SDL::Tutorial::Images(User Contributed Perl DocumentatSDL::Tutorial::Images(3)NAMESDL::Tutorial::ImagesSYNOPSIS
# 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.
perl v5.14.1 2011-07-18 SDL::Tutorial::Images(3)
