However, when AntiAlias is ON, if two sprites are overlaid by using semitranslucent sprites, the edges of the bottom sprite may affect the edges of the top sprite. Since this cannot be avoided, please keep this in mind when using G_RM_XLU_SPRITE.

The Texture Load GBI
The sprite drawing process for S2DEX was described in the sprite GBI section. Here, we will describe the TMEM load process, which is another important operation.

uObjTxtr Structure
In the Texture Load GBI, three different texture types are processed by the same GBI. These three different types (methods) are distinguished by uObjTxtr structure's member variable type, which is provided to the GBI. These three methods are shown below.

1. Texture load using LoadBlock

2. Texture load using LoadTile

3. TLUT load

Texture load using LoadBlock can be faster than texture load using LoadTile; however, there is a limitation to loadable texture width. Since this limitation is the same as "LoadBlock."

Corresponding to the three different methods, three different data structures are defined. These data structures are constructed the same way, having different member variable names. These data structures are combined into a union (uObjTxtr structure).

1. Texture load structure uObjTxtrBlock_t for using Loadblock

   typedef struct		{
     u32		type;	 // by type G_OBJLT_TXTRBLOCK
     u64		*image;		 // texture source address on DRAM
     u16		tmem;		 // TMEM word address of loading destination (8byteWORD)
     u16		tsize;		 // texture size specified by macro GS_TB_TSIZE()
     u16		tline;		 // texture width specified by macro GS_TB_TLINE()
     u16		sid;		 // Status ID  { 0, 4, 8, or 12 } 
     u32		flag;		 // Status flag
     u32		mask;		 // Status mask
   	} uObjTxtrBlock_t;	 	 // 24 bytes
   

2. Texture load structure uObjTxtrTile_t for using LoadTile

   typedef struct		{
     u32		type;		// by type G_OBJLT_TXTRTILE
     u64		*image;	// texture source address on DRAM
     u16		tmem;		// TMEM word address of loading destination (8byteWORD)
     u16		twidth;	// Texture width specified by macro GS_TT_TWIDTH()
     u16		theight;	// Texture height specified by macro GS_TT_THEIGHT()
     u16		sid;		// Status ID  { 0, 4, 8, or 12 } 
     u32		flag;		// Status flag
     u32		mask;		// Status mask
   	} uObjTxtrTile_t;		// 24 bytes
   

• TLUT load structure uObjTLUT_t

  typedef struct		{
    u32		type;		// by type G_OBJLT_TLUT
    u64		*image;	// texture source address on DRAM
    u16		phead;		// first TLUT area number 256 ( phead ( 511
    u16		pnum;		// number of TLUT to be loaded - 1
    u16		 zero;		// always 0
    u16		sid;		// Status ID  { 0, 4, 8, or 12 } 
    u32		flag;		// Status flag
    u32		mask;		// Status mask
  	} uObjTxtrTLUT_t;		// 24 bytes
  

The shared structure, uObjTxtr union

typedef union		{
  uObjTxtrBlock_t		block;	// texture load parameter using LoadBlock
  uObjTxtrTile_t		tile;	// texture load parameter using LoadTile
  uObjTxtrTLUT_t		tlut;	// TLUT load parameter	 
  long long int		force_structure_alignment;
	} uObjTxtr;

gSPObjLoadTxtr

gSPObjLoadTxtr(Gfx *gdl, uObjTxtr *tx)
gsSPObjLoadTxtr(uObjTxtr *tx)

Gfx	*gdl;	The display list pointer.
uObjTxtr	*tx;	The pointer to the texture load data structure

gSPObjLoadTxtr performs each loading operation by referring to the texture loading parameters which are held by the above-mentioned three structures.

The three structures have the common member variables type, image, sid, flag, and mask. First, we will explain these five common member variables.

• type
  gSPObjLoadTxtr distinguishes each structure using the value of type, the structure's member variable. Each value of type and corresponding structure, and each operation is shown below.

  Type Value	Structure	Operation
  G_OBJLT_TXTRBLOCK	uObjTxtrBlock_t	texture load using LoadBlock
  G_OBJLT_TXTRTILE	uObjTxtrTile_t	texture load using LoadTile
  G_OBJLT_TLUT	uObjTLUT_t	loading of TLUT

• image
  image, the member variable, specifies the texture data in the main memory to be loaded, or TLUT data address. This texture data must be 8 byte aligned.

