Provided by: libsdl-perl_2.2.5-1build2_amd64 bug




               # to read this tutorial
               $ perldoc SDL::Tutorial::Images

               # to create a demo animation program based on this tutorial
               $ perl -e 1


       Since you're already familiar with the concepts behind animation, it's time to learn how
       to work with images.  As usual, the important point is that computer animation is just
       simulating motion by painting several slightly different frames to the screen every

       There are two ways to vary an image on screen.  One is to change its coordinates so it's
       at a slightly different position.  This is very easy to do; it's just like animating a
       rectangle.  The other way is to change the image itself so it's slightly different.  This
       is a little more difficult, as you'll need to draw the alternate image beforehand somehow.

   Loading Images
       As usual, start with an SDL::App object representing the image window.  Then preload the
       image file.  This is easy; just pass the "name" parameter to the SDL::Surface constructor:

               use SDL::Surface;

               my $frame = SDL::Surface->new( -name => 'frame1.png' );

       Note: you'll need to have compiled SDL Perl (and probably SDL) to support JPEG and PNG
       files for this to work.

       That's it; now you have an SDL::Surface object containing the image.  You can use the
       "height()", "width()", and "bpp()" methods to retrieve its height, width, and bits per
       pixel, if you need them.

   Displaying Images
       Drawing an image onto the screen requires blitting it from one surface to another.
       (Remember, "blitting" means copying bits in memory.)  The "blit()" method of SDL::Surface
       objects comes in handy.  Its arguments are a little odd, though.  Assuming $app is the
       SDL::App object, as usual:

               use SDL::Rect;

               my $frame_rect = SDL::Rect->new(
                       -height => $frame->height(),
                       -width  => $frame->width(),
                       -x      => 0,
                       -y      => 0,

               my $dest_rect  = SDL::Rect->new(
                       -height => $frame->height(),
                       -width  => $frame->width(),
                       -x      => 0,
                       -y      => 0,

               $frame->blit( $frame_rect, $app, $dest_rect );
               $app->update( $dest_rect );

       Here we have two SDL::Rect objects which represent rectangular regions of a Surface.
       $frame_rect represents the entire area of $frame, while $dest_rect represents the area of
       the main window in which to blit the frame.  This may be clearer with more descriptive
       variable names:


       As usual, call "update()" on $app to see the change.

       Requiring the source and destination Rect objects may seem tedious in this simple example,
       but it's highly useful for copying only part of surface to part of another.  For example,
       animating this image is a matter of changing the "x" and "y" coordinates of $dest_rect:

               for my $x ( 1 .. 100 )
                       $dest_rect->x( $x );
                       $frame->blit( $frame_rect, $app, $dest_rect );
                       $app->update( $dest_rect );

       Of course, you'll have to redraw all or part of the screen to avoid artifacts, as
       discussed in the previous tutorial.

   Multi-Image Animation
       That covers moving a single image around the screen.  What if you want something more?
       For example, what if you want to animate a stick figure walking?

       You'll need several frames, just as in a flip-book.  Each frame should be slightly
       different than the one before it.  It's probably handy to encapsulate all of this in a
       "Walker" class:

               package Walker;

               use SDL::Surface;

               sub new
                       my ($class, @images) = @_;
                       my $self = [ map { SDL::Surface->new( -name => $_ ) } @images ];

                       bless $self, $class;

               sub next_frame
                       my $self  = shift;
                       my $frame = shift @$self;

                       push @$self, $frame;
                       return $frame;

       To use this class, instantiate an object:

               my $walker = Walker->new( 'frame1.png', 'frame2.png', 'frame3.png' );

       Then call "next_frame()" within the loop:

               for my $x ( 1 .. 100 )
                       my $frame = $walker->next_frame();

                       $dest_rect->x( $x );
                       $frame->blit( $frame_rect, $app, $dest_rect );
                       $app->update( $dest_rect );

       Again, the rest of the frame drawing is missing from this example so as not to distract
       from this technique.  You'll probably want to abstract the undrawing and redrawing into a
       separate subroutine so you don't have to worry about it every time.

       It'd be easy to make "next_frame()" much smarter, selecting an image appropriate to the
       direction of travel, using a bored animation when the character is no longer moving, or
       adding other characteristics to the character.  As you can see, the hard part of this
       technique is generating the images beforehand.  That can add up to a tremendous amount of
       art and that's one reason for the popularity of 3D models... but that's another tutorial
       much further down the road.

       More importantly, it's time to discuss how to make these animations run more smoothly.
       More on that next time.


           basic SDL tutorial

           non-image animation


       chromatic, <>

       Written for and maintained by the Perl SDL project, <>.


       No known bugs.


       Copyright (c) 2004, chromatic.  All rights reserved.  This module is distributed under the
       same terms as Perl itself, in the hope that it is useful but certainly under no guarantee.