How To Make an Animated Pointer
(ReadMeSecond)

This file describes how to make an animation for the pointer animator.  If
you haven't read it already, please read "ReadMeFirst" for information on
how to call the pointer animator with a predefined animation.  Also, if you
haven't run the pointer animator, please do so before reading the rest of
this file.  I feel it will make some of the descriptions easier to
understand.


What's an Animation? (a short history)

If you've never seen a television or watched a Disney movie, this
description isn't going to mean much to you.  You have some outside research
to do.  I expect you have seen Tweety outsmart Sylvester, Jerry do horrible
things to Tom and the coyote fall off cliffs hundreds of times and therefore
understand what animation is.  While you are not going to produce anything
that even remotely resembles a really good animation using the pointer
animator, the concepts are the same and with some imagination, you can make
animations which will hold people's interest, amuse them or get your message
across.

An animation is a series of still frames.  Each of the frames represents a
point in time.  By showing the frames rapidly, in sequence, an illusion of
motion is created.  The shorter the time between frames, the more smooth
the animation appears and the more frames needed to represent the same total
time.

The maximum speed of a pointer animation varies depending on which version
of Amiga you have.  If you live in North America, chances are pretty good
your maximum rate is 60 frames per second.  If you live somewhere else, your
maximum rate is probably 50 frames per second.


What You Need to Make an Animation

A good paint program, a good imagination, the pointer animator programs and
of course an Amiga are all you really need to produce pointer animations.
Of all the things required, the only one I plan to comment on is the paint
program.  It should be able to select 2 or 4 bit planes (this is the same as
4 or 16 maximum colors).  It must also be able to save rectangular brushes
from 1 to 32 pixels wide in an IFF ILBM format file.  Luckily, most paint
programs will let you do both of these things.  If you have one that
doesn't, write to the manufacturer and let them know you wish it did.
Another useful but not absolutely necessary function is the ability to
display the X,Y position of the cursor.  Of course, beyond the basic
functions of the paint program, you should feel comfortable with it.  The
paint program I use is Deluxe Paint Version 2.0 by Electronic Arts.


Planning Your Animation

Before you start actually working on your animation, I suggest you sit down
and think about what you want to produce.  The animated pointer has several
limitations when compared to other forms of animation.

First is the size of the pointer.  Your animation cannot be wider than 32
lo-res pixels.  Because of the way the Amiga's hardware handles sprites, the
aspect ratio of your pointer will be the same whatever the resolution of the
screen is.

Secondly you need to decide how many colors you want to use.  You have two
choices; 3 and 15.  The normal Workbench pointer uses three colors.  If you
can produce your animation using only three colors, your pointer will work
properly with almost every program.  Again because of the way the Amiga's
hardware works, by using fifteen colors, you are using up the colors for all
of the hardware sprites.  This shouldn't normally matter because not many
programs use the hardware sprites.  Also, any program that opens a screen
after the pointer animator has started, will get the proper lower three
colors, but the upper twelve colors will be set to the system's default
colors (by designing your pointer with the default colors you can get rid of
this problem.)

OK, now you know most of the limitations of the animation system.  It's time
to discuss the actual animation.  The pointer animations are loops.  That
means that as soon as the last frame has been displayed, the first frame is
displayed again.  When you are working out an animation concept, you should
take that into account.  For example, it would be hard to make a "clean"
animation of a breaking vase.  After the vase had broken and the pieces were
laying at the bottom of the frame, how would you explain the vase becoming
whole again when the loop restarted?

A much better animation would be a bouncing ball.  The ball could start at
the top, fall to the bottom and then bounce back to the top where the loop
could repeat.  This brings up another point.  Although it's a matter of
style, I personally feel that it is best not to draw attention to the fact
that the pointer size is limited.  In the ball example, I feel it would be
preferable to have some visible object at the bottom of the pointer for the
ball to bounce off of.  Of course the object at the bottom would itself
point out the bottom of the pointer, but it wouldn't look as though the ball
was bouncing off the image boundary.

