sis_tris.c

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

/**********************************************************************/
/*                 High level hooks for t_vb_render.c                 */
/**********************************************************************/

/* This is called when Mesa switches between rendering triangle
 * primitives (such as GL_POLYGON, GL_QUADS, GL_TRIANGLE_STRIP, etc),
 * and lines, points and bitmaps.
 */

static void sisRasterPrimitive( GLcontext *ctx, GLuint hwprim )
{
   sisContextPtr smesa = SIS_CONTEXT(ctx);
   if (smesa->hw_primitive != hwprim) {
      SIS_FIREVERTICES(smesa);
      smesa->hw_primitive = hwprim;

      smesa->AGPParseSet &= ~(MASK_PsDataType | MASK_PsShadingMode);
      smesa->AGPParseSet |= hw_prim_agp_type[hwprim];

      if (smesa->is6326) {
	 smesa->dwPrimitiveSet &= ~(MASK_6326_DrawPrimitiveCommand |
	    MASK_6326_SetFirePosition | MASK_6326_ShadingMode);
	 smesa->dwPrimitiveSet |= hwprim | hw_prim_6326_mmio_fire[hwprim];
      } else {
	 smesa->dwPrimitiveSet &= ~(MASK_DrawPrimitiveCommand |
	    MASK_SetFirePosition | MASK_ShadingMode);
	 smesa->dwPrimitiveSet |= hwprim | hw_prim_mmio_fire[hwprim];
      }

      if (ctx->Light.ShadeModel == GL_FLAT) {
	 smesa->AGPParseSet |= hw_prim_agp_shade[hwprim];
	 smesa->dwPrimitiveSet |= hw_prim_mmio_shade[hwprim];
      } else {
	 smesa->AGPParseSet |= MASK_PsShadingSmooth;
	 if (smesa->is6326) {
	    smesa->dwPrimitiveSet |= OP_6326_3D_SHADE_FLAT_GOURAUD;
	 } else {
	    smesa->dwPrimitiveSet |= SHADE_GOURAUD;
	 }
      }
   }
}

static void sisRenderPrimitive( GLcontext *ctx, GLenum prim )
{
   sisContextPtr smesa = SIS_CONTEXT(ctx);

   smesa->render_primitive = prim;

   if (prim >= GL_TRIANGLES && (ctx->_TriangleCaps & DD_TRI_UNFILLED))
      return;
   sisRasterPrimitive( ctx, hw_prim[prim] );
}

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

#define EMIT_PAD( N )							\
do {									\
   smesa->vertex_attrs[smesa->vertex_attr_count].attrib = 0;		\
   smesa->vertex_attrs[smesa->vertex_attr_count].format = EMIT_PAD;	\
   smesa->vertex_attrs[smesa->vertex_attr_count].offset = (N);		\
   smesa->vertex_attr_count++;						\
} while (0)
				
