// Filename 		: PRIM.C
// Coded by 		: Scott Evans
// Created/Modified : 23/10/97
//			          15/7/98 Added global variable for drawing mode

// Description		: Primitive library for the Yaroze


#include <prim.h>


// Pointer to drawing mode primitive

DR_MODE_PRIM *drawing_mode;


// Function			: GsSortTriangle
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a triangle into the ordering table

// Parameters		: t - pointer to GsTRIANGLE
//				  	  ot - pointer to ordering table
//				  	  priority - priority of triangle

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortTriangle(GsTRIANGLE *t,GsOT *ot,u_word priority)
{
	TRIANGLE_PRIM *prim=(TRIANGLE_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setXY3(prim,t->x0,t->y0,t->x1,t->y1,t->x2,t->y2);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(TRIANGLE_PRIM);
	
	prim->code=F3_CODE;
	prim->tag=(u_long *)(0x04<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(t->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);	
}


// Function			: GsSortGTriangle
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a Gouraud shaded triangle into the ordering table

// Parameters		: t - pointer to GsGTRIANGLE
//				  	  ot - pointer to ordering table
//				  	  priority - priority of triangle

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortGTriangle(GsGTRIANGLE *t,GsOT *ot,u_word priority)
{
	GTRIANGLE_PRIM *prim=(GTRIANGLE_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setRGB1(prim,t->r1,t->g1,t->b1);
	setRGB1(prim,t->r2,t->g2,t->b2);
	setXY3(prim,t->x0,t->y0,t->x1,t->y1,t->x2,t->y2);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(GTRIANGLE_PRIM);
	
	prim->code=G3_CODE;
	prim->tag=(u_long *)(0x06<<24);
	prim->pad0=prim->pad1=0;
	
	drawing_mode=0;

	// Test for transparency
	
	if(t->attribute&TRANSPARENCY_ON)
    {
    	// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    

    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortQuad
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a 4 sided polygon into the ordering table

// Parameters		: q - pointer to GsQUAD
//				  	  ot - pointer to ordering table
//				  	  priority - priority of quad

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortQuad(GsQUAD *q,GsOT *ot,u_word priority)
{
	QUAD_PRIM *prim=(QUAD_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,q->r0,q->g0,q->b0);
	setXY4(prim,q->x0,q->y0,q->x1,q->y1,q->x2,q->y2,q->x3,q->y3);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(QUAD_PRIM);
	
	prim->code=F4_CODE;
	prim->tag=(u_long *)(0x05<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(q->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(q->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortGQuad
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a Gouraud shaded quad into the ordering table

// Parameters		: q - pointer to GsQUAD
//				  	  ot - pointer to ordering table
//				  	  priority - priority of quad

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortGQuad(GsGQUAD *q,GsOT *ot,u_word priority)
{
	GQUAD_PRIM *prim=(GQUAD_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB4(prim,q->r0,q->g0,q->b0,q->r1,q->g1,q->b1,q->r2,q->g2,q->b2,q->r3,q->g3,q->b3);
	setXY4(prim,q->x0,q->y0,q->x1,q->y1,q->x2,q->y2,q->x3,q->y3);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(GQUAD_PRIM);
	
	prim->code=G4_CODE;
	
	drawing_mode=0;

	// Test for transparency
	
	if(q->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(q->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }

		
	prim->tag=(u_long *)(0x08<<24);
	
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortLine2
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a line into the ordering table

// Parameters		: l - pointer to GsLINE2
//				  	  ot - pointer to ordering table
//				  	  priority - priority of line

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortLine2(GsLINE2 *l,GsOT *ot,u_word priority)
{
	LINE2_PRIM *prim=(LINE2_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,l->r0,l->g0,l->b0);
	setXY2(prim,l->x0,l->y0,l->x1,l->y1);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(LINE2_PRIM);
	
	prim->code=LF2_CODE;
	prim->tag=(u_long *)(0x03<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortGLine2
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts a Gouraud shaded line into the ordering table

// Parameters		: l - pointer to GsGLINE2
//				  	  ot - pointer to ordering table
//				  	  priority - priority of line

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortGLine2(GsGLINE2 *l,GsOT *ot,u_word priority)
{
	GLINE2_PRIM *prim=(GLINE2_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,l->r0,l->g0,l->b0);
	setXY2(prim,l->x0,l->y0,l->x1,l->y1);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(LINE2_PRIM);
	
	prim->code=LG2_CODE;
	prim->tag=(u_long *)(0x04<<24);
	prim->pad=0;
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortLine3
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts 2 connected lines into the ordering table

// Parameters		: q - pointer to GsLINE3
//				 	  ot - pointer to ordering table
//				  	  priority - priority of lines

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortLine3(GsLINE3 *l,GsOT *ot,u_word priority)
{
	LINE3_PRIM *prim=(LINE3_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,l->r0,l->g0,l->b0);
	setXY3(prim,l->x0,l->y0,l->x1,l->y1,l->x2,l->y2);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(LINE3_PRIM);
	
	prim->code=LF3_CODE;
	prim->tag=(u_long *)(0x05<<24);
	prim->pad=0x55555555;
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortGLine3
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts 2 connected Gouraud shaded lines into the ordering table

// Parameters		: l - pointer to GsGLINE3
//				  	  ot - pointer to ordering table
//				  	  priority - priority of lines

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortGLine3(GsGLINE3 *l,GsOT *ot,u_word priority)
{
	GLINE3_PRIM *prim=(GLINE3_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,l->r0,l->g0,l->b0);
	setRGB1(prim,l->r1,l->g1,l->b1);
	setRGB2(prim,l->r2,l->g2,l->b2);
	setXY3(prim,l->x0,l->y0,l->x1,l->y1,l->x2,l->y2);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(GLINE3_PRIM);
	
	prim->code=LG3_CODE;
	prim->tag=(u_long *)(0x07<<24);
	prim->pad0=prim->pad1=0;
	prim->pad2=0x55555555;
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortLine4
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts 3 connected lines into the ordering table

// Parameters		: l - pointer to GsLINE4
//				  	  ot - pointer to ordering table
//				  	  priority - priority of lines

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortLine4(GsLINE4 *l,GsOT *ot,u_word priority)
{
	LINE4_PRIM *prim=(LINE4_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,l->r0,l->g0,l->b0);
	setXY4(prim,l->x0,l->y0,l->x1,l->y1,l->x2,l->y2,l->x3,l->y3);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(LINE4_PRIM);
	
	prim->code=LF3_CODE;
	prim->tag=(u_long *)(0x06<<24);
	prim->pad=0x55555555;
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortGLine4
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Sorts 3 connected Gouraud shaded lines into the ordering table

// Parameters		: l - pointer to GsQLine4
//				  	  ot - pointer to ordering table
//				  	  priority - priority of lines

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortGLine4(GsGLINE4 *l,GsOT *ot,u_word priority)
{
	GLINE4_PRIM *prim=(GLINE4_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB4(prim,l->r0,l->g0,l->b0,l->r1,l->g1,l->b1,l->r2,l->g2,l->b2,l->r3,l->g3,l->b3);
	setXY4(prim,l->x0,l->y0,l->x1,l->y1,l->x2,l->y2,l->x3,l->y3);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(GLINE4_PRIM);
	
	prim->code=LG4_CODE;
	prim->tag=(u_long *)(0x09<<24);
	prim->pad0=prim->pad1=prim->pad2=0;
	prim->pad3=0x55555555;
	
	drawing_mode=0;

	// Test for transparency
	
	if(l->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(l->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortTile
// Coded by			: Scott Evans
// Created/Modified	: 26/10/97
// Description		: Sorts a tile (rectangle) into the ordering table

// Parameters		: t - pointer to GsTILE
//				  	  ot - pointer to ordering table
//				  	  priority - priority of tile

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortTile(GsTILE *t,GsOT *ot,u_word priority)
{
	TILE_PRIM *prim=(TILE_PRIM *)GsOUT_PACKET_P;
    long mode;

	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setXY0(prim,t->x0,t->y0);
	setWH(prim,t->w,t->h);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(TILE_PRIM);
	
	prim->code=TL_CODE;
	prim->tag=(u_long *)(0x03<<24);
	
	drawing_mode=0;

	if(t->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	
        // Create a draw mode primitive
        
        drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    
    }
		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);	
}


// Function			: GsSortTile1
// Coded by			: Scott Evans
// Created/Modified	: 26/10/97
// Description		: Sorts a 1x1 tile into the ordering table

// Parameters		: t - pointer to GsTILE1
//				  	  ot - pointer to ordering table
//				  	  priority - priority of tile

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortTile1(GsTILE1 *t,GsOT *ot,u_word priority)
{
	TILE1_PRIM *prim=(TILE1_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setXY0(prim,t->x0,t->y0);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(TILE1_PRIM);
	
	prim->code=TL1_CODE;
	prim->tag=(u_long *)(0x02<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(t->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	
        // Create a draw mode primitive
        
        drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: GsSortTile8
// Coded by			: Scott Evans
// Created/Modified	: 26/10/97
// Description		: Sorts a 8x8 tile into the ordering table

// Parameters		: t - pointer to GsTILE8
//				  	  ot - pointer to ordering table
//				  	  priority - priority of tile

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortTile8(GsTILE8 *t,GsOT *ot,u_word priority)
{
	TILE8_PRIM *prim=(TILE8_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setXY0(prim,t->x0,t->y0);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(TILE8_PRIM);
	
	prim->code=TL8_CODE;
	prim->tag=(u_long *)(0x02<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(t->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	
        // Create a draw mode primitive
        
        drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}

// Function			: GsSortTile16
// Coded by			: Scott Evans
// Created/Modified	: 26/10/97
// Description		: Sorts a 16x16 tile into the ordering table

// Parameters		: t - pointer to GsTILE16
//				 	  ot - pointer to ordering table
//				  	  priority - priority of tile

// Returns			: Nothing

// Notes			: Trying to keep it similar to other GsSort... functions


void GsSortTile16(GsTILE16 *t,GsOT *ot,u_word priority)
{
	TILE16_PRIM *prim=(TILE16_PRIM *)GsOUT_PACKET_P;
    long mode;
    
	// Copy primitive into current packet buffer
	
	setRGB0(prim,t->r0,t->g0,t->b0);
	setXY0(prim,t->x0,t->y0);
	
	// Update packet buffer work area pointer
	
	GsOUT_PACKET_P+=sizeof(TILE16_PRIM);
	
	prim->code=TL16_CODE;
	prim->tag=(u_long *)(0x02<<24);
	
	drawing_mode=0;

	// Test for transparency
	
	if(t->attribute&TRANSPARENCY_ON)
    {
		// Need to change current tpage for different transparency
        
        drawing_mode=(DR_MODE_PRIM *)GsOUT_PACKET_P;
        GsOUT_PACKET_P+=sizeof(DR_MODE_PRIM);
        
        mode=(t->attribute>>28)&0x3;
        
        prim->code|=TRANSPARENT_CODE;
    	
        // Create a draw mode primitive
        
        drawing_mode->tag=(u_long *)(0x02<<24);
        drawing_mode->code[0]=(GetTPage(0,mode,0,0)&0x09ff)|0xe1000000;
        drawing_mode->code[1]=0;	    
    }

		
	// Add the primitive to the ordering table
	
	AddPrimToOT_TAG((GsOT_TAG *)prim,(ot->org)+priority);
    
    if(drawing_mode)
    	AddPrimToOT_TAG((GsOT_TAG *)drawing_mode,(ot->org)+priority);
}


// Function			: AddPrimToOT_TAG
// Coded by			: Scott Evans
// Created/Modified	: 23/10/97
// Description		: Adds a primitive to an ordering table tag

// Parameters		: prim_tag - pointer to the primitives tag
//				  	  ot_tag - pointer to ordering table tag

// Returns			: Nothing

// Notes			: 


void AddPrimToOT_TAG(GsOT_TAG *prim_tag,GsOT_TAG *ot_tag)
{
	// Primitive points to next tag in list
	
	prim_tag->p=ot_tag->p;
	
	// Ordering table tag point to new primitive
	
	ot_tag->p=(u_long)prim_tag;
}