• sid, flag, and mask
  These three member variables are used for bypassing the reloading operation if the texture in question is already loaded. If the requested texture is already loaded, g[s]SPObjLoadTxtr will not perform the load operation.

To determine the existence of the texture in question in TMEM using the RSP, the RSP must analyze the loading destination area for each texture load operation. This is time consuming, and not a very good option.

In S2DEX, the loading destination area data are included in texture data structure. Therefore, rather than performing analysis using the RSP, simple calculation will determine whether or not the loading operation needs to be performed.

For example, when texture data are loaded to TMEM, an ID which corresponds to the loaded texture can be written to a status area. By simply comparing the IDs when the next TMEM loading operation is performed, the loading question can be resolved rather easily.

The loading decision method used by S2DEX is an extension of the above concept. When partial loading by dividing TMEM is performed, S2DEX can also make loading decisions for different parts of TMEM using two 32 bit variables (flag and mask); this makes partial loading possible.

The RSP provides four 32 bit status variables in the status region. When the microcode starts up, these variables are set to 0. sid will determine which status value to use. sid can assign one of the values {0, 4, 8, 12}.

g[s]ObjLoadTxtr actually makes the loading decision using the steps below.

1. Check the condition of (Status[sid] & mask == flag).

2. If the result is true, assume that the texture is already loaded and terminate the loading operation.

3. If the result is false, load the texture, and change Status[sid] to:

   Status[sid] = (Status[sid] & ~mask) | (flag & mask);
   

The easiest way to use flag is to assign -1 (=0xffffffff) to mask, and texture's source data address (= the value of the member variable "image") to flag. If there is no texture data starting from the same address, this will act as a texture cache.

Also, when (flag & ~mask) != 0, the condition will always be false, and texture will always be loaded.

The next example will divide TMEM into two areas and control each area. Here, assign Status[0]'s bits 31~16 to the first half of TMEM, and assign bits 15~0 to the last half of TMEM. Assign the sequence number to each texture. The value of sid is always 0.

	Load Area	Flag	Mask
A: texture 1	0 to 255	0x00010000	0xffff0000
B: texture 2	256 to 511	0x00000002	0x0000ffff
C: texture 3	0 to 511	0x00030003	0xffffffff
D: texture 3 (last half only)	256 to 511	0x00000003	0x0000ffff

At C, the entire texture 3 is loaded. Even though the loading operation of A changes the first half, since the TMEM's last half retains texture 3 data. The request for loading texture 3 at D to the last half will not require actual loading.

Similar to this example, S2DEX has GBI gSPSelectDL / gSPSelectBranchDL, which performs a DL branching operation, using the same principle as the operation using Status.

The member variables of other structures are explained in the following paragraphs.

1. Texture load using LoadBlock (uObjTxtrBlock_t structure)

   tmem
   The texture's loading destination TMEM address is assigned to tmem in DoubleWord units. Normally, this loading address is used as the value of imageAdrs of uObjSprite structure. If this value is to be specified in pixel units, the macro GS_PIX2TMEM(), described earlier, will become useful.

   tsize
   The size information of the texture to be loaded is assigned to tsize. To obtain this value from texture size, the macro GB_TB_TSIZE() is used.

   GS_TB_TSIZE(pix,siz): tsize setting
    pix:		the number of texels to be loaded (=width of texture X height of     texture)
    siz:		1 texel size, specify G_IM_SIZ_*
    
   

   tline
   The width information of the texture to be loaded is assigned to tline. Use the macro GS_TB_TLINE() for obtaining the value from the texture width.

   GS_TB_TLINE(pix,siz): setting of tline
   	 pix:	the number of texel of texture width
   	 siz:	1 texel size, specified by G_IM_SIZ_*
   

2. Texture load by LoadTile (uObjTxtrTile_t structure)

   tmem
   This member variable is common to the load operations using LoadBlock. The TMEM texture load destination address is assigned to tmem in DoubleWord units.

   twidth
   The load texture width information is assigned to twidth. Use the macro GS_TT_TWIDTH() to obtain the value from texture width.

   GS_TT_TWIDTH(pix,siz): setting of twidth 
   	 pix:	texture width 
   	 siz:	1 texel size specified by G_IM_SIZ_*
   

   theight
   The height information of the texture to be loaded is assigned to theight. Use the macro GS_TT_THEIGHT() to obtain the value from texture height.

   GS_TT_THEIGHT(pix,siz): setting of theight
   	 pix:	texture height
   	 siz:	1 texel size, specified by G_IM_SIZ_*
   