static void sisRenderStart( GLcontext *ctx )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   sisContextPtr smesa = SIS_CONTEXT(ctx);
   struct vertex_buffer *VB = &tnl->vb;
   DECLARE_RENDERINPUTS(index_bitset);
   GLuint AGPParseSet = smesa->AGPParseSet;
   GLboolean tex_fallback = GL_FALSE;

   RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );

   if (ctx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT && 
      smesa->driDrawable->numClipRects != 0)
   {
      multipass_cliprect(ctx, 0);
      if (smesa->driDrawable->numClipRects > 1)
         tnl->Driver.Render.Multipass = multipass_cliprect;
      else
         tnl->Driver.Render.Multipass = NULL;
   } else {
      tnl->Driver.Render.Multipass = NULL;
   }

   /* Important:
    */
   VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
   smesa->vertex_attr_count = 0;

   /* EMIT_ATTR's must be in order as they tell t_vertex.c how to build up a
    * hardware vertex.
    */

   AGPParseSet &= ~(MASK_VertexDWSize | MASK_VertexDataFormat);
   AGPParseSet |= SiS_PS_HAS_XYZ | SiS_PS_HAS_DIFFUSE;
   if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
      EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_4F_VIEWPORT);
      AGPParseSet |= SiS_PS_HAS_W;
      smesa->coloroffset = 4;
   } else {
      EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_3F_VIEWPORT);
      smesa->coloroffset = 3;
   }

   EMIT_ATTR(_TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA);

   smesa->specoffset = 0;
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
       RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
      AGPParseSet |= SiS_PS_HAS_SPECULAR;

      if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
	 EMIT_ATTR(_TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR);
	 smesa->specoffset = smesa->coloroffset + 1;
      } else {
	 EMIT_PAD(3);
      }

      if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
	 EMIT_ATTR(_TNL_ATTRIB_FOG, EMIT_1UB_1F);
      } else {
	 EMIT_PAD(1);
      }
   }

   /* projective textures are not supported by the hardware */
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
      if (VB->TexCoordPtr[0]->size > 2)
	 tex_fallback = GL_TRUE;
      EMIT_ATTR(_TNL_ATTRIB_TEX0, EMIT_2F);
      AGPParseSet |= SiS_PS_HAS_UV0;
   }
   /* Will only hit tex1 on SiS300 */
   if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
      if (VB->TexCoordPtr[1]->size > 2)
	 tex_fallback = GL_TRUE;
      EMIT_ATTR(_TNL_ATTRIB_TEX1, EMIT_2F);
      AGPParseSet |= SiS_PS_HAS_UV1;
   }
   FALLBACK(smesa, SIS_FALLBACK_TEXTURE, tex_fallback);

   if (!RENDERINPUTS_EQUAL( smesa->last_tcl_state_bitset, index_bitset )) {
      smesa->AGPParseSet = AGPParseSet;

      smesa->vertex_size =  _tnl_install_attrs( ctx, smesa->vertex_attrs, 
	 smesa->vertex_attr_count, smesa->hw_viewport, 0 );

      smesa->vertex_size >>= 2;
      smesa->AGPParseSet |= smesa->vertex_size << 28;
   }
}

static void sisRenderFinish( GLcontext *ctx )
{
}

/**********************************************************************/
/*                    AGP/PCI vertex submission                       */
/**********************************************************************/

void
sisFlushPrimsLocked(sisContextPtr smesa)
{
   if (smesa->vb_cur == smesa->vb_last)
      return;

   if (smesa->is6326)
      sis6326UpdateHWState(smesa->glCtx);
   else
      sisUpdateHWState(smesa->glCtx);

   if (smesa->using_agp) {
      mWait3DCmdQueue(8);
      mEndPrimitive();
      MMIO(REG_3D_AGPCmBase, (smesa->vb_last - smesa->vb) +
         smesa->vb_agp_offset);
      MMIO(REG_3D_AGPTtDwNum, ((smesa->vb_cur - smesa->vb_last) / 4) |
	 0x50000000);
      MMIO(REG_3D_ParsingSet, smesa->AGPParseSet);
      MMIO(REG_3D_AGPCmFire, (GLint)(-1));
      mEndPrimitive();
   } else {
      int mmio_index = 0, incr = 0;
      void (*sis_emit_func)(sisContextPtr smesa, char *verts) = NULL;

      if (smesa->AGPParseSet & MASK_PsShadingSmooth)
	 mmio_index |= VERT_SMOOTH;
      if (smesa->AGPParseSet & SiS_PS_HAS_SPECULAR)
	 mmio_index |= VERT_SPEC;
      if (smesa->AGPParseSet & SiS_PS_HAS_W)
	 mmio_index |= VERT_W;
      if (smesa->AGPParseSet & SiS_PS_HAS_UV0)
	 mmio_index |= VERT_UV0;
      if (smesa->AGPParseSet & SiS_PS_HAS_UV1)
	 mmio_index |= VERT_UV1;
      if (smesa->is6326)
	 mmio_index |= VERT_6326;

      switch (smesa->AGPParseSet & MASK_PsDataType) {
      case MASK_PsPointList:
         incr = smesa->vertex_size * 4;
	 sis_emit_func = sis_point_func_mmio[mmio_index];
	 break;
      case MASK_PsLineList:
         incr = smesa->vertex_size * 4 * 2;
	 sis_emit_func = sis_line_func_mmio[mmio_index];
	 break;
      case MASK_PsTriangleList:
         incr = smesa->vertex_size * 4 * 3;
	 sis_emit_func = sis_tri_func_mmio[mmio_index];
	 break;
      }

      if (!smesa->is6326) {
	 mWait3DCmdQueue(1);
	 MMIO(REG_3D_PrimitiveSet, smesa->dwPrimitiveSet);
      }
      while (smesa->vb_last < smesa->vb_cur) {
	 sis_emit_func(smesa, smesa->vb_last);
	 smesa->vb_last += incr;
      }
      mWait3DCmdQueue(1);
      mEndPrimitive();

      /* With PCI, we can just start writing to the start of the VB again. */
      smesa->vb_cur = smesa->vb;
   }
   smesa->vb_last = smesa->vb_cur;
}

