Bobs are used for animation on the Amiga, the main advantage over Sprites is
that you can have a lot more of them and can be of any size. Bobs are controlled
by the blitter which can move large graphics areas around very fast.
To define a bob you need to specify data using layers, each layer can have 2
colours, the colours are defined by the current palette. You can also specify
plane pick to select which colours the bob uses. Here is a sample bob setup
using two alternate images (see Bob.c from the Rom Kernel Manual's Lib Examples):
#define GEL_SIZE 4 /* number of lines in the bob */
/* Bob data - two sets that are alternated between. Note that this */
/* data is at the resolution of the screen. */
/* data is 2 planes by 2 words by GEL_SIZE lines */
WORD chip bob_data1[2 * 2 * GEL_SIZE] =
{
/* plane 1 */
0xffff, 0x0003, 0xfff0, 0x0003, 0xfff0, 0x0003, 0xffff, 0x0003,
/* plane 2 */
0x3fff, 0xfffc, 0x3ff0, 0x0ffc, 0x3ff0, 0x0ffc, 0x3fff, 0xfffc
};
/* data is 2 planes by 2 words by GEL_SIZE lines */
WORD chip bob_data2[2 * 2 * GEL_SIZE] =
{
/* plane 1 */
0xc000, 0xffff, 0xc000, 0x0fff, 0xc000, 0x0fff, 0xc000, 0xffff,
/* plane 2 */
0x3fff, 0xfffc, 0x3ff0, 0x0ffc, 0x3ff0, 0x0ffc, 0x3fff, 0xfffc
};
NEWBOB myNewBob = /* Data for the new bob structure defined in animtools.h
*/
{ /* Initial image, WORD width, line height */
bob_data2, 2, GEL_SIZE, /* Image depth, plane pick, plane
on off, VSprite flags */
2, 3, 0, SAVEBACK | OVERLAY, /* dbuf (0=false), raster depth,
x,y position, hit mask, */
0, 2, 160, 100, 0,0, /* me mask */
};
This is the structure for the Window to place the Bob into, it is a 400 x 150 window placed on the Workbench screen:
struct NewWindow myNewWindow =
{ /* information for the new window */
80, 20, 400, 150, -1, -1, CLOSEWINDOW | INTUITICKS,
ACTIVATE | WINDOWCLOSE | WINDOWDEPTH | RMBTRAP,
NULL, NULL, "Bob", NULL, NULL, 0, 0, 0, 0, WBENCHSCREEN
};
Now draw the bob on the window with the bobDrawGList() function. rport is a
pointer to to the rastport ie the Window's bitmap
structuture and vport is a portion of the physical display to be viewed, you
can have multiple viewports on one display seperated by
a least one blank line.
Functions:
void SortGList(struct RastPort *rp)
void DrawGList(struct RastPort *rp, struct ViewPort *vp)
void WaitTOF(void)
/* Draw the Bobs into the RastPort. */
VOID bobDrawGList(struct RastPort *rport, struct ViewPort *vport)
{
/* This function sorts the gel list by its x,y co-ords,
required before DrawGList */
SortGList(rport);
/* This function draws all the gels including bobs and
vsprites */
DrawGList(rport, vport);
/* If the GelsList includes true VSprites, MrgCop()
and LoadView() here */
WaitTOF() ; /* Wait for next top of frame refresh interval
before continuing */
}
The next bit of code does the actual display and starts animation of Bobs.
You need a Bob structure to store the bob information.
The most useful functions are:
Functions:
void AddBob(struct Bob *bob, struct RaspPort *rp) - Add a bob to the current
gel list.
void RemBob(struct Bob *bob) - Remove bob from the current gel list.
void InitMasks(struct VSprite *vs) - Initialises BorderLine and CollMask of
a VSprite or bob.
VOID do_Bob(struct Window *win)
{
struct Bob *myBob;
struct GelsInfo *my_ginfo;
if (NULL == (my_ginfo = setupGelSys(win->RPort, 0x03)))
return_code = RETURN_WARN;
else
{
/* Create the Bob using makeBob() from Animtools.c to allocate
memory and fill in the required information for Bob structure
to create the Bob object */
if (NULL == (myBob = makeBob(&myNewBob)))
return_code = RETURN_WARN;
else
{
/* Add the bob to the
window's rastport ready for display */
AddBob(myBob, win->RPort);
/* Display the gels (bobs)
in the given window and viewport */
bobDrawGList(win->RPort,
ViewPortAddress(win));
/* do animation in this
function */
process_window(win, myBob);
/* When done, remove bob from
system */
RemBob(myBob);
/* Update the display to remove
it from the screen */
bobDrawGList(win->RPort,
ViewPortAddress(win));
/* Free up any memory uses by bob
*/
freeBob(myBob, myNewBob.nb_RasDepth);
}
cleanupGelSys(my_ginfo,win->RPort);
}
}
Finally the code that does the animation which in this case moves the Bob depending
on mouse movement using the values
of the MouseX and MouseY values with a sight offset and changing the X and Y
values of the bob object. It will also change
the bob's image by changing the ImageData value to different images defined
earlier.
VOID process_window(struct Window *win, struct Bob *myBob)
{
struct IntuiMessage *msg;
/* FOREVER is equivalent to an empty for() loop that never ends */
FOREVER {
/* Wait for a signal bit to be returned from the window */
Wait(1L << win->UserPort->mp_SigBit);
/* If a message is received from window then process it */
while (NULL != (msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
{
/* only CLOSEWINDOW and INTUITICKS are active */
if (msg->Class == CLOSEWINDOW)
{
/* If the CloseWindows gadget is pressed,
then reply and exit this function */
ReplyMsg((struct Message *)msg);
return;
}
/* Must be INTUITICKS: change x and y values on the fly. Note:
** do not have to add window offset, Bob is relative to the
** window (sprite relative to screen).
*/
myBob->BobVSprite->X = msg->MouseX + 20;
myBob->BobVSprite->Y = msg->MouseY + 1;
ReplyMsg((struct Message *)msg);
}
/* after getting a message, change image data on the fly */
myBob->BobVSprite->ImageData =
(myBob->BobVSprite->ImageData == bob_data1) ? bob_data2 :
bob_data1;
InitMasks(myBob->BobVSprite); /* set up masks for new image */
bobDrawGList(win->RPort, ViewPortAddress(win));
}
}