3. TLUT load (uObjTLUT_t structure)

   phead
   The first TLUT area number is assigned to phead. The palette number can be obtained by adding 256 to the normal palette ID. Therefore, the value ranges from 256 to 511. Use the GS_PAL_HEAD() macro for this setting.

   GS_PAL_HEAD(head): setting of phead (add 256 to head)
   	 head: first ID of TLUT to be loaded
   

   pnum
   A value representing "(the-number-of-colors-of-the-loaded-TLUT) -1" is assigned to pnum. Use the GS_PAL_NUM() macro for this setting.

   GS_PAL_NUM(num): setting of pnum (num -1)
   	 num: the number of TLUT to be loaded
   

   zero
   This member is not used in uObjTLUT_t. However, to maintain compatibility with other structures, always assign 0 to zero.

The following illustrates an example of the set-up for the three structures.

1. RGBA16 Texture load using LoadBlock

   uObjTxtr objTxtrBlock_RGBA16 = {
   	  G_OBJLT_TXTRBLOCK,                    /* type    */
   	  (u64 *)textureRGBA16,                 /* image   */
   	  GS_PIX2TMEM(0,     G_IM_SIZ_16b),     /* tmem    */
   	  GS_TB_TSIZE(32*32, G_IM_SIZ_16b),     /* tsize   */
   	  GS_TB_TLINE(32,    G_IM_SIZ_16b),     /* tline   */
   	  0,                                    /* sid     */
   	  (u32)textureRGBA16,                   /* flag    */
   	  -1                                    /* mask    */
   	};
   
   

2. CI4 Texture load using LoadTile

   uObjTxtr objTxtrTile_CI4 = {
   	  G_OBJLT_TXTRTILE,                     /* type    */
   	  (u64 *)textureCI4,                    /* image   */
   	  GS_PIX2TMEM  (0,  G_IM_SIZ_4b),	      /* tmem    */
   	  GS_TT_TWIDTH (32, G_IM_SIZ_4b),	      /* twidth  */
   	  GS_TT_THEIGHT(32, G_IM_SIZ_4b),	      /* theight */
   	  0,                                    /* sid     */
   	  (u32)textureCI4,                      /* flag    */
   	  -1                                    /* mask    */
   	};
   

3. TLUT load

   uObjTxtr objTLUT_CI4 = {
   	  G_OBJLT_TLUT,                         /* type    */
   	  (u64 *)textureCI4pal,                 /* image   */
   	  GS_PAL_HEAD(0),                       /* phead   */
   	  GS_PAL_NUM(16),                       /* pnum    */
   	  0,                                    /* zero    */
   	  0,                                    /* sid     */
   	  (u32)textureCI4pal,                   /* flag    */
   	  -1                                    /* mask    */
   	};
   

Compound Processing GBI
In actual game development, combining the Texture Load GBI and the sprite Drawing GBI is sometimes advantageous for controlling Sprites. S2DEX provides the mechanism to control the two GBIs with one GBI. The following is an explanation of compound processing of the GBIs.

uObjTxSprite Structure
uObjTxSprite structure, which is shown below, has been constructed by combining uObjTxtr structure and uObjSprite structure. The pointer to uObjTxSprite structure is provided to the compound processing GBI as the parameter.

typedef struct	{
	   uObjTxtr	txtr;
	   uObjSprite	sprite;
	 } uObjTxSprite;		/* 48 bytes */

gSPObjLoadTxRect

gSPObjLoadTxRect(Gfx *gdl, uObjTxSprite *txsp)
gsSPObjLoadTxRect(uObjTxSprite *txsp)

Gfx	*gdl;	The display list pointer.
UObjTxSprite	*txsp;	The pointer to texture load and sprite draw data structure

The g[s]SPObjLoadTxRect GBI performs the Texture Load operation, and then draws a non-rotating sprite.

Essentially, this command performs two GBI operations g[s]SPObjLoadTxtr and g[s]SPObjRectangle with one GBI. The results of (A) and (B) shown below are identical.

(A) gsSPObjLoadTxRectR(txsp);

(B) gsSPObjLoadTxtr(&(txsp->txtr));
	   gsSPObjRectangleR(&(txsp->sprite));

gSPObjLoadTxRectR

gSPObjLoadTxRectR(Gfx *gdl, uObjTxSprite *txsp)
gsSPObjLoadTxRectR(uObjTxSprite *txsp)

