savagetris.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

 */
static GLboolean savageCheckPTexHack( GLcontext *ctx )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   DECLARE_RENDERINPUTS(index_bitset);

   RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );

   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 ) && VB->TexCoordPtr[0]->size == 4) {
      if (!RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_ATTRIB_TEX1, _TNL_LAST_TEX ))
	 return GL_TRUE; /* apply ptex hack */
      else
	 FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE);
   }
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 ) && VB->TexCoordPtr[1]->size == 4)
      FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE);

   return GL_FALSE; /* don't apply ptex hack */
}


#define DO_EMIT_ATTR( ATTR, STYLE )					\
do {									\
   imesa->vertex_attrs[imesa->vertex_attr_count].attrib = (ATTR);	\
   imesa->vertex_attrs[imesa->vertex_attr_count].format = (STYLE);	\
   imesa->vertex_attr_count++;						\
} while (0)

#define NEED_ATTR( INDEX, SKIP )					\
do {									\
   setupIndex |= (INDEX);						\
   skip &= ~(SKIP);							\
} while (0)

#define EMIT_ATTR( ATTR, STYLE, INDEX, SKIP )				\
do {									\
   NEED_ATTR( INDEX, SKIP );						\
   DO_EMIT_ATTR( ATTR, STYLE );						\
} while (0)

#define EMIT_PAD( N )							\
do {									\
   imesa->vertex_attrs[imesa->vertex_attr_count].attrib = 0;		\
   imesa->vertex_attrs[imesa->vertex_attr_count].format = EMIT_PAD;	\
   imesa->vertex_attrs[imesa->vertex_attr_count].offset = (N);		\
   imesa->vertex_attr_count++;						\
} while (0)

#define SAVAGE_EMIT_XYZ  0x0001
#define SAVAGE_EMIT_W    0x0002
#define SAVAGE_EMIT_C0   0x0004
#define SAVAGE_EMIT_C1   0x0008
#define SAVAGE_EMIT_FOG  0x0010
#define SAVAGE_EMIT_S0   0x0020
#define SAVAGE_EMIT_T0   0x0040
#define SAVAGE_EMIT_Q0   0x0080
#define SAVAGE_EMIT_ST0  0x0060
#define SAVAGE_EMIT_STQ0 0x00e0
#define SAVAGE_EMIT_S1   0x0100
#define SAVAGE_EMIT_T1   0x0200
#define SAVAGE_EMIT_ST1  0x0300


static INLINE GLuint savageChooseVertexFormat_s3d( GLcontext *ctx )
{
   savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   DECLARE_RENDERINPUTS(index_bitset);
   GLuint setupIndex = SAVAGE_EMIT_XYZ;
   GLubyte skip;

   RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
   imesa->vertex_attr_count = 0;

   skip = SAVAGE_SKIP_ALL_S3D;
   skip &= ~SAVAGE_SKIP_Z; /* all mesa vertices have a z coordinate */

   /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
    * build up a hardware vertex.
    */
   if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ) || !(ctx->_TriangleCaps & DD_FLATSHADE))
      EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, SAVAGE_EMIT_W, SAVAGE_SKIP_W );
   else {
      EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 0 );
      EMIT_PAD( 4 );
      skip &= ~SAVAGE_SKIP_W;
   }

   /* t_context.c always includes a diffuse color */
   EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 );

   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ))
      EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 );
   else
      EMIT_PAD( 3 );
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
      EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 );
   else
      EMIT_PAD( 1 );
   skip &= ~SAVAGE_SKIP_C1;

   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
      if (imesa->ptexHack)
	 EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW, SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0);
      else if (VB->TexCoordPtr[0]->size == 4)
	 assert (0); /* should be caught by savageCheckPTexHack */
      else if (VB->TexCoordPtr[0]->size >= 2)
	 /* The chromium menu emits some 3D tex coords even though no
	  * 3D texture is enabled. Ignore the 3rd coordinate. */
	 EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_2F, SAVAGE_EMIT_ST0, SAVAGE_SKIP_ST0 );
      else if (VB->TexCoordPtr[0]->size == 1) {
	 EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_1F, SAVAGE_EMIT_S0, SAVAGE_SKIP_S0 );
	 EMIT_PAD( 4 );
      } else
	 EMIT_PAD( 8 );
   } else
      EMIT_PAD( 8 );
   skip &= ~SAVAGE_SKIP_ST0;

   assert (skip == 0);
   imesa->skip = skip;
   return setupIndex;
}


