
void DrawObjectFixedAsm( Object* object, Skeleton* camera, int depth )
{
   DVECTOR*    screenPtr;
   ushort*     depthPtr;
   ushort*     flagsPtr;

   StdPoly     prim;
   Poly        poly;

   short       i;
   
   short       coord0;
   short       coord1;
   short       coord2;
   short       coord3;


   SVECTOR*    vertex;

   short       primitiveCount;
   short       vertexCount;


   /* for sprites */
   int 			     x, y;

   short 		     xSize;
   short 		     ySize;
   short 		     xSize2;
   short 		     ySize2;

   short             tlX; 
   short             tlY; 
   short             trX; 
   short             trY; 
   short             blX; 
   short             blY; 
   short             brX; 
   short             brY; 

   short             offsetX; 
   short             offsetY; 
   short             offset2X; 
   short             offset2Y; 

   short             tex;

   SetSkeletonTransform( object->skeleton );


   vertex = object->vertices;
   vertexCount = object->vertexCount;

   poly.prim = object->primitives;
   primitiveCount = object->primitiveCount;

	primCount += primitiveCount;


   if ( vertexCount <= 128 )
   {
      screenPtr = ( DVECTOR* )( FastRam );
      depthPtr = ( ushort* )( FastRam + 512 );
      flagsPtr = ( ushort* )( FastRam + 768 );
   }
   else
   {
      screenPtr = StaticScreen;
      depthPtr = StaticDepth;
      flagsPtr = StaticFlags;
   }


   RotTransPersN( vertex, screenPtr, depthPtr, flagsPtr, vertexCount );

		
   for ( i=0; i<primitiveCount; i++ )
   {
      switch ( poly.prim->type )
      {
         case TypeGT3 :

            coord0 = poly.gt3->coords[ 0 ];
            coord1 = poly.gt3->coords[ 1 ];
            coord2 = poly.gt3->coords[ 2 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyGT3( ( POLY_GT3* )prims.ptr );

                  prims.gt3->cba = poly.gt3->cba;
                  prims.gt3->tsb = poly.gt3->tsb;

                  prims.gt3->u0 = poly.gt3->u0;
                  prims.gt3->v0 = poly.gt3->v0;
                  prims.gt3->u1 = poly.gt3->u1;
                  prims.gt3->v1 = poly.gt3->v1;
                  prims.gt3->u2 = poly.gt3->u2;
                  prims.gt3->v2 = poly.gt3->v2;

                  prims.gt3->colour0.r = 230; // PCwipeout
                  prims.gt3->colour0.g = 0;
                  prims.gt3->colour0.b = 0;
                  prims.gt3->colour1 = poly.gt3->colour[ 1 ];
                  prims.gt3->colour2 = poly.gt3->colour[ 2 ];

                  prims.gt3->xy0 = screenPtr[ coord0 ];
                  prims.gt3->xy1 = screenPtr[ coord1 ];
                  prims.gt3->xy2 = screenPtr[ coord2 ];


                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.gt3 += 1;
               }
            }

            poly.gt3 += 1;
            break;

         case TypeGT4 :

            coord0 = poly.gt4->coords[ 0 ];
            coord1 = poly.gt4->coords[ 1 ];
            coord2 = poly.gt4->coords[ 2 ];
            coord3 = poly.gt4->coords[ 3 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] | 
                      flagsPtr[ coord3 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyGT4( ( POLY_GT4* )prims.ptr );

                  prims.gt4->cba = poly.gt4->cba;
                  prims.gt4->tsb = poly.gt4->tsb;

                  prims.gt4->u0 = poly.gt4->u0;
                  prims.gt4->v0 = poly.gt4->v0;
                  prims.gt4->u1 = poly.gt4->u1;
                  prims.gt4->v1 = poly.gt4->v1;
                  prims.gt4->u2 = poly.gt4->u2;
                  prims.gt4->v2 = poly.gt4->v2;
                  prims.gt4->u3 = poly.gt4->u3;
                  prims.gt4->v3 = poly.gt4->v3;

                  prims.gt4->colour0.r = 230; // PCwipeout
                  prims.gt4->colour0.g = 0;
                  prims.gt4->colour0.b = 0;
                  prims.gt4->colour1 = poly.gt4->colour[ 1 ];
                  prims.gt4->colour2 = poly.gt4->colour[ 2 ];
                  prims.gt4->colour3 = poly.gt4->colour[ 3 ];

                  prims.gt4->xy0 = screenPtr[ coord0 ];
                  prims.gt4->xy1 = screenPtr[ coord1 ];
                  prims.gt4->xy2 = screenPtr[ coord2 ];
                  prims.gt4->xy3 = screenPtr[ coord3 ];


                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.gt4 += 1;
               }
            }

            poly.gt4 += 1;
            break;

         case TypeFT3 :

            coord0 = poly.ft3->coords[ 0 ];
            coord1 = poly.ft3->coords[ 1 ];
            coord2 = poly.ft3->coords[ 2 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyFT3( ( POLY_FT3* )prims.ptr );

                  prims.ft3->cba = poly.ft3->cba;
                  prims.ft3->tsb = poly.ft3->tsb;

                  prims.ft3->u0 = poly.ft3->u0;
                  prims.ft3->v0 = poly.ft3->v0;
                  prims.ft3->u1 = poly.ft3->u1;
                  prims.ft3->v1 = poly.ft3->v1;
                  prims.ft3->u2 = poly.ft3->u2;
                  prims.ft3->v2 = poly.ft3->v2;

                  prims.ft3->colour0.r = 230; // PCwipeout
                  prims.ft3->colour0.g = 0;
                  prims.ft3->colour0.b = 0;

                  prims.ft3->xy0 = screenPtr[ coord0 ];
                  prims.ft3->xy1 = screenPtr[ coord1 ];
                  prims.ft3->xy2 = screenPtr[ coord2 ];


                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.ft3 += 1;
               }
            }

            poly.ft3 += 1;
            break;

         case TypeFT4 :

            coord0 = poly.ft4->coords[ 0 ];
            coord1 = poly.ft4->coords[ 1 ];
            coord2 = poly.ft4->coords[ 2 ];
            coord3 = poly.ft4->coords[ 3 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] | 
                      flagsPtr[ coord3 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyFT4( ( POLY_FT4* )prims.ptr );

                  prims.ft4->cba = poly.ft4->cba;
                  prims.ft4->tsb = poly.ft4->tsb;

                  prims.ft4->u0 = poly.ft4->u0;
                  prims.ft4->v0 = poly.ft4->v0;
                  prims.ft4->u1 = poly.ft4->u1;
                  prims.ft4->v1 = poly.ft4->v1;
                  prims.ft4->u2 = poly.ft4->u2;
                  prims.ft4->v2 = poly.ft4->v2;
                  prims.ft4->u3 = poly.ft4->u3;
                  prims.ft4->v3 = poly.ft4->v3;

                  prims.ft4->colour0.r = 230; // PCwipeout
                  prims.ft4->colour0.g = 0;
                  prims.ft4->colour0.b = 0;

                  prims.ft4->xy0 = screenPtr[ coord0 ];
                  prims.ft4->xy1 = screenPtr[ coord1 ];
                  prims.ft4->xy2 = screenPtr[ coord2 ];
                  prims.ft4->xy3 = screenPtr[ coord3 ];

                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.ft4 += 1;
               }
            }

            poly.ft4 += 1;
            break;

         case TypeG3 :

            coord0 = poly.g3->coords[ 0 ];
            coord1 = poly.g3->coords[ 1 ];
            coord2 = poly.g3->coords[ 2 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyG3( ( POLY_G3* )prims.ptr );

                  prims.g3->colour0.r = 230; // PCwipeout
                  prims.g3->colour0.g = 0;
                  prims.g3->colour0.b = 0;
                  prims.g3->colour1 = poly.g3->colour[ 1 ];
                  prims.g3->colour2 = poly.g3->colour[ 2 ];

                  prims.g3->xy0 = screenPtr[ coord0 ];
                  prims.g3->xy1 = screenPtr[ coord1 ];
                  prims.g3->xy2 = screenPtr[ coord2 ];

                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.g3 += 1;
               }
            }

            poly.g3 += 1;
            break;

         case TypeG4 :

            coord0 = poly.g4->coords[ 0 ];
            coord1 = poly.g4->coords[ 1 ];
            coord2 = poly.g4->coords[ 2 ];
            coord3 = poly.g4->coords[ 3 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] | 
                      flagsPtr[ coord3 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyG4( ( POLY_G4* )prims.ptr );

                  prims.g4->colour0.r = 230; // PCwipeout
                  prims.g4->colour0.g = 0;
                  prims.g4->colour0.b = 0;
                  prims.g4->colour1 = poly.g4->colour[ 1 ];
                  prims.g4->colour2 = poly.g4->colour[ 2 ];
                  prims.g4->colour3 = poly.g4->colour[ 3 ];

                  prims.g4->xy0 = screenPtr[ coord0 ];
                  prims.g4->xy1 = screenPtr[ coord1 ];
                  prims.g4->xy2 = screenPtr[ coord2 ];
                  prims.g4->xy3 = screenPtr[ coord3 ];

                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.g4 += 1;
               }
            }

            poly.g4 += 1;
            break;

         case TypeF3 :

            coord0 = poly.f3->coords[ 0 ];
            coord1 = poly.f3->coords[ 1 ];
            coord2 = poly.f3->coords[ 2 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyF3( ( POLY_F3* )prims.ptr );

                  prims.f3->colour0.r = 230; // PCwipeout
                  prims.f3->colour0.g = 0;
                  prims.f3->colour0.b = 0;

                  prims.f3->xy0 = screenPtr[ coord0 ];
                  prims.f3->xy1 = screenPtr[ coord1 ];
                  prims.f3->xy2 = screenPtr[ coord2 ];

                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.f3 += 1;
               }
            }

            poly.f3 += 1;
            break;

         case TypeF4 :

            coord0 = poly.f4->coords[ 0 ];
            coord1 = poly.f4->coords[ 1 ];
            coord2 = poly.f4->coords[ 2 ];
            coord3 = poly.f4->coords[ 3 ];

            if ( !( ( flagsPtr[ coord0 ] | 
                      flagsPtr[ coord1 ] | 
                      flagsPtr[ coord2 ] | 
                      flagsPtr[ coord3 ] ))); // & ClipFlag ) )
            {
               if ( NormalClip( screenPtr[ coord0 ], 
                                screenPtr[ coord1 ], 
                                screenPtr[ coord2 ] ) > 0 )
               {
                  SetPolyF4( ( POLY_F4* )prims.ptr );

                  prims.f4->colour0.r = 230; // PCwipeout
                  prims.f4->colour0.g = 0;
                  prims.f4->colour0.b = 0;

                  prims.f4->xy0 = screenPtr[ coord0 ];
                  prims.f4->xy1 = screenPtr[ coord1 ];
                  prims.f4->xy2 = screenPtr[ coord2 ];
                  prims.f4->xy3 = screenPtr[ coord3 ];

                  AddPrim( OT[ CurrentScreen ] + depth, ( ulong* ) prims.prim );

                  prims.f4 += 1;
               }
            }

            poly.f4 += 1;
            break;

		default:
	      FntPrint( "bad prim\n" );
  			break;

      }
   }
}