Gfx	*gdl;	The display list pointer.
uObjTxSprite	*txsp;	The pointer to the texture load and the sprite drawing data structure

The g[s]SPObjLoadTxRectR GBI performs the Texture Load operation, and then draws a non-rotating sprite referencing a 2D matrix.

Essentially, this command performs two GBI operations, g[s]SPObjLoadTxtr and g[s]SPObjRectangleR with one GBI. The results of (A) and (B) shown below are identical.

 (A) gsSPObjLoadTxRectR(txsp);
	(B) gsSPObjLoadTxtr(&(txsp->txtr));
	    gsSPObjRectangleR(&(txsp->sprite));

gSPObjLoadTxSprite

gSPObjLoadTxSprite(Gfx *gdl, uObjTxSprite *txsp)
gsSPObjLoadTxSprite(uObjTxSprite *txsp)

Gfx	*gdl;	The display list pointer.
uObjTxSprite	*txsp;	The pointer to the texture load and the sprite drawing data structure

The g[s]SPObjLoadTxSprite GBI performs the Texture Load operation, and then draws a rotating sprite.

Essentially, this command performs two GBI operations, g[s]SPObjLoadTxtr and g[s]SPObjSprite with one GBI. The results of (A) and (B) shown below are identical.

	(A) gsSPObjLoadTxSprite(txsp);
	(B) gsSPObjLoadTxtr(&(txsp->txtr));
	    gsSPObjSprite(&(txsp->sprite));

Conditional Branching GBI
We have explained that S2DEX is using the RSP's Status for making a loading decision. Here, we will explain the GBI which uses Status for DL branching and linking.

gSPSetStatus

gSPSetStatus(Gfx *gdl, u8 sid, u32 val)
gsSPSetStatus(u8 sid, u32 val)

Gfx	*gdl;	The display list pointer.
u8	sid;	Status ID { 0, 4, 8, or 12 }
u32	val;	A value the user desires to set

g[s]SPSetStatus assigns the value of val to the Status area (Status[sid]) specified by sid. The Status value is referenced for Texture Loading and making conditional branching decisions.

gSPSelectDL

gSPSelectDL(Gfx *gdl, Gfx *ldl, u8 sid, u32 flag, u32 mask)
gsSPSelectDL(Gfx *ldl, u8 sid, u32 flag, u32 mask)

Gfx	*gdl;	The display list pointer.
Gfx	*ldl;	Display list to be linked
u8	sid;	Status ID { 0, 4, 8, or 12 }
u32	flag;	Status flag
u32	mask;	Status mask

g[s]SPSelectDL inspects Status[sid] using the same method used for texture load decision making. Depending on the True/False result, other display lists are called.

g[s]SPSelectDL determines whether or not to call the display list by going through the following steps.

• Check the condition of (Status[sid] & mask) == flag

• If the result is true, finish GBI without doing anything.

• If the result is false, change the Status[sid] by performing:

  Status[sid] = (Status[sid] & ~mask) | (flag & mask);
  

  and call display list "ldl".

gSPSelectBranchDL

gSPSelectBranchDL(Gfx *gdl, Gfx *bdl, u8 sid, u32 flag, u32 mask)
gsSPSelectBranchDL(Gfx *bdl, u8 sid, u32 flag, u32 mask)

Gfx	*gdl;	The display list pointer.
Gfx	*link;	Display list to be linked
u8	sid;	Status ID { 0, 4, 8, or 12 }
u32	flag;	Status flag
u32	mask;	Status mask

g[s]SPSelectBranchDL examines Status[sid] using the same method used for texture load decision making, and depending on the True/False result branches out to other display lists.

g[s]SPSelectBranchDL determines whether or not to call the display list using the following steps.

• Check the condition of (Status[sid] & mask) == flag

• If the result is true, finish GBI without doing anything.

• If the result is false, change the Status[sid] by performing:

  Status[sid] = (Status[sid] & ~mask) | (flag & mask);
  

  and branch out to display list "ldl".

Emulation Functions
These are functions for using the CPU to emulate S2DEX GBI functions.

guS2DEmuGBgRect1Cyc

void	guS2DEmuGBgRect1Cyc (Gfx **gdl_p, uObjBg *bg);

This function uses the CPU to emulate the action of S2DEX function gSPBgRect1Cyc by combining other GBI's.