void sisFlushPrims(sisContextPtr smesa)
{
   LOCK_HARDWARE();
   sisFlushPrimsLocked(smesa);
   UNLOCK_HARDWARE();
}

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

static const char * const fallbackStrings[] = {
   "Texture mode",
   "Texture 0 mode",
   "Texture 1 mode",
   "Texture 0 env",	/* Note: unused */
   "Texture 1 env",	/* Note: unused */
   "glDrawBuffer(GL_FRONT_AND_BACK)",
   "glEnable(GL_STENCIL) without hw stencil buffer",
   "write mask",
   "no_rast",
};

static const char *getFallbackString(GLuint bit)
{
   int i = 0;
   while (bit > 1) {
      i++;
      bit >>= 1;
   }
   return fallbackStrings[i];
}

void sisFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   sisContextPtr smesa = SIS_CONTEXT(ctx);
   GLuint oldfallback = smesa->Fallback;

   if (mode) {
      smesa->Fallback |= bit;
      if (oldfallback == 0) {
	 SIS_FIREVERTICES(smesa);
	 _swsetup_Wakeup( ctx );
	 smesa->RenderIndex = ~0;
         if (SIS_DEBUG & DEBUG_FALLBACKS) {
            fprintf(stderr, "SiS begin rasterization fallback: 0x%x %s\n",
                    bit, getFallbackString(bit));
         }
      }
   }
   else {
      smesa->Fallback &= ~bit;
      if (oldfallback == bit) {
	 _swrast_flush( ctx );
	 tnl->Driver.Render.Start = sisRenderStart;
	 tnl->Driver.Render.PrimitiveNotify = sisRenderPrimitive;
	 tnl->Driver.Render.Finish = sisRenderFinish;

	 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, 
			     smesa->vertex_attrs, 
			     smesa->vertex_attr_count,
			     smesa->hw_viewport, 0 ); 

	 smesa->NewGLState |= _SIS_NEW_RENDER_STATE;
         if (SIS_DEBUG & DEBUG_FALLBACKS) {
            fprintf(stderr, "SiS end rasterization fallback: 0x%x %s\n",
                    bit, getFallbackString(bit));
         }
      }
   }
}


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

void sisInitTriFuncs( GLcontext *ctx )
{
   sisContextPtr smesa = SIS_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   static int firsttime = 1;

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

      sis_vert_init_none();
      sis_vert_init_g();
      sis_vert_init_w();
      sis_vert_init_gw();
      sis_vert_init_s();
      sis_vert_init_gs();
      sis_vert_init_ws();
      sis_vert_init_gws();
      sis_vert_init_t0();
      sis_vert_init_gt0();
      sis_vert_init_wt0();
      sis_vert_init_gwt0();
      sis_vert_init_st0();
      sis_vert_init_gst0();
      sis_vert_init_wst0();
      sis_vert_init_gwst0();
      sis_vert_init_t1();
      sis_vert_init_gt1();
      sis_vert_init_wt1();
      sis_vert_init_gwt1();
      sis_vert_init_st1();
      sis_vert_init_gst1();
      sis_vert_init_wst1();
      sis_vert_init_gwst1();
      sis_vert_init_t0t1();
      sis_vert_init_gt0t1();
      sis_vert_init_wt0t1();
      sis_vert_init_gwt0t1();
      sis_vert_init_st0t1();
      sis_vert_init_gst0t1();
      sis_vert_init_wst0t1();
      sis_vert_init_gwst0t1();
   }

   smesa->RenderIndex = ~0;
   smesa->NewGLState |= _SIS_NEW_RENDER_STATE;

   tnl->Driver.RunPipeline = sisRunPipeline;
   tnl->Driver.Render.Start = sisRenderStart;
   tnl->Driver.Render.Finish = sisRenderFinish;
   tnl->Driver.Render.PrimitiveNotify = sisRenderPrimitive;
   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) );

   smesa->verts = (char *)tnl->clipspace.vertex_buf;
}