Another idea to keep in mind is that a pointer should be useful for pointing.
To be easy to use, a pointer should contain at least one point that doesn't
move.  This point can be anywhere in the pointer although the top left
corner is customary.  It is also good if the pointer has a couple of
contrasting colors close together so that the pointer will stand out on any
possible background.

Once you have your animation concept, you should storyboard it.  That is,
you should draw some rough sketches of what you hope to accomplish and
annotate them with the approximate amount of time between each sketch.  If
your animation is extremely simple (like most of mine) the storyboard itself
can be made into your final animation.  But if you are planning a more
complicated animation (and I hope you are) you will probably have several
frames in the final animation between each sketch of your storyboard.

After you have your idea storyboarded you can probably estimate the tallest
frame you will need.  If you can fit it in it is best to keep your pointer
16 pixels high since this is the one variable that can be changed to really
screw up the appearance of an animation (and the default height is 16.)


Drawing Your Animation

Now, you have all the tools you need and you have a well thought out idea to
make the animation from.  There is a drawing in this archive called
"DesignGrid".  I used this drawing as a guide while I was drawing my first
animations.  Along the left side are some 16 pixel wide columns.  They are
divided by things that look like ladders.  The "rungs" of these ladders are
16 pixels apart.  On the right side are many boxes.  The inside dimensions of
these boxes are 16x16 pixels.  The reason for 16x16 is that this is the
normal maximum pointer size.

To use this guide, first pick the colors you plan to use.  The first color
(color zero) will be transparent in the completed pointer.  Draw any objects
which will remain stationary into one of the boxes.  Then cut that box out
as a brush, and paste it into all of the other boxes to use as a guide.
Then go back and start drawing in the rest of the frames.

When you are done with a large number of the frames, arrange them for
saving.  Cut out the first frame, making sure to cut just inside the top and
bottom.  Leave the sides on for a guide in placing the brush.  Put the brush
at the top of the first column on the left side.  Make sure to line up the
bottoms of the box sides with the first rung of the ladders.  Then continue
cutting out each frame in turn and placing it in the column below the last
frame.  When you are done with the first column, go to the top of the next.
The most important thing to remember here is that the frames should all be
the same height.  After all the frames are pasted into columns, cut out an
entire column as a brush, and save it to disk.  Make sure you cut just
inside of the ladders so that the brush will be sixteen pixels wide.  Also
make sure that the height of each brush is an exact multiple of the height
of one frame.  When you have all of the columns saved, you are ready to merge
them into one animation.


Using merge

One of the programs supplied with the pointer animator is called "merge".  It
must be run from the CLI.  It is used to add columns of frames end to end.
It can also be used to add a message to the front of your animation.  The
calling syntax of merge is:

merge <out file> [-t<text file>] <in file1> [<in file2>...[in filen]]

Where: <out file> is the combination of all the input files.  Don't use the
           same name for <out file> as for one of the <in files>.  This would
           cause hard feelings and quite possibly cause you to lose the
           contents of your file.
       <text file> is a standard ASCII text file (NOT an IFF file)
       <in file> each input file is an IFF ILBM file.  All the files must be
           the same number of colors and the same width.  Only the color map
           from the first file is saved.  Any other "extraneous" information,
           such as color range, is discarded.

As an example let's suppose we have just finished an animation of a fish
swimming, to send off to Fred.  We want to produce a file called "Fish" we
have four column files named "col1", "col2", "col3" and "col4".  In addition
we have a text file named "fishtext" which contains the following paragraph.

I am dedicating this animation to Fred Fish.  I would like to express
my appreciation for what Mr. Fish has done for the Amiga community.
Thank you Fred.
TRK 4-10-88

To put all this together you would type:

merge Fish -tfishtext col1 col2 col3 col4

Now we have a file named "Fish".  While we are in the CLI, we might as well
make the .info file for our animation.  As luck would have it, we have
another animation named "Flag".  So we will make a copy of its .info file
for our new file.  Type:

copy Flag.info Fish.info

For information on executing your new animation, refer back to
"ReadMeFirst".

If you have any specific questions or comments, please send them along with
your shareware payment to:

Tim Kemp
P.O. Box 23101
Columbus, OH 43223