Parameters:	gdl_p	Pointer to pointer to display list *The value for gdl_p is automatically calculated.
	bg	Pointer to uObjBg structure

Calling gSPBgRect1Cyc (gdl ++, bg) can be replaced by guS2DEmuGBgRect1Cyc (&gdl, bg). Refer to "gSPBgRect1Cyc" for an explanation of the parameter bg.

In addition, in order to notify the main routine that a scissoring box setting and Texture Filter setting, the function guS2DEmuSetScissor, discussed below, must be called before guS2DEmuBgRect1Cyc.

This function produces GBI's which are functional not only in S2DEX, but in the F3DEX series as well. Because of this, one microcode can be processed when displaying a scaled scrolling BG screen and a 3D model at the same time.

guS2DEmuSetScissor

void	guS2DEmuSetScissor (u32 ulx, u32 uly, u32 lrx, u32 lry, u8 bilerp);

This function sets the scissoring parameters and Texture Filter referred when the function guS2DEmuBgRect1Cyc is processed.

Parameters:	ulx	upper left X coordinate of scissor box (u10.0)
	uly	upper left Y coordinate of scissor box (u10.0)
	lrx	lower right X coordinate of scissor box (u10.0)
	lry	lower right Y coordinate of scissor box (u10.0)
	bilerp	set to value other than 0 to perform Bilerp interpolation processing on the image, or set to 0 for PointSample

Normally, the range of the scissor box set by g[s]DPSetScissor is handled by this function as parameters. In addition, the initial values for ulx, uly, lrx, lry, and bilerp are 0, 0, 320, 340, 0, respectively, which are settings that draw to a 320x240 pixel frame buffer with PointSample.

This function only needs to be called once before guS2DEmuBgRect1Cyc is called. As long as there is no change in the scissor box and Texture Filter, it only needs to be called once during game initialization, and doesn't need to be called every time a frame is drawn.

DEBUG Information Output Function
There are 2 versions of S2DEX Microcode; one version for debugging and another version for release. The relationship between the two microcodes is the same as the relationship between libultra_rom.a and libultra_d.a.

Although the debug version microcode, S2DEX_D is slower than the release version of the microcode, it has the following additional features.

• Outputs the display list processing log.

• In the event of bad input or encountering undefined commands, stops RSP and reports the problem to the CPU.

Investigation of problems, such as finding the cause of a runaway RSP, will become easier by checking the display list processing log. To use S2DEX_D, it is necessary to prepare an output buffer for the RSP display list processing log. The size must be the same as the display list, and must be 8 byte aligned.

Once the area is reserved, provide the pointer data of the first address of the area to data_size, which is a member variable of the OSTask structure. This member variable is not used in the S2DEX and F3DEX series to mean the size of the DL is the essential meaning. A remnant of N64 OS/Library Version 1.0, it is used as a log output buffer.

This address must not be the Segment address. When gspS2DEX.fifo_d.o activates as microcode, it is stored in the address specified by the process log.

For details concerning the processing log's display methods, please refer to the function ucDebugGfxLogPrint() in the sample program uc_assert.c. Also, for details concerning the decision making process for stopping the RSP, please refer to ucCheckAssert() in the same file.

Note: The OSTask structure's member variable yield_data_size was used to set the log buffer in S2DEX Release 0.75 and older, but this was switched to data_size in Release 0.76 and later. Please note that the display function ucDebugGfxLogPrint() has also been corrected.

Installing the S2DEX Package
The description here applies to S2DEX Microcode when it is received as a patch. If the package is included in the N64 OS/Library that you received, the work described here is not necessary.

The S2DEX Microcode consists of the following files:

