Graphics Sprites, Bobs and Animation - Revision history

Costel Mincea: Text replacement - "" to ""

2025-01-26T19:30:36Z

Text replacement - "<syntaxhighlight>" to "<syntaxhighlight lang="C" line>"

← Older revision		Revision as of 19:30, 26 January 2025
Line 99:		Line 99:
	To initialize the animation system, call the system function InitGels(). It takes the form:		To initialize the animation system, call the system function InitGels(). It takes the form:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct VSprite *vsHead;		struct VSprite *vsHead;
	struct VSprite *vsTail;		struct VSprite *vsTail;
Line 139:		Line 139:
	For example, SetCollision() could be called as follows:		For example, SetCollision() could be called as follows:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	ULONG num;		ULONG num;
	VOID (*routine)();		VOID (*routine)();
Line 176:		Line 176:
	In other words, if it takes three 16-bit words to hold one line of a GEL, then you must reserve three words for the BorderLine. In the VSprite examples, the routine makeVSprite() correctly allocates and initializes the collision mask and borderline. For example:		In other words, if it takes three 16-bit words to hold one line of a GEL, then you must reserve three words for the BorderLine. In the VSprite examples, the routine makeVSprite() correctly allocates and initializes the collision mask and borderline. For example:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	WORD myBorderLineData[3]; /* reserve space for BorderLine for this Bob */		WORD myBorderLineData[3]; /* reserve space for BorderLine for this Bob */

Line 272:		Line 272:
	Here is a typical program segment that assigns the members correctly (for boundaries 50, 100, 80, 240). It assumes that you already have a RastPort structure pointer named myRastPort.		Here is a typical program segment that assigns the members correctly (for boundaries 50, 100, 80, 240). It assumes that you already have a RastPort structure pointer named myRastPort.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	myRastPort->GelsInfo->topmost = 50;		myRastPort->GelsInfo->topmost = 50;
	myRastPort->GelsInfo->bottommost = 100;		myRastPort->GelsInfo->bottommost = 100;