static INLINE GLuint savageChooseVertexFormat_s4( GLcontext *ctx )
{
   savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   DECLARE_RENDERINPUTS(index_bitset);
   GLuint setupIndex = SAVAGE_EMIT_XYZ;
   GLubyte skip;
   GLuint size, mask;

   RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
   skip = SAVAGE_SKIP_ALL_S4;
   skip &= ~SAVAGE_SKIP_Z; /* all mesa vertices have a z coordinate */

   if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ) || !(ctx->_TriangleCaps & DD_FLATSHADE))
      NEED_ATTR( SAVAGE_EMIT_W, SAVAGE_SKIP_W );

   /* t_context.c always includes a diffuse color */
   NEED_ATTR( SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 );

   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ))
      NEED_ATTR( SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 );
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
      NEED_ATTR( SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 );

   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
      if (imesa->ptexHack)
	 NEED_ATTR( SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0);
      else if (VB->TexCoordPtr[0]->size == 4)
	 assert (0); /* should be caught by savageCheckPTexHack */
      else if (VB->TexCoordPtr[0]->size >= 2)
	 /* The chromium menu emits some 3D tex coords even though no
	  * 3D texture is enabled. Ignore the 3rd coordinate. */
	 NEED_ATTR( SAVAGE_EMIT_ST0, SAVAGE_SKIP_ST0 );
      else
	 NEED_ATTR( SAVAGE_EMIT_S0, SAVAGE_SKIP_S0 );
   }
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
      if (VB->TexCoordPtr[1]->size == 4)
	 /* projective textures are not supported by the hardware */
	 assert (0); /* should be caught by savageCheckPTexHack */
      else if (VB->TexCoordPtr[1]->size >= 2)
	 NEED_ATTR( SAVAGE_EMIT_ST1, SAVAGE_SKIP_ST1 );
      else
	 NEED_ATTR( SAVAGE_EMIT_S1, SAVAGE_SKIP_S1 );
   }

   /* if nothing changed we can skip the rest */
   if (setupIndex == imesa->SetupIndex && imesa->vertex_size != 0)
      return setupIndex;

   if (imesa->enable_vdma) {
      mask = SAVAGE_SKIP_W;
      size = 10 - (skip & 1) - (skip >> 1 & 1) -
	 (skip >> 2 & 1) - (skip >> 3 & 1) - (skip >> 4 & 1) -
	 (skip >> 5 & 1) - (skip >> 6 & 1) - (skip >> 7 & 1);

      while (size < 8) {
	 if (skip & mask) {
	    skip &= ~mask;
	    size++;
	 }
	 mask <<= 1;
      }
   }

   imesa->vertex_attr_count = 0;

   if (skip & SAVAGE_SKIP_W)
      DO_EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT );
   else if (setupIndex & SAVAGE_EMIT_W)
      DO_EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT );
   else {
      DO_EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT );
      EMIT_PAD( 4 );
   }

   DO_EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA );

   if (!(skip & SAVAGE_SKIP_C1)) {
      if (!(setupIndex & (SAVAGE_EMIT_C1|SAVAGE_EMIT_FOG)))
	 EMIT_PAD( 4 );
      else {
	 if (setupIndex & SAVAGE_EMIT_C1)
	    DO_EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR );
	 else
	    EMIT_PAD( 3 );
	 if (setupIndex & SAVAGE_EMIT_FOG)
	    DO_EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F );
	 else
	    EMIT_PAD( 1 );
      }
   }

   if ((skip & SAVAGE_SKIP_ST0) != SAVAGE_SKIP_ST0) {
      if ((setupIndex & SAVAGE_EMIT_STQ0) == SAVAGE_EMIT_STQ0)
	 DO_EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW );
      else if ((setupIndex & SAVAGE_EMIT_ST0) == SAVAGE_EMIT_ST0)
	 DO_EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_2F );
      else if ((setupIndex & SAVAGE_EMIT_ST0) == SAVAGE_EMIT_S0) {
	 DO_EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_1F );
	 if (!(skip & SAVAGE_SKIP_T0)) EMIT_PAD( 4 );
      } else {
	 if (!(skip & SAVAGE_SKIP_S0)) EMIT_PAD( 4 );
	 if (!(skip & SAVAGE_SKIP_T0)) EMIT_PAD( 4 );
      }
   }

   if ((skip & SAVAGE_SKIP_ST1) != SAVAGE_SKIP_ST1) {
      if ((setupIndex & SAVAGE_EMIT_ST1) == SAVAGE_EMIT_ST1)
	 DO_EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F );
      else if ((setupIndex & SAVAGE_EMIT_ST1) == SAVAGE_EMIT_S1) {
	 DO_EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_1F );
	 if (!(skip & SAVAGE_SKIP_T1)) EMIT_PAD( 4 );
      } else {
	 if (!(skip & SAVAGE_SKIP_S1)) EMIT_PAD( 4 );
	 if (!(skip & SAVAGE_SKIP_T1)) EMIT_PAD( 4 );
      }
   }

   imesa->skip = skip;
   return setupIndex;
}