README	This section (25.5.7)
gspS2DEX.fifo.o	S2DEX Microcode
gspS2DEX.fifo_d.o	S2DEX Microcode (for Debugging)
include/gs2dex.h	Include files for S2DEX
libultra/Makefile	Makefile for updating libultra
libultra/us2dex.o	Initialization routine for BG structure
libultra/us2dex_emu.o	Scaleable BG drawing routine
sample/*	S2DEX Sample programs

libultra*.a is created by executing the make command in the libultra directory. Copy libultra*.a files to /usr/lib.

Copy gspS2DEX.fifo.o and gspS2DEX.fifo_d.o to /usr/lib/PR, and copy include/gs2dex.h to /usr/include/PR.

In addition, perl is necessary to compile affiliated sample programs.

Please install the following packages from the IRIX 5.3/6.x CD.

                  eoe2.sw.gifts_perl

History of Revisions

• 03/26/97 - Release 0.70 (beta 1)
  Initial version

• 03/28/97 - Release 0.71 (beta 2)
  Added libultra patch
  Revised installation data

• 04/01/97 - Release 0.72 (beta 3)
  Corrected improper S flipping operation in BG rendering
  Changed part of sample program

• 04/10/97 - Release 0.73 (beta 4)
  Defined new RenderMode
  Added new function G_OBJRM_WIDEN to gSPObjRenderMode
  Modified sample program so that CI8 textures can be used on semitranslucent sprites and BG

• 04/21/97 - Release 0.74 (beta 5)
  Corrected inadequate checks on buffer status when using small FIFO buffer
  Corrected the fact that member variables imageX and imageY of the uObjBg structure were installed in (u10.2) format so that they are (u10.5)
  Changed frameX and frameY member variables of uObjBg structure to signed

• 05/09/97 - Release 0.75 (beta6)
  Created guS2DEmuBgRect1Cyc() and guSDEmuSetScissor() functions which create a DL for scalable BG screens using the CPU
  Distributed as a patch, and section was added to README regarding this.
  No change from 0.74 microcode
  Added section on perl installation method

• 05/16/97 - Release 0.80 (beta7)
  Changed log output buffer setting method (yield_data_size -> data_size)
  Corrected bug in yield processing
  Added text pertaining to FIFO buffer size to section 2.4 in README file
  Corrected Sync processing in BG rendering GBI / emulation functions

• 06/03/97 - Release 1.00
  Installed g[s]SPBgRect1Cyc, a GBI which renders scalable BG
  Changed formats of imagePal and imageFlip member variables in uObjBg_t structure and uObjScaleBg_t structure from u8 to u16 for alignment
  Added 3.4 Precautions Regarding GBI to documentation
  Changed BaseScaleX and BaseScaleY in uObjMtx structure, and scaleW and scaleH in uObjSprite structure to unsigned

• 06/13/97 - Release 1.01
  Corrected bug in g[s]SPBgRect1Cyc in which unnecessary texture loading processing was sometimes performed, vastly increasing RDP processing time

• 07/03/97 - Release 1.02
  Corrected problem in which, when multiple semitranslucent sprites were joined together, the seam line would be blended twice, and along with this, added G_OBJRM_XLU as ObjRenderMode
  Reduced actual rendered size differences when the same sprite data were rendered by g[s]SPObjRectangle and g[s]SPObjSprite

• 07/04/97 - Release 1.03
  Corrected bug in G_OBJRM_XLU mode
  Added processing example (render ball) to sample program of when an object is realized by combining multiple sprites while Bilerp in effect.

• 07/31/97 - Release 1.04
  Due to inadequate processing of the line at the seam during semitransparent display with Release 1.02, to measures to eradicate the problem. Concretely, increased the accuracy of sprite rendering processing. As a result, the G_OBJRM_XLU mode and G_OBJRM_ANTIALIAS mode became unnecessary.
  Adjusted definition of RDP RenderMode. In particular, isolated the modes during display of semi-translucent sprites according to when AntiAlias is ON and OFF.

• 08/07/97 - Release 1.05
  Corrected problem in which texture which shift when rendering long, thin sprites by further increasing sprite rendering precision.
  Increase Rectangle calculation accuracy. This eliminated the gaps that would develop when aligning rectangles using the RectR commands. (This was obstructed in the past by G_OBJRM_WIDEN in the ObjRenderMode.)
  Added ball using RectR to the sample program. Also revised program so that G_OBJRM_WIDEN is not used.

• 10/29/97 - Release 1.06 (N64 Dev Env. 2.0i)
  Corrected errors in g[s]SPSelectDL and g[s]SPSelectBranchDL macro definitions.
  Corrected improper operation of gSPObjLoadTxRectR after processing gSPBgRect1Cyc.
  Corrected improper operation of gSPObjLoadTxRect.
  Reduced size of microcode data area. This somewhat increased the RAM area available to the user.

• 12/25/97 - Release 1.06+
  Corrected errors and difficult to understand points in this README.txt file.

• 04/10/98 - Release 1.07
  Corrected abnormal functioning in the rendering processing of frames with narrow widths by gSPBgRectCopy command.

Copyright © 1999 Nintendo of America Inc. All Rights Reserved Nintendo and N64 are registered trademarks of Nintendo Last Updated January, 1999