Line 309:		Line 309:
	To show the kind of use you can make of this feature, the example below adds speed and acceleration figures to each GEL by extending the VSprite structure. When your collision routine is called, it could use these values to transfer energy between the two colliding objects (say, billiard balls). You would have to set up additional routines, executed between calls to DoCollision(), that would add the values to the GELs position appropriately. You could do this with code similar o the following:		To show the kind of use you can make of this feature, the example below adds speed and acceleration figures to each GEL by extending the VSprite structure. When your collision routine is called, it could use these values to transfer energy between the two colliding objects (say, billiard balls). You would have to set up additional routines, executed between calls to DoCollision(), that would add the values to the GELs position appropriately. You could do this with code similar o the following:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct myInfo		struct myInfo
	{		{
Line 321:		Line 321:
	These members are for example only. You may use any definition for your user extensions. You would then also provide the following line, to extend the VSprites structure, use:		These members are for example only. You may use any definition for your user extensions. You would then also provide the following line, to extend the VSprites structure, use:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	/* Redefine VUserStuff for my own use. */		/* Redefine VUserStuff for my own use. */
	#define VUserStuff struct myInfo		#define VUserStuff struct myInfo
Line 328:		Line 328:
	To extend the Bobs structure, use:		To extend the Bobs structure, use:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#define BUserStuff struct myInfo		#define BUserStuff struct myInfo
	</syntaxhighlight>		</syntaxhighlight>
Line 334:		Line 334:
	To extend the AnimObs structure, use:		To extend the AnimObs structure, use:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#define AUserStuff struct myInfo		#define AUserStuff struct myInfo
	</syntaxhighlight>		</syntaxhighlight>
Line 354:		Line 354:
	The AnimComp (Animation Component), is an extension of the Bob structure discussed in the previous section. An AnimComp provides a convenient way to link together a series of images so that they can be sequenced automatically, and so multiple sequences can be grouped together. An AnimComp is analogous to one sheet of celluloid representing a single image to be placed over the background.		The AnimComp (Animation Component), is an extension of the Bob structure discussed in the previous section. An AnimComp provides a convenient way to link together a series of images so that they can be sequenced automatically, and so multiple sequences can be grouped together. An AnimComp is analogous to one sheet of celluloid representing a single image to be placed over the background.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct AnimComp		struct AnimComp
	{		{
Line 376:		Line 376:
	The second animation data structure is the AnimOb which provides the variables needed for overall control over a group of AnimComps. The AnimOb itself contains no imagery; it simply provides a common reference point for the sequenced images and specifies how the system should move that point.		The second animation data structure is the AnimOb which provides the variables needed for overall control over a group of AnimComps. The AnimOb itself contains no imagery; it simply provides a common reference point for the sequenced images and specifies how the system should move that point.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct AnimOb		struct AnimOb
	{		{
Line 528:		Line 528:
	The system uses one pointer, known as the AnimKey, to keep track of all the AnimObs via their PrevOb and NextOb linkage fields. The AnimKey acts as the anchor for the list of AnimObs you are using and is initialized with code such as the following:		The system uses one pointer, known as the AnimKey, to keep track of all the AnimObs via their PrevOb and NextOb linkage fields. The AnimKey acts as the anchor for the list of AnimObs you are using and is initialized with code such as the following:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct AnimOb *animKey;		struct AnimOb *animKey;

Line 542:		Line 542:
	Use the routine AddAnimOb() to add animation objects to the controlled object list. This routine will link the PrevOb and NextOb pointers to chain all the AnimObs that the system is controlling.		Use the routine AddAnimOb() to add animation objects to the controlled object list. This routine will link the PrevOb and NextOb pointers to chain all the AnimObs that the system is controlling.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct RastPort myRPort;		struct RastPort myRPort;
	struct AnimOb myAnimOb;		struct AnimOb myAnimOb;
Line 562:		Line 562:
	This is illustrated in the following typical call sequence:		This is illustrated in the following typical call sequence:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	struct AnimOb **myAnimKey;		struct AnimOb **myAnimKey;
	struct RastPort *rp;		struct RastPort *rp;
Line 593:		Line 593:
	For example, if you provide a routine such as this:		For example, if you provide a routine such as this:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	VOID MyOCode(struct AnimOb *anOb)		VOID MyOCode(struct AnimOb *anOb)
	{		{
Line 602:		Line 602:
	Then, if you put the address of the routine in an AnimOb structure:		Then, if you put the address of the routine in an AnimOb structure:

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	myAnimOb.AnimORoutine = MyOCode;		myAnimOb.AnimORoutine = MyOCode;
	</syntaxhighlight>		</syntaxhighlight>

Steven Solie: /* Moving the Objects */

2015-11-04T18:02:30Z

Moving the Objects

← Older revision		Revision as of 18:02, 4 November 2015
Line 562:		Line 562:
	This is illustrated in the following typical call sequence:		This is illustrated in the following typical call sequence:

			<syntaxhighlight>
	<pre>
	struct AnimOb **myAnimKey;		struct AnimOb **myAnimKey;
	struct RastPort *rp;		struct RastPort *rp;
Line 569:		Line 569:
	/* ... setup of graphics elements and objects */		/* ... setup of graphics elements and objects */

	Animate(myAnimKey, rp); /* "move" objects per instructions */		IGraphics->Animate(myAnimKey, rp); /* "move" objects per instructions */
	SortGList(rp); /* put them in order */		IGraphics->SortGList(rp); /* put them in order */
	DoCollision(rp); /* software collision detect/action */		IGraphics->DoCollision(rp); /* software collision detect/action */
	SortGList(rp); /* put them back into right order */		IGraphics->SortGList(rp); /* put them back into right order */
	DrawGList(vp, rp); /* draw into current RastPort */		IGraphics->DrawGList(vp, rp); /* draw into current RastPort */
			</syntaxhighlight>
	</pre>

	==== Your own Animation Routine Calls ====		==== Your own Animation Routine Calls ====

	The AnimOb and AnimComp structures can include pointers for your own routines that you want the system to call. These pointers are stored in the ~~AnimOb‚Äôs~~ AnimORoutine field and in the AnimComp's AnimCRoutine field, respectively.		The AnimOb and AnimComp structures can include pointers for your own routines that you want the system to call. These pointers are stored in the AnimOb's AnimORoutine field and in the AnimComp's AnimCRoutine field, respectively.

	When Animate() is called, the system performs the following steps for every AnimOb in the AnimKey list:		When Animate() is called, the system performs the following steps for every AnimOb in the AnimKey list:
Line 593:		Line 593:
	For example, if you provide a routine such as this:		For example, if you provide a routine such as this:

			<syntaxhighlight>
	<pre>
	VOID MyOCode(struct AnimOb *anOb)		VOID MyOCode(struct AnimOb *anOb)
	{		{
	/* whatever needs to be done */		/* whatever needs to be done */
	}		}
			</syntaxhighlight>
	</pre>

	Then, if you put the address of the routine in an AnimOb structure:		Then, if you put the address of the routine in an AnimOb structure:

			<syntaxhighlight>
	<pre>
	myAnimOb.AnimORoutine = MyOCode;		myAnimOb.AnimORoutine = MyOCode;
			</syntaxhighlight>
	</pre>

	MyOCode() will be called with the address of this AnimOb when Animate() processes this AnimOb.		MyOCode() will be called with the address of this AnimOb when Animate() processes this AnimOb.

Steven Solie: /* The AnimKey */

2015-11-04T18:01:09Z

The AnimKey

← Older revision		Revision as of 18:01, 4 November 2015
Line 531:		Line 531:
	struct AnimOb *animKey;		struct AnimOb *animKey;

	InitAnimate(&animKey); /* Only do this once to initialize the AnimOb list */		IGraphics->InitAnimate(&animKey); /* Only do this once to initialize the AnimOb list */
	</syntaxhighlight>		</syntaxhighlight>

Steven Solie: /* Adding Animation Objects */

2015-11-04T18:00:55Z

Adding Animation Objects

← Older revision		Revision as of 18:00, 4 November 2015
Line 542:		Line 542:
	Use the routine AddAnimOb() to add animation objects to the controlled object list. This routine will link the PrevOb and NextOb pointers to chain all the AnimObs that the system is controlling.		Use the routine AddAnimOb() to add animation objects to the controlled object list. This routine will link the PrevOb and NextOb pointers to chain all the AnimObs that the system is controlling.

			<syntaxhighlight>
	<pre>
	struct RastPort myRPort;		struct RastPort myRPort;
	struct AnimOb myAnimOb;		struct AnimOb myAnimOb;
	struct AnimOb animKey; / Must be initialized with InitAnimate() */		struct AnimOb animKey; / Must be initialized with InitAnimate() */

	AddAnimOb(&~~amp;~~myAnimOb, &~~amp;~~animKey, &~~amp;~~myRPort);		IGraphics->AddAnimOb(&myAnimOb, &animKey, &myRPort);
			</syntaxhighlight>
	</pre>

	=== Moving the Objects ===		=== Moving the Objects ===

Steven Solie: /* The AnimKey */

2015-11-04T18:00:14Z

The AnimKey

← Older revision		Revision as of 18:00, 4 November 2015
Line 528:		Line 528:
	The system uses one pointer, known as the AnimKey, to keep track of all the AnimObs via their PrevOb and NextOb linkage fields. The AnimKey acts as the anchor for the list of AnimObs you are using and is initialized with code such as the following:		The system uses one pointer, known as the AnimKey, to keep track of all the AnimObs via their PrevOb and NextOb linkage fields. The AnimKey acts as the anchor for the list of AnimObs you are using and is initialized with code such as the following:

			<syntaxhighlight>
	<pre>
	struct AnimOb *animKey;		struct AnimOb *animKey;

	InitAnimate(&~~amp;~~animKey); /* Only do this once to initialize the AnimOb list */		InitAnimate(&animKey); /* Only do this once to initialize the AnimOb list */
			</syntaxhighlight>
	</pre>

	As each new object is added (via AddAnimOb()), it is linked in at the beginning of the list, so AnimKey will always point to the object most recently added to the list. To search forward through the list, start with the AnimKey and move forward on the NextOb link. Continue to move forward until the NextOb is NULL, indicating the end of the list. The PrevOb link will allow you to move back to a previous object.		As each new object is added (via AddAnimOb()), it is linked in at the beginning of the list, so AnimKey will always point to the object most recently added to the list. To search forward through the list, start with the AnimKey and move forward on the NextOb link. Continue to move forward until the NextOb is NULL, indicating the end of the list. The PrevOb link will allow you to move back to a previous object.

Steven Solie: /* Animation Data Structures */

2015-11-04T17:59:41Z

Animation Data Structures

← Older revision		Revision as of 17:59, 4 November 2015
Line 354:		Line 354:
	The AnimComp (Animation Component), is an extension of the Bob structure discussed in the previous section. An AnimComp provides a convenient way to link together a series of images so that they can be sequenced automatically, and so multiple sequences can be grouped together. An AnimComp is analogous to one sheet of celluloid representing a single image to be placed over the background.		The AnimComp (Animation Component), is an extension of the Bob structure discussed in the previous section. An AnimComp provides a convenient way to link together a series of images so that they can be sequenced automatically, and so multiple sequences can be grouped together. An AnimComp is analogous to one sheet of celluloid representing a single image to be placed over the background.

			<syntaxhighlight>
	<pre>
	struct AnimComp		struct AnimComp
	{		{
Line 370:		Line 370:
	struct Bob AnimBob; / Underlying Bob structure for this AnimComp */		struct Bob AnimBob; / Underlying Bob structure for this AnimComp */
	};		};
			</syntaxhighlight>
	</pre>

	The AnimComp structure contains pointers, PrevSeq and NextSeq, that lets you group these cells into stacks that will be viewed sequentially. The AnimComp structure also has PrevComp and NextComp pointers that let you group stacks into complex objects containing multiple independently moving parts.		The AnimComp structure contains pointers, PrevSeq and NextSeq, that lets you group these cells into stacks that will be viewed sequentially. The AnimComp structure also has PrevComp and NextComp pointers that let you group stacks into complex objects containing multiple independently moving parts.
Line 376:		Line 376:
	The second animation data structure is the AnimOb which provides the variables needed for overall control over a group of AnimComps. The AnimOb itself contains no imagery; it simply provides a common reference point for the sequenced images and specifies how the system should move that point.		The second animation data structure is the AnimOb which provides the variables needed for overall control over a group of AnimComps. The AnimOb itself contains no imagery; it simply provides a common reference point for the sequenced images and specifies how the system should move that point.

			<syntaxhighlight>
	<pre>
	struct AnimOb		struct AnimOb
	{		{
Line 390:		Line 390:
	AUserStuff AUserExt; /* AnimOb user extension */		AUserStuff AUserExt; /* AnimOb user extension */
	};		};
			</syntaxhighlight>
	</pre>

	These structures can be used in various ways. A simple animation of a rotating ball could be created with three or four AnimComps linked together in a circular list by their NextSeq and PrevSeq fields. The system displays the initial AnimComp (the "top of the stack"), then switches to the AnimComp pointed to by NextSeq, and then switches to ''its'' NextSeq and so on until it reaches the end of the sequence. The sequence starts over again automatically if the last AnimComp.NextSeq points back to the first AnimComp in the stack.		These structures can be used in various ways. A simple animation of a rotating ball could be created with three or four AnimComps linked together in a circular list by their NextSeq and PrevSeq fields. The system displays the initial AnimComp (the "top of the stack"), then switches to the AnimComp pointed to by NextSeq, and then switches to ''its'' NextSeq and so on until it reaches the end of the sequence. The sequence starts over again automatically if the last AnimComp.NextSeq points back to the first AnimComp in the stack.

Steven Solie: /* Adding User Extensions to GEL Data Structures */

2015-11-04T17:59:11Z

Adding User Extensions to GEL Data Structures

← Older revision		Revision as of 17:59, 4 November 2015
Line 309:		Line 309:
	To show the kind of use you can make of this feature, the example below adds speed and acceleration figures to each GEL by extending the VSprite structure. When your collision routine is called, it could use these values to transfer energy between the two colliding objects (say, billiard balls). You would have to set up additional routines, executed between calls to DoCollision(), that would add the values to the GELs position appropriately. You could do this with code similar o the following:		To show the kind of use you can make of this feature, the example below adds speed and acceleration figures to each GEL by extending the VSprite structure. When your collision routine is called, it could use these values to transfer energy between the two colliding objects (say, billiard balls). You would have to set up additional routines, executed between calls to DoCollision(), that would add the values to the GELs position appropriately. You could do this with code similar o the following:

			<syntaxhighlight>
	<pre>
	struct myInfo		struct myInfo
	{		{
Line 317:		Line 317:
	short yaccel;		short yaccel;
	};		};
			</syntaxhighlight>
	</pre>

	These members are for example only. You may use any definition for your user extensions. You would then also provide the following line, to extend the VSprites structure, use:		These members are for example only. You may use any definition for your user extensions. You would then also provide the following line, to extend the VSprites structure, use:

			<syntaxhighlight>
	<pre>
	/* Redefine VUserStuff for my own use. */		/* Redefine VUserStuff for my own use. */
	#define VUserStuff struct myInfo		#define VUserStuff struct myInfo
			</syntaxhighlight>
	</pre>

	To extend the Bobs structure, use:		To extend the Bobs structure, use:

			<syntaxhighlight>
	<pre>
	#define BUserStuff struct myInfo		#define BUserStuff struct myInfo
			</syntaxhighlight>
	</pre>

	To extend the AnimObs structure, use:		To extend the AnimObs structure, use:

			<syntaxhighlight>
	<pre>
	#define AUserStuff struct myInfo		#define AUserStuff struct myInfo
			</syntaxhighlight>
	</pre>

	When the system is compiling the <graphics/gels.h> file with your program, the compiler preprocessor substitutes "struct myInfo" everywhere that UserExt is used in the header. The structure is thereby customized to include the items you wish to associate with it.		When the system is compiling the <graphics/gels.h> file with your program, the compiler preprocessor substitutes "struct myInfo" everywhere that UserExt is used in the header. The structure is thereby customized to include the items you wish to associate with it.

Steven Solie: /* "animtools.h" and "animtools.c" */

2015-11-04T17:58:15Z

"animtools.h" and "animtools.c"

← Older revision		Revision as of 17:58, 4 November 2015
Line 626:		Line 626:
	=== "animtools.h" and "animtools.c" ===		=== "animtools.h" and "animtools.c" ===

	Here is the listing of the "animtools.h" header file and the "animtools.c" link file used by the examples in this ~~chapter~~. The makeSeq() and makeComp() subroutines here demonstrate how to use the GELs animation system.		Here is the listing of the "animtools.h" header file and the "animtools.c" link file used by the examples in this article. The makeSeq() and makeComp() subroutines here demonstrate how to use the GELs animation system.

	<pre>		<pre>

Steven Solie: /* Initializing the GEL System */

2015-11-04T17:57:50Z

Initializing the GEL System

← Older revision		Revision as of 17:57, 4 November 2015
Line 111:		Line 111:
	InitGels() forms these structures into a linked list of GELs that is empty except for these two dummy elements (the head and tail). It gives the head VSprite the maximum negative ''x'' and ''y'' positions and the tail VSprite the maximum positive ''x'' and ''y'' positions. This is to aid the system in keeping the list sorted by ''x, y'' values, so GELs that are closer to the top and left of the display are nearer the head of the list. The memory space that the VSprites and Gelsinfo structures take up must already have been allocated. This can be done either by declaring them statically or explicitly allocating memory for them.		InitGels() forms these structures into a linked list of GELs that is empty except for these two dummy elements (the head and tail). It gives the head VSprite the maximum negative ''x'' and ''y'' positions and the tail VSprite the maximum positive ''x'' and ''y'' positions. This is to aid the system in keeping the list sorted by ''x, y'' values, so GELs that are closer to the top and left of the display are nearer the head of the list. The memory space that the VSprites and Gelsinfo structures take up must already have been allocated. This can be done either by declaring them statically or explicitly allocating memory for them.

	Once the GelsInfo structure has been allocated and initialized, GELs can be added to the system. Refer to the setupGelSys() and cleanupGelsys() functions in the ~~‚Äúanimtools~~.~~c‚Äù~~ lisitng at the end of the ~~chapter~~ for examples of allocating, initializing and freeing a GelsInfo structure.		Once the GelsInfo structure has been allocated and initialized, GELs can be added to the system. Refer to the setupGelSys() and cleanupGelsys() functions in the "animtools.c" lisitng at the end of the article for examples of allocating, initializing and freeing a GelsInfo structure.

	== Collisions and GEL Structure Extensions ==		== Collisions and GEL Structure Extensions ==

Steven Solie: /* VSprite HitMask and MeMask */

2015-11-04T17:57:19Z

VSprite HitMask and MeMask

← Older revision		Revision as of 17:57, 4 November 2015
Line 206:		Line 206:
	* If the collision is with the boundary, bit 0 is always a 1 and the system calls the collision handling routine number 0. Always assign the routine that handles boundary collisions to vector 0 in the collision handling table.		* If the collision is with the boundary, bit 0 is always a 1 and the system calls the collision handling routine number 0. Always assign the routine that handles boundary collisions to vector 0 in the collision handling table.

	* The system uses the flag called BORDERHIT to indicate that an object has landed on or moved beyond the outermost bounds of the drawing area (the edge of the clipping region). The VSprite example earlier in this ~~chapter~~ uses collision detection to check for border hits.		* The system uses the flag called BORDERHIT to indicate that an object has landed on or moved beyond the outermost bounds of the drawing area (the edge of the clipping region). The VSprite example earlier in this article uses collision detection to check for border hits.

	* If any one of the other bits (1 to 15) is set, then the system calls your collision handling routine corresponding to the bit set.		* If any one of the other bits (1 to 15) is set, then the system calls your collision handling routine corresponding to the bit set.