static void savageRenderStart( GLcontext *ctx )
{
   savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   GLuint setupIndex = SAVAGE_EMIT_XYZ;
   GLboolean ptexHack;

   /* Check if we need to apply the ptex hack. Choose a new render
    * state if necessary. (Note: this can't be done in
    * savageRunPipeline, since the number of vertex coordinates can
    * change in the pipeline. texmat or texgen or both?) */
   ptexHack = savageCheckPTexHack( ctx );
   if (ptexHack != imesa->ptexHack) {
      imesa->ptexHack = ptexHack;
      savageChooseRenderState (ctx);
   }
   /* Handle fallback cases identified in savageCheckPTexHack. */
   if (SAVAGE_CONTEXT(ctx)->Fallback) {
      tnl->Driver.Render.Start(ctx);
      return;
   }

   /* Important:
    */
   VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
 
   if (imesa->savageScreen->chipset < S3_SAVAGE4) {
      setupIndex = savageChooseVertexFormat_s3d(ctx);
   } else {
      setupIndex = savageChooseVertexFormat_s4(ctx);
   }

   /* Need to change the vertex emit code if the SetupIndex changed or
    * is set for the first time (indicated by vertex_size == 0). */
   if (setupIndex != imesa->SetupIndex || imesa->vertex_size == 0) {
      GLuint hwVertexSize;
      imesa->vertex_size =
	 _tnl_install_attrs( ctx, 
			     imesa->vertex_attrs, 
			     imesa->vertex_attr_count,
			     imesa->hw_viewport, 0 );
      imesa->vertex_size >>= 2;
      imesa->SetupIndex = setupIndex;

      hwVertexSize = imesa->vertex_size;
      if (setupIndex & SAVAGE_EMIT_Q0) {
	 /* The vertex setup code emits homogenous texture
	  * coordinates. They are converted to normal 2D coords by
	  * savage_ptex_tri/line/point. Now we have two different
	  * vertex sizes. Functions that emit vertices to the hardware
	  * need to use HwVertexSize, anything that manipulates the
	  * vertices generated by t_vertex uses vertex_size. */
	 hwVertexSize--;
	 assert (imesa->ptexHack);
      } else
	 assert (!imesa->ptexHack);

      if (hwVertexSize != imesa->HwVertexSize) {
	 /* Changing the vertex size: flush vertex and command buffer and
	  * discard the DMA buffer, if we were using one. */
	 savageFlushVertices(imesa);
	 savageFlushCmdBuf(imesa, GL_TRUE);
	 if (hwVertexSize == 8 && imesa->enable_vdma) {
	    if (SAVAGE_DEBUG & DEBUG_DMA)
	       fprintf (stderr, "Using DMA, skip=0x%02x\n", imesa->skip);
	    /* we can use vertex dma */
	    imesa->vtxBuf = &imesa->dmaVtxBuf;
	 } else {
	    if (SAVAGE_DEBUG & DEBUG_DMA)
	       fprintf (stderr, "Not using DMA, skip=0x%02x\n", imesa->skip);
	    imesa->vtxBuf = &imesa->clientVtxBuf;
	 }
	 imesa->HwVertexSize = hwVertexSize;
      }
   }
}

