Amiga Format 10/af010.adf/PointerAnimator/pointeranimator.doc

Text File | 1978-12-28 | 13.1 KB | 258 lines

                       POINTER ANIMATOR!
                      (C)1988 By Tim Kemp
                        ** SHAREWARE **
How To Use the Pointer Animator

Introduction:
Pointer animator animates the Workbench pointer by substituting its own
custom pointer and then rapidly changing the pointer image to cause the
animation. The image sequences are standard IFF ILBM files; allowing you
to easily edit predefined animations and create your own! In addition to
the normal three color pointer, the pointer animator also supports a 15
color pointer!

Our eyes are specially designed to detect motion. On a normal Workbench
screen with a good contrast between the pointer and display colors, you can
easily distinguish the position of the pointer. On a 32 color screen, it
can be difficult to identify the pointer. Even with very similar colors, an
animated pointer is easy to spot.

Starting an Animation:

To run a pointer animation from the Workbench, all you need to do is double
click on the animation's icon. Running from CLI is only slightly more
difficult. If the pointer will work with the default values (listed below),
just type: pointeranimator <filename>

If the pointer doesn't work well with the default values, you can change
several parameters on the command line (or in the .info file, from the
Workbench.) You can enter as many of these parameters as you need, as flags
on the command line:

s - speed. (Range= 1-9, Default is 5, or 12 frames/second)
(1 = 60 frames/second; the fastest speed) To determine the number of
images/second, divide 60 (50 for European machines) by the speed.

h - height.  The height in picture elements, or "pixels" (Range= 1-255)
If you are using a predefined animation, it will already have a specific
height. If you specify the wrong height, the animation will roll like a
TV with the vertical sync misadjusted. The default height is 16 pixels.

x - horizontal offset. Even though the pointer covers an area 16 pixels
wide and many pixels high, there is only one pixel position where the pointer
actually is; the "hot spot" of the pointer. On most standard pointers, the
hot spot is near the upper left corner. You can put this spot wherever you
want. The horizontal offset is measured in number of pixels right of the
left side of the pointer. The default value is 0.

y - vertical offset. This value, together with the horizontal position,
determines the position of the hot spot. The vertical offset is measured in
pixels down from the top edge. The default value is 0.

EXAMPLE: pointer animator shock -s3 -x1 -y1

uses the animation sequence stored in the file "Shock". It causes the
animation speed to be 20 frames per second and the hot spot to be one pixel
down and to the right of the top left corner of the pointer. This command
could easily be inserted into your Startup-Sequence to cause the pointer
animator to be automatically invoked when you turn on your Amiga.

You can also set these parameters from the Workbench. First select the file
by clicking once on the animation file's icon. Then select "Info" from the
Workbench menu.  The bottom line of the window that appears should be
labeled "TOOL TYPES". It will probably contain a line that says something
like "SPEED=5". This line corresponds to the 's' flag. By using the up and
down arrow gadgets you can step though all of the parameters. They should
read something like this:

SPEED=5
HEIGHT=16
X OFFSET=0
Y OFFSET=0

If any of these are missing, you can add them by clicking on the "ADD"
gadget. When you are done, click on "SAVE" to keep the changes you made.
(Warning: There is a well-known bug in 1.2 which sometimes makes it very
frustrating to enter several tool types without getting everything screwed up
when the info window is saved. Check the info window again after saving)

Stopping the Animation:

If for some reason you need to stop an animated pointer, double click on the
"PointerStopper" icon, or run "PointerStopper" from the CLI. If you are just
switching between animations, it will be done automatically.

For More Fun:

I strongly suggest you go make some of your own animations. It's very easy
and the results are often better than you would have expected.

How To Make an Animated Pointer:

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 & 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; otherwise you may have 50.

What You Need to Make an Animation:

A good paint program, a good imagination, & the pointer animator programs
are all you need to produce pointer animations. The Paint Program should
be able to select 2 or 4 bit planes (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. Another useful function is the ability to display the X,Y
position of the cursor. I use 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 pointer size: Your animation cannot be wider than 32 lo-res pixels.

Secondly, you must 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, & 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.
USAGE:

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

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

If You Use Pointer Animator...

If you use it please pay for it. If I distributed this commercially I would
charge between $10 and $20. I won't ask for a particular amount, but please
use these values as guidelines. In addition to the money, I would be glad to
hear any comments or suggestions on any of my programs. Please send all
correspondence to:

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