SDL::Tutorial::Images(3p)

NAME
SDL::Tutorial::Images

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

        # to create a demo animation program based on this tutorial
        $ perl -MSDL::Tutorial::Images=sdl_images.pl -e 1

ANIMATING IMAGES
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 second.

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:

        $source_surface->blit(
                $area_of_source_to_blit,
                $destination_surface,
                $destination_area
        );

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.

SEE ALSO

SDL::Tutorial
    basic SDL tutorial

SDL::Tutorial::Animation
    non-image animation

AUTHOR
chromatic, <chromatic@wgz.org>

Written for and maintained by the Perl SDL project, <http://sdl.perl.org/>.

BUGS
No known bugs.

COPYRIGHT
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.