static void savageRenderFinish( GLcontext *ctx )
{
   /* Flush the last primitive now, before any state is changed. */
   savageFlushVertices(SAVAGE_CONTEXT(ctx));

   if (SAVAGE_CONTEXT(ctx)->RenderIndex & SAVAGE_FALLBACK_BIT)
      _swrast_flush( ctx );
}


/**********************************************************************/
/*           Transition to/from hardware rasterization.               */
/**********************************************************************/

static const char * const fallbackStrings[] = {
   "Texture mode",
   "Draw buffer",
   "Read buffer",
   "Color mask",
   "Specular",
   "LogicOp",
   "glEnable(GL_STENCIL) without hw stencil buffer",
   "glRenderMode(selection or feedback)",
   "glBlendEquation",
   "Hardware rasterization disabled",
   "Projective texture",
};

void savageFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
   GLuint oldfallback = imesa->Fallback;
   GLuint index;
   for (index = 0; (1 << index) < bit; ++index);

   if (mode) {
      imesa->Fallback |= bit;
      if (oldfallback == 0) {
	 /* the first fallback */
	 _swsetup_Wakeup( ctx );
	 imesa->RenderIndex = ~0;
      }
      if (!(oldfallback & bit) && (SAVAGE_DEBUG & DEBUG_FALLBACKS))
	 fprintf (stderr, "Savage begin fallback: 0x%x %s\n",
		  bit, fallbackStrings[index]);
   }
   else {
      imesa->Fallback &= ~bit;
      if (oldfallback == bit) {
	 /* the last fallback */
	 _swrast_flush( ctx );
	 tnl->Driver.Render.Start = savageRenderStart;
	 tnl->Driver.Render.PrimitiveNotify = savageRenderPrimitive;
	 tnl->Driver.Render.Finish = savageRenderFinish;

	 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
	 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
	 tnl->Driver.Render.Interp = _tnl_interp;

	 _tnl_invalidate_vertex_state( ctx, ~0 );
	 _tnl_invalidate_vertices( ctx, ~0 );
	 _tnl_install_attrs( ctx, 
			     imesa->vertex_attrs, 
			     imesa->vertex_attr_count,
			     imesa->hw_viewport, 0 ); 

	 imesa->new_gl_state |= _SAVAGE_NEW_RENDER_STATE;
      }
      if ((oldfallback & bit) && (SAVAGE_DEBUG & DEBUG_FALLBACKS))
	 fprintf (stderr, "Savage end fallback: 0x%x %s\n",
		  bit, fallbackStrings[index]);
   }
}


/**********************************************************************/
/*                            Initialization.                         */
/**********************************************************************/

void savageInitTriFuncs( GLcontext *ctx )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   static int firsttime = 1;

   if (firsttime) {
      init_rast_tab();
      firsttime = 0;
   }

   tnl->Driver.RunPipeline = savageRunPipeline;
   tnl->Driver.Render.Start = savageRenderStart;
   tnl->Driver.Render.Finish = savageRenderFinish;
   tnl->Driver.Render.PrimitiveNotify = savageRenderPrimitive;
   tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;

   tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
   tnl->Driver.Render.CopyPV = _tnl_copy_pv;
   tnl->Driver.Render.Interp = _tnl_interp;

   _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12, 
		       (6 + 2*ctx->Const.MaxTextureUnits) * sizeof(GLfloat) );
   
   SAVAGE_CONTEXT(ctx)->verts = (char *)tnl->clipspace.vertex_buf;
}