fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-07 20:08:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

More GLSL code:

Browse source 
- use macros to access and modify render inputs bit-field;
- un-alias generic vertex attributes for ARB vertex calls;
- use MAX_VERTEX_PROGRAM_ATTRIBS (NV code) or MAX_VERTEX_ATTRIBS
  (ARB code) in place of VERT_ATTRIB_MAX;
- define VERT_ATTRIB_GENERIC0..15 for un-aliased vertex
  attributes for ARB_vertex_shader;
- fix generic attribute index range check in arbprogparse.c;
- interface GLSL varyings between vertex and fragment shader;
- use 64-bit optimised bitset (bitset.h) for render inputs;
This commit is contained in:
Michal Krol 2006-04-11 11:41:11 +00:00
parent d90ad3fd87
commit bb38cadb1c
39 changed files with 879 additions and 580 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/mesa/drivers/dri/i915/i830_context.h
View file

@ -118,7 +118,7 @@ struct i830_context
{ {
struct intel_context intel; struct intel_context intel;
GLuint last_index; DECLARE_RENDERINPUTS(last_index_bitset);
struct i830_hw_state meta, initial, state, *current; struct i830_hw_state meta, initial, state, *current;
}; };

23
src/mesa/drivers/dri/i915/i830_vtbl.c
View file

@ -65,11 +65,13 @@ static void i830_render_start( intelContextPtr intel )
i830ContextPtr i830 = I830_CONTEXT(intel); i830ContextPtr i830 = I830_CONTEXT(intel);
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint v0 = _3DSTATE_VFT0_CMD; GLuint v0 = _3DSTATE_VFT0_CMD;
GLuint v2 = _3DSTATE_VFT1_CMD; GLuint v2 = _3DSTATE_VFT1_CMD;
GLuint mcsb1 = 0; GLuint mcsb1 = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
/* Important: /* Important:
*/ */
VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr; VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
@ -78,7 +80,7 @@ static void i830_render_start( intelContextPtr intel )
/* EMIT_ATTR's must be in order as they tell t_vertex.c how to /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, VFT0_XYZW ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, VFT0_XYZW );
intel->coloroffset = 4; intel->coloroffset = 4;
} }
@ -87,32 +89,33 @@ static void i830_render_start( intelContextPtr intel )
intel->coloroffset = 3; intel->coloroffset = 3;
} }
if (index & _TNL_BIT_POINTSIZE) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE )) {
EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, VFT0_POINT_WIDTH ); EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, VFT0_POINT_WIDTH );
} }
EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, VFT0_DIFFUSE ); EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, VFT0_DIFFUSE );
intel->specoffset = 0; intel->specoffset = 0;
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
if (index & _TNL_BIT_COLOR1) { RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
intel->specoffset = intel->coloroffset + 1; intel->specoffset = intel->coloroffset + 1;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, VFT0_SPEC ); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, VFT0_SPEC );
} }
else else
EMIT_PAD( 3 ); EMIT_PAD( 3 );
if (index & _TNL_BIT_FOG) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, VFT0_SPEC ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, VFT0_SPEC );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
int i, count = 0; int i, count = 0;
for (i = 0; i < I830_TEX_UNITS; i++) { for (i = 0; i < I830_TEX_UNITS; i++) {
if (index & _TNL_BIT_TEX(i)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
GLuint sz = VB->TexCoordPtr[i]->size; GLuint sz = VB->TexCoordPtr[i]->size;
GLuint emit; GLuint emit;
GLuint mcs = (i830->state.Tex[i][I830_TEXREG_MCS] & GLuint mcs = (i830->state.Tex[i][I830_TEXREG_MCS] &
@ -162,7 +165,7 @@ static void i830_render_start( intelContextPtr intel )
if (v0 != i830->state.Ctx[I830_CTXREG_VF] || if (v0 != i830->state.Ctx[I830_CTXREG_VF] ||
v2 != i830->state.Ctx[I830_CTXREG_VF2] || v2 != i830->state.Ctx[I830_CTXREG_VF2] ||
mcsb1 != i830->state.Ctx[I830_CTXREG_MCSB1] || mcsb1 != i830->state.Ctx[I830_CTXREG_MCSB1] ||
index != i830->last_index) { !RENDERINPUTS_EQUAL( index_bitset, i830->last_index_bitset )) {
I830_STATECHANGE( i830, I830_UPLOAD_CTX ); I830_STATECHANGE( i830, I830_UPLOAD_CTX );
@ -180,7 +183,7 @@ static void i830_render_start( intelContextPtr intel )
i830->state.Ctx[I830_CTXREG_VF] = v0; i830->state.Ctx[I830_CTXREG_VF] = v0;
i830->state.Ctx[I830_CTXREG_VF2] = v2; i830->state.Ctx[I830_CTXREG_VF2] = v2;
i830->state.Ctx[I830_CTXREG_MCSB1] = mcsb1; i830->state.Ctx[I830_CTXREG_MCSB1] = mcsb1;
i830->last_index = index; RENDERINPUTS_COPY( i830->last_index_bitset, index_bitset );
assert(i830_check_vertex_size( intel, intel->vertex_size )); assert(i830_check_vertex_size( intel, intel->vertex_size ));
} }

21
src/mesa/drivers/dri/i915/i915_texprog.c
View file

@ -576,11 +576,13 @@ void i915ValidateTextureProgram( i915ContextPtr i915 )
GLcontext *ctx = &intel->ctx; GLcontext *ctx = &intel->ctx;
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
int i, offset; int i, offset;
GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK; GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK;
GLuint s2 = S2_TEXCOORD_NONE; GLuint s2 = S2_TEXCOORD_NONE;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
/* Important: /* Important:
*/ */
VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr; VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
@ -591,9 +593,9 @@ void i915ValidateTextureProgram( i915ContextPtr i915 )
if (i915->vertex_fog == I915_FOG_PIXEL) { if (i915->vertex_fog == I915_FOG_PIXEL) {
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, S4_VFMT_XYZW, 16 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, S4_VFMT_XYZW, 16 );
index &= ~_TNL_BIT_FOG; RENDERINPUTS_CLEAR( index_bitset, _TNL_ATTRIB_FOG );
} }
else if (index & _TNL_BITS_TEX_ANY) { else if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, S4_VFMT_XYZW, 16 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, S4_VFMT_XYZW, 16 );
} }
else { else {
@ -601,29 +603,30 @@ void i915ValidateTextureProgram( i915ContextPtr i915 )
} }
/* How undefined is undefined? */ /* How undefined is undefined? */
if (index & _TNL_BIT_POINTSIZE) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE )) {
EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, S4_VFMT_POINT_WIDTH, 4 ); EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, S4_VFMT_POINT_WIDTH, 4 );
} }
intel->coloroffset = offset / 4; intel->coloroffset = offset / 4;
EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, S4_VFMT_COLOR, 4 ); EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, S4_VFMT_COLOR, 4 );
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
if (index & _TNL_BIT_COLOR1) { RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
intel->specoffset = offset / 4; intel->specoffset = offset / 4;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, S4_VFMT_SPEC_FOG, 3 ); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, S4_VFMT_SPEC_FOG, 3 );
} else } else
EMIT_PAD( 3 ); EMIT_PAD( 3 );
if (index & _TNL_BIT_FOG) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, S4_VFMT_SPEC_FOG, 1 ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, S4_VFMT_SPEC_FOG, 1 );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
if (index & _TNL_BIT_TEX(i)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
int sz = VB->TexCoordPtr[i]->size; int sz = VB->TexCoordPtr[i]->size;
s2 &= ~S2_TEXCOORD_FMT(i, S2_TEXCOORD_FMT0_MASK); s2 &= ~S2_TEXCOORD_FMT(i, S2_TEXCOORD_FMT0_MASK);

2
src/mesa/drivers/dri/r128/r128_context.c
View file

@ -190,7 +190,7 @@ GLboolean r128CreateContext( const __GLcontextModes *glVisual,
rmesa->RenderIndex = -1; /* Impossible value */ rmesa->RenderIndex = -1; /* Impossible value */
rmesa->vert_buf = NULL; rmesa->vert_buf = NULL;
rmesa->num_verts = 0; rmesa->num_verts = 0;
rmesa->tnl_state = ~0; RENDERINPUTS_ONES( rmesa->tnl_state_bitset );
/* Set the maximum texture size small enough that we can guarentee that /* Set the maximum texture size small enough that we can guarentee that
* all texture units can bind a maximal texture and have them both in * all texture units can bind a maximal texture and have them both in

2
src/mesa/drivers/dri/r128/r128_context.h
View file

@ -130,7 +130,7 @@ struct r128_context {
char *verts; /* points to tnl->clipspace.vertex_buf */ char *verts; /* points to tnl->clipspace.vertex_buf */
GLuint num_verts; GLuint num_verts;
int coloroffset, specoffset; int coloroffset, specoffset;
int tnl_state; /* tnl->render_inputs for this _tnl_install_attrs */ DECLARE_RENDERINPUTS(tnl_state_bitset); /* tnl->render_inputs for this _tnl_install_attrs */
GLuint NewGLState; GLuint NewGLState;
GLuint Fallback; GLuint Fallback;

2
src/mesa/drivers/dri/r128/r128_lock.c
View file

@ -89,7 +89,7 @@ void r128GetLock( r128ContextPtr rmesa, GLuint flags )
driUpdateFramebufferSize(rmesa->glCtx, dPriv); driUpdateFramebufferSize(rmesa->glCtx, dPriv);
rmesa->lastStamp = dPriv->lastStamp; rmesa->lastStamp = dPriv->lastStamp;
rmesa->new_state |= R128_NEW_CLIP; rmesa->new_state |= R128_NEW_CLIP;
rmesa->tnl_state = ~0; RENDERINPUTS_ONES( rmesa->tnl_state_bitset );
} }
rmesa->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_CLIPRECTS; rmesa->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_CLIPRECTS;

25
src/mesa/drivers/dri/r128/r128_tris.c
View file

@ -564,11 +564,13 @@ static void r128RenderStart( GLcontext *ctx )
r128ContextPtr rmesa = R128_CONTEXT(ctx); r128ContextPtr rmesa = R128_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint vc_frmt = 0; GLuint vc_frmt = 0;
GLboolean fallback_projtex = GL_FALSE; GLboolean fallback_projtex = GL_FALSE;
GLuint offset = 0; GLuint offset = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
/* Important: */ /* Important: */
VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr; VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
rmesa->vertex_attr_count = 0; rmesa->vertex_attr_count = 0;
@ -577,7 +579,7 @@ static void r128RenderStart( GLcontext *ctx )
/* EMIT_ATTR's must be in order as they tell t_vertex.c how to /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if ( index & _TNL_BITS_TEX_ANY ) if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ))
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 16 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 16 );
else else
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 12 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 12 );
@ -591,28 +593,29 @@ static void r128RenderStart( GLcontext *ctx )
R128_CCE_VC_FRMT_DIFFUSE_ARGB, 4 ); R128_CCE_VC_FRMT_DIFFUSE_ARGB, 4 );
#endif #endif
if ( index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG) ) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
#if MESA_LITTLE_ENDIAN #if MESA_LITTLE_ENDIAN
if ( index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->specoffset = offset; rmesa->specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR,
R128_CCE_VC_FRMT_SPEC_FRGB, 3 ); R128_CCE_VC_FRMT_SPEC_FRGB, 3 );
} else } else
EMIT_PAD( 3 ); EMIT_PAD( 3 );
if (index & _TNL_BIT_FOG) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB, EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
1 ); 1 );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
#else #else
if (index & _TNL_BIT_FOG) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB, EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, R128_CCE_VC_FRMT_SPEC_FRGB,
1 ); 1 );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
if ( index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->specoffset = offset; rmesa->specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB,
R128_CCE_VC_FRMT_SPEC_FRGB, 3 ); R128_CCE_VC_FRMT_SPEC_FRGB, 3 );
@ -621,12 +624,12 @@ static void r128RenderStart( GLcontext *ctx )
#endif #endif
} }
if ( index & _TNL_BIT_TEX(rmesa->tmu_source[0]) ) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(rmesa->tmu_source[0]) )) {
if ( VB->TexCoordPtr[rmesa->tmu_source[0]]->size > 2 ) if ( VB->TexCoordPtr[rmesa->tmu_source[0]]->size > 2 )
fallback_projtex = GL_TRUE; fallback_projtex = GL_TRUE;
EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_2F, R128_CCE_VC_FRMT_S_T, 8 ); EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_2F, R128_CCE_VC_FRMT_S_T, 8 );
} }
if ( index & _TNL_BIT_TEX(rmesa->tmu_source[1]) ) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(rmesa->tmu_source[1]) )) {
if ( VB->TexCoordPtr[rmesa->tmu_source[1]]->size > 2 ) if ( VB->TexCoordPtr[rmesa->tmu_source[1]]->size > 2 )
fallback_projtex = GL_TRUE; fallback_projtex = GL_TRUE;
EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F, R128_CCE_VC_FRMT_S2_T2, 8 ); EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F, R128_CCE_VC_FRMT_S2_T2, 8 );
@ -638,7 +641,7 @@ static void r128RenderStart( GLcontext *ctx )
/* Only need to change the vertex emit code if there has been a /* Only need to change the vertex emit code if there has been a
* statechange to a TNL index. * statechange to a TNL index.
*/ */
if ( index != rmesa->tnl_state ) { if (!RENDERINPUTS_EQUAL( index_bitset, rmesa->tnl_state_bitset )) {
FLUSH_BATCH( rmesa ); FLUSH_BATCH( rmesa );
rmesa->dirty |= R128_UPLOAD_CONTEXT; rmesa->dirty |= R128_UPLOAD_CONTEXT;
@ -763,7 +766,7 @@ void r128InitTriFuncs( GLcontext *ctx )
_tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12, _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
(6 + 2 * ctx->Const.MaxTextureUnits) * sizeof(GLfloat) ); (6 + 2 * ctx->Const.MaxTextureUnits) * sizeof(GLfloat) );
rmesa->verts = (char *)tnl->clipspace.vertex_buf; rmesa->verts = (char *)tnl->clipspace.vertex_buf;
rmesa->tnl_state = -1; RENDERINPUTS_ONES( rmesa->tnl_state_bitset );
rmesa->NewGLState |= _R128_NEW_RENDER_STATE; rmesa->NewGLState |= _R128_NEW_RENDER_STATE;
} }

2
src/mesa/drivers/dri/r200/r200_context.h
View file

@ -897,7 +897,7 @@ struct r200_context {
GLuint TclFallback; GLuint TclFallback;
GLuint Fallback; GLuint Fallback;
GLuint NewGLState; GLuint NewGLState;
GLuint tnl_index; /* index of bits for last tnl_install_attrs */ DECLARE_RENDERINPUTS(tnl_index_bitset); /* index of bits for last tnl_install_attrs */
/* Vertex buffers /* Vertex buffers
*/ */

31
src/mesa/drivers/dri/r200/r200_swtcl.c
View file

@ -85,11 +85,12 @@ static void r200SetVertexFormat( GLcontext *ctx )
r200ContextPtr rmesa = R200_CONTEXT( ctx ); r200ContextPtr rmesa = R200_CONTEXT( ctx );
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
int fmt_0 = 0; int fmt_0 = 0;
int fmt_1 = 0; int fmt_1 = 0;
int offset = 0; int offset = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
/* Important: /* Important:
*/ */
@ -106,7 +107,8 @@ static void r200SetVertexFormat( GLcontext *ctx )
/* EMIT_ATTR's must be in order as they tell t_vertex.c how to /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if ( !rmesa->swtcl.needproj || (index & _TNL_BITS_TEX_ANY)) { /* need w coord for projected textures */ if ( !rmesa->swtcl.needproj ||
RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) { /* need w coord for projected textures */
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0 );
offset = 4; offset = 4;
} }
@ -124,10 +126,11 @@ static void r200SetVertexFormat( GLcontext *ctx )
offset += 1; offset += 1;
rmesa->swtcl.specoffset = 0; rmesa->swtcl.specoffset = 0;
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
#if MESA_LITTLE_ENDIAN #if MESA_LITTLE_ENDIAN
if (index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->swtcl.specoffset = offset; rmesa->swtcl.specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) ); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
} }
@ -135,21 +138,21 @@ static void r200SetVertexFormat( GLcontext *ctx )
EMIT_PAD( 3 ); EMIT_PAD( 3 );
} }
if (index & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
} }
else { else {
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
#else #else
if (index & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
} }
else { else {
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
if (index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->swtcl.specoffset = offset; rmesa->swtcl.specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) ); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
} }
@ -159,11 +162,11 @@ static void r200SetVertexFormat( GLcontext *ctx )
#endif #endif
} }
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
int i; int i;
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
if (index & _TNL_BIT_TEX(i)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
GLuint sz = VB->TexCoordPtr[i]->size; GLuint sz = VB->TexCoordPtr[i]->size;
fmt_1 |= sz << (3 * i); fmt_1 |= sz << (3 * i);
@ -179,7 +182,7 @@ static void r200SetVertexFormat( GLcontext *ctx )
rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_SPEC_ALPHA; rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_SPEC_ALPHA;
} }
if ( rmesa->tnl_index != index || if (!RENDERINPUTS_EQUAL( rmesa->tnl_index_bitset, index_bitset ) ||
(rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0) || (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0) ||
(rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) { (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
R200_NEWPRIM(rmesa); R200_NEWPRIM(rmesa);
@ -193,7 +196,7 @@ static void r200SetVertexFormat( GLcontext *ctx )
rmesa->swtcl.vertex_attr_count, rmesa->swtcl.vertex_attr_count,
NULL, 0 ); NULL, 0 );
rmesa->swtcl.vertex_size /= 4; rmesa->swtcl.vertex_size /= 4;
rmesa->tnl_index = index; RENDERINPUTS_COPY( rmesa->tnl_index_bitset, index_bitset );
} }
} }
@ -235,12 +238,12 @@ void r200ChooseVertexState( GLcontext *ctx )
/* HW perspective divide is a win, but tiny vertex formats are a /* HW perspective divide is a win, but tiny vertex formats are a
* bigger one. * bigger one.
*/ */
if ( ((tnl->render_inputs & _TNL_BITS_TEX_ANY) == 0) if (!RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )
|| (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
rmesa->swtcl.needproj = GL_TRUE; rmesa->swtcl.needproj = GL_TRUE;
vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT; vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT;
vte &= ~R200_VTX_W0_FMT; vte &= ~R200_VTX_W0_FMT;
if (tnl->render_inputs & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
vap &= ~R200_VAP_FORCE_W_TO_ONE; vap &= ~R200_VAP_FORCE_W_TO_ONE;
} }
else { else {
@ -719,7 +722,7 @@ void r200Fallback( GLcontext *ctx, GLuint bit, GLboolean mode )
*/ */
_tnl_invalidate_vertex_state( ctx, ~0 ); _tnl_invalidate_vertex_state( ctx, ~0 );
_tnl_invalidate_vertices( ctx, ~0 ); _tnl_invalidate_vertices( ctx, ~0 );
rmesa->tnl_index = 0; RENDERINPUTS_ZERO( rmesa->tnl_index_bitset );
r200ChooseVertexState( ctx ); r200ChooseVertexState( ctx );
r200ChooseRenderState( ctx ); r200ChooseRenderState( ctx );
} }

2
src/mesa/drivers/dri/r300/r300_context.h
View file

@ -776,7 +776,7 @@ struct r300_state {
GLuint *Elts; GLuint *Elts;
struct r300_dma_region elt_dma; struct r300_dma_region elt_dma;
GLuint render_inputs; /* actual render inputs that R300 was configured for. DECLARE_RENDERINPUTS(render_inputs_bitset); /* actual render inputs that R300 was configured for.
They are the same as tnl->render_inputs for fixed pipeline */ They are the same as tnl->render_inputs for fixed pipeline */
struct { struct {

48
src/mesa/drivers/dri/r300/r300_maos.c
View file

@ -268,7 +268,9 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
GLuint vic_1 = 0; /* R300_VAP_INPUT_CNTL_1 */ GLuint vic_1 = 0; /* R300_VAP_INPUT_CNTL_1 */
GLuint aa_vap_reg = 0; /* VAP register assignment */ GLuint aa_vap_reg = 0; /* VAP register assignment */
GLuint i; GLuint i;
GLuint inputs = 0; DECLARE_RENDERINPUTS(inputs_bitset);
RENDERINPUTS_ZERO( inputs_bitset );
#define CONFIGURE_AOS(r, f, v, sz, cn) { \ #define CONFIGURE_AOS(r, f, v, sz, cn) { \
if (RADEON_DEBUG & DEBUG_STATE) \ if (RADEON_DEBUG & DEBUG_STATE) \
@ -300,23 +302,23 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
GLuint InputsRead = CURRENT_VERTEX_SHADER(ctx)->Base.InputsRead; GLuint InputsRead = CURRENT_VERTEX_SHADER(ctx)->Base.InputsRead;
struct r300_vertex_program *prog=(struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx); struct r300_vertex_program *prog=(struct r300_vertex_program *)CURRENT_VERTEX_SHADER(ctx);
if (InputsRead & (1<<VERT_ATTRIB_POS)) { if (InputsRead & (1<<VERT_ATTRIB_POS)) {
inputs |= _TNL_BIT_POS; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_POS );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_POS]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_POS];
} }
if (InputsRead & (1<<VERT_ATTRIB_NORMAL)) { if (InputsRead & (1<<VERT_ATTRIB_NORMAL)) {
inputs |= _TNL_BIT_NORMAL; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_NORMAL );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_NORMAL]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_NORMAL];
} }
if (InputsRead & (1<<VERT_ATTRIB_COLOR0)) { if (InputsRead & (1<<VERT_ATTRIB_COLOR0)) {
inputs |= _TNL_BIT_COLOR0; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_COLOR0 );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_COLOR0]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_COLOR0];
} }
if (InputsRead & (1<<VERT_ATTRIB_COLOR1)) { if (InputsRead & (1<<VERT_ATTRIB_COLOR1)) {
inputs |= _TNL_BIT_COLOR1; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_COLOR1 );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_COLOR1]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_COLOR1];
} }
if (InputsRead & (1<<VERT_ATTRIB_FOG)) { if (InputsRead & (1<<VERT_ATTRIB_FOG)) {
inputs |= _TNL_BIT_FOG; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_FOG );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_FOG]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_FOG];
} }
if(ctx->Const.MaxTextureUnits > 8) { /* Not sure if this can even happen... */ if(ctx->Const.MaxTextureUnits > 8) { /* Not sure if this can even happen... */
@ -325,17 +327,17 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
} }
for (i=0;i<ctx->Const.MaxTextureUnits;i++) { for (i=0;i<ctx->Const.MaxTextureUnits;i++) {
if (InputsRead & (1<<(VERT_ATTRIB_TEX0+i))) { if (InputsRead & (1<<(VERT_ATTRIB_TEX0+i))) {
inputs |= _TNL_BIT_TEX0<<i; RENDERINPUTS_SET( inputs_bitset, _TNL_ATTRIB_TEX(i) );
rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_TEX0+i]; rmesa->state.aos[nr++].aos_reg = prog->inputs[VERT_ATTRIB_TEX0+i];
} }
} }
nr = 0; nr = 0;
} else { } else {
inputs = TNL_CONTEXT(ctx)->render_inputs; RENDERINPUTS_COPY( inputs_bitset, TNL_CONTEXT(ctx)->render_inputs_bitset );
} }
rmesa->state.render_inputs = inputs; RENDERINPUTS_COPY( rmesa->state.render_inputs_bitset, inputs_bitset );
if (inputs & _TNL_BIT_POS) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_POS )) {
CONFIGURE_AOS(i_coords, AOS_FORMAT_FLOAT, CONFIGURE_AOS(i_coords, AOS_FORMAT_FLOAT,
VB->AttribPtr[VERT_ATTRIB_POS], VB->AttribPtr[VERT_ATTRIB_POS],
immd ? 4 : VB->AttribPtr[VERT_ATTRIB_POS].size, immd ? 4 : VB->AttribPtr[VERT_ATTRIB_POS].size,
@ -344,7 +346,7 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
vic_1 |= R300_INPUT_CNTL_POS; vic_1 |= R300_INPUT_CNTL_POS;
} }
if (inputs & _TNL_BIT_NORMAL) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_NORMAL )) {
CONFIGURE_AOS(i_normal, AOS_FORMAT_FLOAT, CONFIGURE_AOS(i_normal, AOS_FORMAT_FLOAT,
VB->AttribPtr[VERT_ATTRIB_NORMAL], VB->AttribPtr[VERT_ATTRIB_NORMAL],
immd ? 4 : VB->AttribPtr[VERT_ATTRIB_NORMAL].size, immd ? 4 : VB->AttribPtr[VERT_ATTRIB_NORMAL].size,
@ -353,7 +355,7 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
vic_1 |= R300_INPUT_CNTL_NORMAL; vic_1 |= R300_INPUT_CNTL_NORMAL;
} }
if (inputs & _TNL_BIT_COLOR0) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_COLOR0 )) {
int emitsize=4; int emitsize=4;
if (!immd) { if (!immd) {
@ -376,7 +378,7 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
vic_1 |= R300_INPUT_CNTL_COLOR; vic_1 |= R300_INPUT_CNTL_COLOR;
} }
if (inputs & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_COLOR1 )) {
int emitsize=4; int emitsize=4;
if (!immd) { if (!immd) {
@ -398,7 +400,7 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
} }
#if 0 #if 0
if (inputs & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_FOG )) {
CONFIGURE_AOS( AOS_FORMAT_FLOAT, CONFIGURE_AOS( AOS_FORMAT_FLOAT,
VB->FogCoordPtr, VB->FogCoordPtr,
immd ? 4 : VB->FogCoordPtr->size, immd ? 4 : VB->FogCoordPtr->size,
@ -408,7 +410,7 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
r300->state.texture.tc_count = 0; r300->state.texture.tc_count = 0;
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
if (inputs & (_TNL_BIT_TEX0 << i)) { if (RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_TEX(i) )) {
CONFIGURE_AOS(i_tex[i], AOS_FORMAT_FLOAT, CONFIGURE_AOS(i_tex[i], AOS_FORMAT_FLOAT,
VB->AttribPtr[VERT_ATTRIB_TEX0+i], VB->AttribPtr[VERT_ATTRIB_TEX0+i],
immd ? 4 : VB->AttribPtr[VERT_ATTRIB_TEX0+i].size, immd ? 4 : VB->AttribPtr[VERT_ATTRIB_TEX0+i].size,
@ -531,17 +533,17 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
#if 0 #if 0
r300->hw.vic.cmd[R300_VIC_CNTL_1]=0; r300->hw.vic.cmd[R300_VIC_CNTL_1]=0;
if(r300->state.render_inputs & _TNL_BIT_POS) if(RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_POS ))
r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_POS; r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_POS;
if(r300->state.render_inputs & _TNL_BIT_NORMAL) if(RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_NORMAL ))
r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_NORMAL; r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_NORMAL;
if(r300->state.render_inputs & _TNL_BIT_COLOR0) if(RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_COLOR0 ))
r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_COLOR; r300->hw.vic.cmd[R300_VIC_CNTL_1]|=R300_INPUT_CNTL_COLOR;
for(i=0;i < ctx->Const.MaxTextureUnits;i++) for(i=0;i < ctx->Const.MaxTextureUnits;i++)
if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i)) if(RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_TEX(i) ))
r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i); r300->hw.vic.cmd[R300_VIC_CNTL_1]|=(R300_INPUT_CNTL_TC0<<i);
#endif #endif
@ -573,15 +575,15 @@ void r300EmitArrays(GLcontext * ctx, GLboolean immd)
if(OutputsWritten & (1<<(VERT_RESULT_TEX0+i))) if(OutputsWritten & (1<<(VERT_RESULT_TEX0+i)))
r300->hw.vof.cmd[R300_VOF_CNTL_1] |= (4<<(3*i)); r300->hw.vof.cmd[R300_VOF_CNTL_1] |= (4<<(3*i));
} else { } else {
if(inputs & _TNL_BIT_POS) if(RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_POS ))
r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT; r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
if(inputs & _TNL_BIT_COLOR0) if(RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_COLOR0 ))
r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT; r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
if(inputs & _TNL_BIT_COLOR1) if(RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_COLOR1 ))
r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT; r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT;
for(i=0;i < ctx->Const.MaxTextureUnits;i++) for(i=0;i < ctx->Const.MaxTextureUnits;i++)
if(inputs & (_TNL_BIT_TEX0<<i)) if(RENDERINPUTS_TEST( inputs_bitset, _TNL_ATTRIB_TEX(i) ))
r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i)); r300->hw.vof.cmd[R300_VOF_CNTL_1]|=(4<<(3*i));
} }

31
src/mesa/drivers/dri/r300/r300_state.c
View file

@ -1270,6 +1270,19 @@ void r300_setup_textures(GLcontext *ctx)
fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], last_hw_tmu); fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n", r300->hw.txe.cmd[R300_TXE_ENABLE], last_hw_tmu);
} }
union r300_outputs_written {
GLuint vp_outputs; /* hw_tcl_on */
DECLARE_RENDERINPUTS(index_bitset); /* !hw_tcl_on */
};
static GLboolean r300_outputs_written_test (r300_outputs_written *ow, GLuint vp_result,
GLuint tnl_attrib)
{
if (hw_tcl_on)
return ow->vp_outputs & (1 << vp_result);
return RENDERINPUTS_TEST( ow->index_bitset, tnl_attrib );
}
void r300_setup_rs_unit(GLcontext *ctx) void r300_setup_rs_unit(GLcontext *ctx)
{ {
r300ContextPtr r300 = R300_CONTEXT(ctx); r300ContextPtr r300 = R300_CONTEXT(ctx);
@ -1284,16 +1297,16 @@ void r300_setup_rs_unit(GLcontext *ctx)
0x00, 0x00,
0x00 0x00
}; };
GLuint OutputsWritten; union r300_outputs_written OutputsWritten;
GLuint InputsRead; GLuint InputsRead;
int fp_reg, high_rr; int fp_reg, high_rr;
int in_texcoords, col_interp_nr; int in_texcoords, col_interp_nr;
int i; int i;
if(hw_tcl_on) if(hw_tcl_on)
OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->Base.OutputsWritten; OutputsWritten.vp_outputs = CURRENT_VERTEX_SHADER(ctx)->Base.OutputsWritten;
else else
OutputsWritten = r300->state.render_inputs; RENDERINPUTS_COPY( OutputsWritten.index_bitset, r300->state.render_inputs_bitset );
if (ctx->FragmentProgram._Current) if (ctx->FragmentProgram._Current)
InputsRead = ctx->FragmentProgram._Current->Base.InputsRead; InputsRead = ctx->FragmentProgram._Current->Base.InputsRead;
@ -1324,7 +1337,7 @@ void r300_setup_rs_unit(GLcontext *ctx)
| (fp_reg << R300_RS_ROUTE_DEST_SHIFT); | (fp_reg << R300_RS_ROUTE_DEST_SHIFT);
high_rr = fp_reg; high_rr = fp_reg;
if (!(OutputsWritten & (hw_tcl_on ? (1 << (VERT_RESULT_TEX0+i)) : (_TNL_BIT_TEX0<<i)))) { if (!r300_outputs_written_test( &OutputsWritten, VERT_RESULT_TEX0+i, _TNL_ATTRIB_TEX(i) )) {
/* Passing invalid data here can lock the GPU. */ /* Passing invalid data here can lock the GPU. */
WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i); WARN_ONCE("fragprog wants coords for tex%d, vp doesn't provide them!\n", i);
//_mesa_print_program(&CURRENT_VERTEX_SHADER(ctx)->Base); //_mesa_print_program(&CURRENT_VERTEX_SHADER(ctx)->Base);
@ -1334,12 +1347,12 @@ void r300_setup_rs_unit(GLcontext *ctx)
fp_reg++; fp_reg++;
} }
/* Need to count all coords enabled at vof */ /* Need to count all coords enabled at vof */
if (OutputsWritten & (hw_tcl_on ? (1 << (VERT_RESULT_TEX0+i)) : (_TNL_BIT_TEX0<<i))) if (r300_outputs_written_test( &OutputsWritten, VERT_RESULT_TEX0+i, _TNL_ATTRIB_TEX(i) ))
in_texcoords++; in_texcoords++;
} }
if (InputsRead & FRAG_BIT_COL0) { if (InputsRead & FRAG_BIT_COL0) {
if (!(OutputsWritten & (hw_tcl_on ? (1<<VERT_RESULT_COL0) : _TNL_BIT_COLOR0))) { if (!r300_outputs_written_test( &OutputsWritten, VERT_RESULT_COL0, _TNL_ATTRIB_COLOR0 )) {
WARN_ONCE("fragprog wants col0, vp doesn't provide it\n"); WARN_ONCE("fragprog wants col0, vp doesn't provide it\n");
goto out; /* FIXME */ goto out; /* FIXME */
//_mesa_print_program(&CURRENT_VERTEX_SHADER(ctx)->Base); //_mesa_print_program(&CURRENT_VERTEX_SHADER(ctx)->Base);
@ -1355,7 +1368,7 @@ void r300_setup_rs_unit(GLcontext *ctx)
out: out:
if (InputsRead & FRAG_BIT_COL1) { if (InputsRead & FRAG_BIT_COL1) {
if (!(OutputsWritten & (hw_tcl_on ? (1<<VERT_RESULT_COL1) : _TNL_BIT_COLOR1))) { if (!r300_outputs_written_test( &OutputsWritten, VERT_RESULT_COL1, _TNL_ATTRIB_COLOR1 )) {
WARN_ONCE("fragprog wants col1, vp doesn't provide it\n"); WARN_ONCE("fragprog wants col1, vp doesn't provide it\n");
//exit(-1); //exit(-1);
} }
@ -1515,7 +1528,7 @@ static void r300GenerateSimpleVertexShader(r300ContextPtr r300)
) )
o_reg += 2; o_reg += 2;
if (r300->state.render_inputs & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_COLOR1 )) {
WRITE_OP( WRITE_OP(
EASY_VSF_OP(MUL, o_reg++, ALL, RESULT), EASY_VSF_OP(MUL, o_reg++, ALL, RESULT),
VSF_REG(r300->state.vap_reg.i_color[1]), VSF_REG(r300->state.vap_reg.i_color[1]),
@ -1526,7 +1539,7 @@ static void r300GenerateSimpleVertexShader(r300ContextPtr r300)
/* Pass through texture coordinates, if any */ /* Pass through texture coordinates, if any */
for(i=0;i < r300->radeon.glCtx->Const.MaxTextureUnits;i++) for(i=0;i < r300->radeon.glCtx->Const.MaxTextureUnits;i++)
if(r300->state.render_inputs & (_TNL_BIT_TEX0<<i)){ if (RENDERINPUTS_TEST( r300->state.render_inputs_bitset, _TNL_ATTRIB_TEX(i) )){
// fprintf(stderr, "i_tex[%d]=%d\n", i, r300->state.vap_reg.i_tex[i]); // fprintf(stderr, "i_tex[%d]=%d\n", i, r300->state.vap_reg.i_tex[i]);
WRITE_OP( WRITE_OP(
EASY_VSF_OP(MUL, o_reg++ /* 2+i */, ALL, RESULT), EASY_VSF_OP(MUL, o_reg++ /* 2+i */, ALL, RESULT),

2
src/mesa/drivers/dri/radeon/radeon_context.h
View file

@ -735,7 +735,7 @@ struct radeon_context {
GLuint TclFallback; GLuint TclFallback;
GLuint Fallback; GLuint Fallback;
GLuint NewGLState; GLuint NewGLState;
GLuint tnl_index; /* index of bits for last tnl_install_attrs */ DECLARE_RENDERINPUTS(tnl_index_bitset); /* index of bits for last tnl_install_attrs */
/* Vertex buffers /* Vertex buffers
*/ */

29
src/mesa/drivers/dri/radeon/radeon_swtcl.c
View file

@ -92,10 +92,11 @@ static void radeonSetVertexFormat( GLcontext *ctx )
radeonContextPtr rmesa = RADEON_CONTEXT( ctx ); radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
int fmt_0 = 0; int fmt_0 = 0;
int offset = 0; int offset = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
/* Important: /* Important:
*/ */
@ -113,7 +114,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if ( !rmesa->swtcl.needproj || if ( !rmesa->swtcl.needproj ||
(index & _TNL_BITS_TEX_ANY)) { /* for projtex */ RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) { /* for projtex */
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F,
RADEON_CP_VC_FRMT_XY | RADEON_CP_VC_FRMT_Z | RADEON_CP_VC_FRMT_W0 ); RADEON_CP_VC_FRMT_XY | RADEON_CP_VC_FRMT_Z | RADEON_CP_VC_FRMT_W0 );
offset = 4; offset = 4;
@ -135,10 +136,11 @@ static void radeonSetVertexFormat( GLcontext *ctx )
offset += 1; offset += 1;
rmesa->swtcl.specoffset = 0; rmesa->swtcl.specoffset = 0;
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
#if MESA_LITTLE_ENDIAN #if MESA_LITTLE_ENDIAN
if (index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->swtcl.specoffset = offset; rmesa->swtcl.specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB,
RADEON_CP_VC_FRMT_PKSPEC ); RADEON_CP_VC_FRMT_PKSPEC );
@ -147,7 +149,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
EMIT_PAD( 3 ); EMIT_PAD( 3 );
} }
if (index & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F,
RADEON_CP_VC_FRMT_PKSPEC ); RADEON_CP_VC_FRMT_PKSPEC );
} }
@ -155,7 +157,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
#else #else
if (index & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F,
RADEON_CP_VC_FRMT_PKSPEC ); RADEON_CP_VC_FRMT_PKSPEC );
} }
@ -163,7 +165,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
if (index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
rmesa->swtcl.specoffset = offset; rmesa->swtcl.specoffset = offset;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR,
RADEON_CP_VC_FRMT_PKSPEC ); RADEON_CP_VC_FRMT_PKSPEC );
@ -174,11 +176,11 @@ static void radeonSetVertexFormat( GLcontext *ctx )
#endif #endif
} }
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
int i; int i;
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) { for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
if (index & _TNL_BIT_TEX(i)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
GLuint sz = VB->TexCoordPtr[i]->size; GLuint sz = VB->TexCoordPtr[i]->size;
switch (sz) { switch (sz) {
@ -204,7 +206,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
} }
} }
if ( rmesa->tnl_index != index || if (!RENDERINPUTS_EQUAL( rmesa->tnl_index_bitset, index_bitset ) ||
fmt_0 != rmesa->swtcl.vertex_format) { fmt_0 != rmesa->swtcl.vertex_format) {
RADEON_NEWPRIM(rmesa); RADEON_NEWPRIM(rmesa);
rmesa->swtcl.vertex_format = fmt_0; rmesa->swtcl.vertex_format = fmt_0;
@ -214,7 +216,7 @@ static void radeonSetVertexFormat( GLcontext *ctx )
rmesa->swtcl.vertex_attr_count, rmesa->swtcl.vertex_attr_count,
NULL, 0 ); NULL, 0 );
rmesa->swtcl.vertex_size /= 4; rmesa->swtcl.vertex_size /= 4;
rmesa->tnl_index = index; RENDERINPUTS_COPY( rmesa->tnl_index_bitset, index_bitset );
if (RADEON_DEBUG & DEBUG_VERTS) if (RADEON_DEBUG & DEBUG_VERTS)
fprintf( stderr, "%s: vertex_size= %d floats\n", fprintf( stderr, "%s: vertex_size= %d floats\n",
__FUNCTION__, rmesa->swtcl.vertex_size); __FUNCTION__, rmesa->swtcl.vertex_size);
@ -257,7 +259,8 @@ void radeonChooseVertexState( GLcontext *ctx )
* bigger one. * bigger one.
*/ */
if ( ((tnl->render_inputs & (_TNL_BITS_TEX_ANY|_TNL_BIT_COLOR1) ) == 0) if ((!RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ) &&
!RENDERINPUTS_TEST( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR1 ))
|| (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) { || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
rmesa->swtcl.needproj = GL_TRUE; rmesa->swtcl.needproj = GL_TRUE;
se_coord_fmt = (RADEON_VTX_XY_PRE_MULT_1_OVER_W0 | se_coord_fmt = (RADEON_VTX_XY_PRE_MULT_1_OVER_W0 |
@ -938,7 +941,7 @@ void radeonFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
*/ */
_tnl_invalidate_vertex_state( ctx, ~0 ); _tnl_invalidate_vertex_state( ctx, ~0 );
_tnl_invalidate_vertices( ctx, ~0 ); _tnl_invalidate_vertices( ctx, ~0 );
rmesa->tnl_index = 0; RENDERINPUTS_ZERO( rmesa->tnl_index_bitset );
radeonChooseVertexState( ctx ); radeonChooseVertexState( ctx );
radeonChooseRenderState( ctx ); radeonChooseRenderState( ctx );
} }

36
src/mesa/drivers/dri/savage/savagetris.c
View file

@ -867,15 +867,17 @@ static GLboolean savageCheckPTexHack( GLcontext *ctx )
{ {
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
if (index & _TNL_BIT_TEX(0) && VB->TexCoordPtr[0]->size == 4) { RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
if ((index & _TNL_BITS_TEX_ANY) == _TNL_BIT_TEX(0))
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 */ return GL_TRUE; /* apply ptex hack */
else else
FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE); FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE);
} }
if ((index & _TNL_BIT_TEX(1)) && VB->TexCoordPtr[1]->size == 4) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 ) && VB->TexCoordPtr[1]->size == 4)
FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE); FALLBACK(ctx, SAVAGE_FALLBACK_PROJ_TEXTURE, GL_TRUE);
return GL_FALSE; /* don't apply ptex hack */ return GL_FALSE; /* don't apply ptex hack */
@ -929,10 +931,11 @@ static __inline__ GLuint savageChooseVertexFormat_s3d( GLcontext *ctx )
savageContextPtr imesa = SAVAGE_CONTEXT(ctx); savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint setupIndex = SAVAGE_EMIT_XYZ; GLuint setupIndex = SAVAGE_EMIT_XYZ;
GLubyte skip; GLubyte skip;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
imesa->vertex_attr_count = 0; imesa->vertex_attr_count = 0;
skip = SAVAGE_SKIP_ALL_S3D; skip = SAVAGE_SKIP_ALL_S3D;
@ -941,7 +944,7 @@ static __inline__ GLuint savageChooseVertexFormat_s3d( GLcontext *ctx )
/* EMIT_ATTR's must be in order as they tell t_vertex.c how to /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if ((index & _TNL_BITS_TEX_ANY) || !(ctx->_TriangleCaps & DD_FLATSHADE)) 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 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, SAVAGE_EMIT_W, SAVAGE_SKIP_W );
else { else {
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 0 ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 0 );
@ -952,17 +955,17 @@ static __inline__ GLuint savageChooseVertexFormat_s3d( GLcontext *ctx )
/* t_context.c always includes a diffuse color */ /* t_context.c always includes a diffuse color */
EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 ); EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 );
if ((index & _TNL_BIT_COLOR1)) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ))
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 ); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 );
else else
EMIT_PAD( 3 ); EMIT_PAD( 3 );
if ((index & _TNL_BIT_FOG)) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
skip &= ~SAVAGE_SKIP_C1; skip &= ~SAVAGE_SKIP_C1;
if (index & _TNL_BIT_TEX(0)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
if (imesa->ptexHack) if (imesa->ptexHack)
EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW, SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0); EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW, SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0);
else if (VB->TexCoordPtr[0]->size == 4) else if (VB->TexCoordPtr[0]->size == 4)
@ -991,28 +994,27 @@ static __inline__ GLuint savageChooseVertexFormat_s4( GLcontext *ctx )
savageContextPtr imesa = SAVAGE_CONTEXT(ctx); savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint setupIndex = SAVAGE_EMIT_XYZ; GLuint setupIndex = SAVAGE_EMIT_XYZ;
GLubyte skip; GLubyte skip;
GLuint size, mask; GLuint size, mask;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
skip = SAVAGE_SKIP_ALL_S4; skip = SAVAGE_SKIP_ALL_S4;
skip &= ~SAVAGE_SKIP_Z; /* all mesa vertices have a z coordinate */ skip &= ~SAVAGE_SKIP_Z; /* all mesa vertices have a z coordinate */
if ((index & _TNL_BITS_TEX_ANY) || !(ctx->_TriangleCaps & DD_FLATSHADE)) if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ) || !(ctx->_TriangleCaps & DD_FLATSHADE))
NEED_ATTR( SAVAGE_EMIT_W, SAVAGE_SKIP_W ); NEED_ATTR( SAVAGE_EMIT_W, SAVAGE_SKIP_W );
/* t_context.c always includes a diffuse color */ /* t_context.c always includes a diffuse color */
NEED_ATTR( SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 ); NEED_ATTR( SAVAGE_EMIT_C0, SAVAGE_SKIP_C0 );
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ))
if ((index & _TNL_BIT_COLOR1))
NEED_ATTR( SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 ); NEED_ATTR( SAVAGE_EMIT_C1, SAVAGE_SKIP_C1 );
if ((index & _TNL_BIT_FOG)) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
NEED_ATTR( SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 ); NEED_ATTR( SAVAGE_EMIT_FOG, SAVAGE_SKIP_C1 );
}
if (index & _TNL_BIT_TEX(0)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
if (imesa->ptexHack) if (imesa->ptexHack)
NEED_ATTR( SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0); NEED_ATTR( SAVAGE_EMIT_STQ0, SAVAGE_SKIP_ST0);
else if (VB->TexCoordPtr[0]->size == 4) else if (VB->TexCoordPtr[0]->size == 4)
@ -1024,7 +1026,7 @@ static __inline__ GLuint savageChooseVertexFormat_s4( GLcontext *ctx )
else else
NEED_ATTR( SAVAGE_EMIT_S0, SAVAGE_SKIP_S0 ); NEED_ATTR( SAVAGE_EMIT_S0, SAVAGE_SKIP_S0 );
} }
if (index & _TNL_BIT_TEX(1)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
if (VB->TexCoordPtr[1]->size == 4) if (VB->TexCoordPtr[1]->size == 4)
/* projective textures are not supported by the hardware */ /* projective textures are not supported by the hardware */
assert (0); /* should be caught by savageCheckPTexHack */ assert (0); /* should be caught by savageCheckPTexHack */

2
src/mesa/drivers/dri/sis/sis_context.h
View file

@ -332,7 +332,7 @@ struct sis_context
GLint drawableID; GLint drawableID;
GLint GlobalFlag; GLint GlobalFlag;
GLuint last_tcl_state; DECLARE_RENDERINPUTS(last_tcl_state_bitset);
/* Stereo */ /* Stereo */
GLboolean useStereo; GLboolean useStereo;

19
src/mesa/drivers/dri/sis/sis_tris.c
View file

@ -842,10 +842,12 @@ static void sisRenderStart( GLcontext *ctx )
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
sisContextPtr smesa = SIS_CONTEXT(ctx); sisContextPtr smesa = SIS_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint AGPParseSet = smesa->AGPParseSet; GLuint AGPParseSet = smesa->AGPParseSet;
GLboolean tex_fallback = GL_FALSE; GLboolean tex_fallback = GL_FALSE;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
if (ctx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_FRONT_LEFT && if (ctx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_FRONT_LEFT &&
smesa->driDrawable->numClipRects != 0) smesa->driDrawable->numClipRects != 0)
{ {
@ -869,7 +871,7 @@ static void sisRenderStart( GLcontext *ctx )
AGPParseSet &= ~(MASK_VertexDWSize | MASK_VertexDataFormat); AGPParseSet &= ~(MASK_VertexDWSize | MASK_VertexDataFormat);
AGPParseSet |= SiS_PS_HAS_XYZ | SiS_PS_HAS_DIFFUSE; AGPParseSet |= SiS_PS_HAS_XYZ | SiS_PS_HAS_DIFFUSE;
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_4F_VIEWPORT); EMIT_ATTR(_TNL_ATTRIB_POS, EMIT_4F_VIEWPORT);
AGPParseSet |= SiS_PS_HAS_W; AGPParseSet |= SiS_PS_HAS_W;
smesa->coloroffset = 4; smesa->coloroffset = 4;
@ -881,17 +883,18 @@ static void sisRenderStart( GLcontext *ctx )
EMIT_ATTR(_TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA); EMIT_ATTR(_TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA);
smesa->specoffset = 0; smesa->specoffset = 0;
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
AGPParseSet |= SiS_PS_HAS_SPECULAR; AGPParseSet |= SiS_PS_HAS_SPECULAR;
if (index & _TNL_BIT_COLOR1) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
EMIT_ATTR(_TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR); EMIT_ATTR(_TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR);
smesa->specoffset = smesa->coloroffset + 1; smesa->specoffset = smesa->coloroffset + 1;
} else { } else {
EMIT_PAD(3); EMIT_PAD(3);
} }
if (index & _TNL_BIT_FOG) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR(_TNL_ATTRIB_FOG, EMIT_1UB_1F); EMIT_ATTR(_TNL_ATTRIB_FOG, EMIT_1UB_1F);
} else { } else {
EMIT_PAD(1); EMIT_PAD(1);
@ -899,14 +902,14 @@ static void sisRenderStart( GLcontext *ctx )
} }
/* projective textures are not supported by the hardware */ /* projective textures are not supported by the hardware */
if (index & _TNL_BIT_TEX(0)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
if (VB->TexCoordPtr[0]->size > 2) if (VB->TexCoordPtr[0]->size > 2)
tex_fallback = GL_TRUE; tex_fallback = GL_TRUE;
EMIT_ATTR(_TNL_ATTRIB_TEX0, EMIT_2F); EMIT_ATTR(_TNL_ATTRIB_TEX0, EMIT_2F);
AGPParseSet |= SiS_PS_HAS_UV0; AGPParseSet |= SiS_PS_HAS_UV0;
} }
/* Will only hit tex1 on SiS300 */ /* Will only hit tex1 on SiS300 */
if (index & _TNL_BIT_TEX(1)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
if (VB->TexCoordPtr[1]->size > 2) if (VB->TexCoordPtr[1]->size > 2)
tex_fallback = GL_TRUE; tex_fallback = GL_TRUE;
EMIT_ATTR(_TNL_ATTRIB_TEX1, EMIT_2F); EMIT_ATTR(_TNL_ATTRIB_TEX1, EMIT_2F);
@ -914,7 +917,7 @@ static void sisRenderStart( GLcontext *ctx )
} }
FALLBACK(smesa, SIS_FALLBACK_TEXTURE, tex_fallback); FALLBACK(smesa, SIS_FALLBACK_TEXTURE, tex_fallback);
if (smesa->last_tcl_state != index) { if (!RENDERINPUTS_EQUAL( smesa->last_tcl_state_bitset, index_bitset )) {
smesa->AGPParseSet = AGPParseSet; smesa->AGPParseSet = AGPParseSet;
smesa->vertex_size = _tnl_install_attrs( ctx, smesa->vertex_attrs, smesa->vertex_size = _tnl_install_attrs( ctx, smesa->vertex_attrs,

27
src/mesa/drivers/dri/unichrome/via_tris.c
View file

@ -744,16 +744,18 @@ static void viaChooseVertexState( GLcontext *ctx )
{ {
struct via_context *vmesa = VIA_CONTEXT(ctx); struct via_context *vmesa = VIA_CONTEXT(ctx);
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLuint regCmdB = HC_HVPMSK_X | HC_HVPMSK_Y | HC_HVPMSK_Z; GLuint regCmdB = HC_HVPMSK_X | HC_HVPMSK_Y | HC_HVPMSK_Z;
GLuint setupIndex = 0; GLuint setupIndex = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
vmesa->vertex_attr_count = 0; vmesa->vertex_attr_count = 0;
/* EMIT_ATTR's must be in order as they tell t_vertex.c how to /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
* build up a hardware vertex. * build up a hardware vertex.
*/ */
if (index & (_TNL_BITS_TEX_ANY|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ) ||
RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, VIA_EMIT_W, HC_HVPMSK_W ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, VIA_EMIT_W, HC_HVPMSK_W );
vmesa->coloroffset = 4; vmesa->coloroffset = 4;
} }
@ -767,8 +769,9 @@ static void viaChooseVertexState( GLcontext *ctx )
HC_HVPMSK_Cd ); HC_HVPMSK_Cd );
vmesa->specoffset = 0; vmesa->specoffset = 0;
if (index & (_TNL_BIT_COLOR1|_TNL_BIT_FOG)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
if ((index & _TNL_BIT_COLOR1)) { RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
vmesa->specoffset = vmesa->coloroffset + 1; vmesa->specoffset = vmesa->coloroffset + 1;
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, VIA_EMIT_SPEC, EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, VIA_EMIT_SPEC,
HC_HVPMSK_Cs ); HC_HVPMSK_Cs );
@ -776,13 +779,13 @@ static void viaChooseVertexState( GLcontext *ctx )
else else
EMIT_PAD( 3 ); EMIT_PAD( 3 );
if ((index & _TNL_BIT_FOG)) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, VIA_EMIT_FOG, HC_HVPMSK_Cs ); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, VIA_EMIT_FOG, HC_HVPMSK_Cs );
else else
EMIT_PAD( 1 ); EMIT_PAD( 1 );
} }
if (index & _TNL_BIT_TEX(0)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX0 )) {
if (vmesa->ptexHack) if (vmesa->ptexHack)
EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW, VIA_EMIT_PTEX0, EMIT_ATTR( _TNL_ATTRIB_TEX0, EMIT_3F_XYW, VIA_EMIT_PTEX0,
(HC_HVPMSK_S | HC_HVPMSK_T) ); (HC_HVPMSK_S | HC_HVPMSK_T) );
@ -791,7 +794,7 @@ static void viaChooseVertexState( GLcontext *ctx )
(HC_HVPMSK_S | HC_HVPMSK_T) ); (HC_HVPMSK_S | HC_HVPMSK_T) );
} }
if (index & _TNL_BIT_TEX(1)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 )) {
EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F, VIA_EMIT_TEX1, EMIT_ATTR( _TNL_ATTRIB_TEX1, EMIT_2F, VIA_EMIT_TEX1,
(HC_HVPMSK_S | HC_HVPMSK_T) ); (HC_HVPMSK_S | HC_HVPMSK_T) );
} }
@ -824,17 +827,19 @@ static GLboolean viaCheckPTexHack( GLcontext *ctx )
{ {
TNLcontext *tnl = TNL_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb; struct vertex_buffer *VB = &tnl->vb;
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
GLboolean fallback = GL_FALSE; GLboolean fallback = GL_FALSE;
GLboolean ptexHack = GL_FALSE; GLboolean ptexHack = GL_FALSE;
if (index & _TNL_BIT_TEX(0) && VB->TexCoordPtr[0]->size == 4) { RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
if ((index & _TNL_BITS_TEX_ANY) == _TNL_BIT_TEX(0))
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 ))
ptexHack = GL_TRUE; ptexHack = GL_TRUE;
else else
fallback = GL_TRUE; fallback = GL_TRUE;
} }
if ((index & _TNL_BIT_TEX(1)) && VB->TexCoordPtr[1]->size == 4) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX1 ) && VB->TexCoordPtr[1]->size == 4)
fallback = GL_TRUE; fallback = GL_TRUE;
FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_PROJ_TEXTURE, fallback); FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_PROJ_TEXTURE, fallback);

53
src/mesa/main/api_noop.c
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -391,7 +391,7 @@ void GLAPIENTRY _mesa_noop_TexCoord4fv( const GLfloat *v )
void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x ) void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1); ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1);
} }
else else
@ -401,7 +401,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x )
void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1); ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1);
} }
else else
@ -411,7 +411,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1); ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1);
} }
else else
@ -421,7 +421,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y
void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1); ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1);
} }
else else
@ -432,7 +432,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x,
GLfloat y, GLfloat z ) GLfloat y, GLfloat z )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1); ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1);
} }
else else
@ -442,7 +442,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x,
void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1); ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1);
} }
else else
@ -453,7 +453,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
GLfloat y, GLfloat z, GLfloat w ) GLfloat y, GLfloat z, GLfloat w )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w); ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w);
} }
else else
@ -463,7 +463,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_PROGRAM_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]); ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]);
} }
else else
@ -471,15 +471,12 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
} }
/*
* XXX Un-alias attribs here
*/
void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x ) void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, 0, 0, 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fARB" );
@ -488,8 +485,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], 0, 0, 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fvARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fvARB" );
@ -498,8 +495,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, 0, 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fARB" );
@ -508,8 +505,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y
void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], 0, 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fvARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fvARB" );
@ -519,8 +516,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
GLfloat y, GLfloat z ) GLfloat y, GLfloat z )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fARB" );
@ -529,8 +526,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], 1);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fvARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fvARB" );
@ -540,8 +537,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
GLfloat y, GLfloat z, GLfloat w ) GLfloat y, GLfloat z, GLfloat w )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, w);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fARB" );
@ -550,8 +547,8 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v ) void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v )
{ {
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
if (index < VERT_ATTRIB_MAX) { if (index < MAX_VERTEX_ATTRIBS) {
ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]); ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], v[3]);
} }
else else
_mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fvARB" ); _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fvARB" );

50
src/mesa/main/bitset.h
View file

@ -28,6 +28,10 @@
* \author Michal Krol * \author Michal Krol
*/ */
/****************************************************************************
* generic bitset implementation
*/
#define BITSET_WORD GLuint #define BITSET_WORD GLuint
#define BITSET_WORDBITS (sizeof (BITSET_WORD) * 8) #define BITSET_WORDBITS (sizeof (BITSET_WORD) * 8)
@ -70,3 +74,49 @@
((x)[BITSET_BITWORD(b)] &= ~BITSET_RANGE(b, e)) : \ ((x)[BITSET_BITWORD(b)] &= ~BITSET_RANGE(b, e)) : \
(assert (!"BITSET_CLEAR_RANGE: bit range crosses word boundary"), 0)) (assert (!"BITSET_CLEAR_RANGE: bit range crosses word boundary"), 0))
/****************************************************************************
* 64-bit bitset implementation
*/
#define BITSET64_WORD GLuint
#define BITSET64_WORDBITS (sizeof (BITSET64_WORD) * 8)
/* bitset declarations
*/
#define BITSET64_DECLARE(name, size) \
GLuint name[2]
/* bitset operations
*/
#define BITSET64_COPY(x, y) do { (x)[0] = (y)[0]; (x)[1] = (y)[1]; } while (0)
#define BITSET64_EQUAL(x, y) ( (x)[0] == (y)[0] && (x)[1] == (y)[1] )
#define BITSET64_ZERO(x) do { (x)[0] = 0; (x)[1] = 0; } while (0)
#define BITSET64_ONES(x) do { (x)[0] = 0xFF; (x)[1] = 0xFF; } while (0)
#define BITSET64_BITWORD(b) ((b) / BITSET64_WORDBITS)
#define BITSET64_BIT(b) (1 << ((b) % BITSET64_WORDBITS))
/* single bit operations
*/
#define BITSET64_TEST(x, b) ((x)[BITSET64_BITWORD(b)] & BITSET64_BIT(b))
#define BITSET64_SET(x, b) ((x)[BITSET64_BITWORD(b)] |= BITSET64_BIT(b))
#define BITSET64_CLEAR(x, b) ((x)[BITSET64_BITWORD(b)] &= ~BITSET64_BIT(b))
#define BITSET64_MASK(b) ((b) == BITSET64_WORDBITS ? ~0 : BITSET64_BIT(b) - 1)
#define BITSET64_RANGE(b, e) (BITSET64_MASK((e) + 1) & ~BITSET64_MASK(b))
/* bit range operations
*/
#define BITSET64_TEST_RANGE(x, b, e) \
(BITSET64_BITWORD(b) == BITSET64_BITWORD(e) ? \
((x)[BITSET64_BITWORD(b)] & BITSET64_RANGE(b, e)) : \
(assert (!"BITSET64_TEST_RANGE: bit range crosses word boundary"), 0))
#define BITSET64_SET_RANGE(x, b, e) \
(BITSET64_BITWORD(b) == BITSET64_BITWORD(e) ? \
((x)[BITSET64_BITWORD(b)] |= BITSET64_RANGE(b, e)) : \
(assert (!"BITSET64_SET_RANGE: bit range crosses word boundary"), 0))
#define BITSET64_CLEAR_RANGE(x, b, e) \
(BITSET64_BITWORD(b) == BITSET64_BITWORD(e) ? \
((x)[BITSET64_BITWORD(b)] &= ~BITSET64_RANGE(b, e)) : \
(assert (!"BITSET64_CLEAR_RANGE: bit range crosses word boundary"), 0))

48
src/mesa/main/dlist.c
View file

@ -4777,7 +4777,7 @@ save_Attr1fNV(GLenum attr, GLfloat x)
n[2].f = x; n[2].f = x;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 1; ctx->ListState.ActiveAttribSize[attr] = 1;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
@ -4799,7 +4799,7 @@ save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
n[3].f = y; n[3].f = y;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 2; ctx->ListState.ActiveAttribSize[attr] = 2;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
@ -4822,7 +4822,7 @@ save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
n[4].f = z; n[4].f = z;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 3; ctx->ListState.ActiveAttribSize[attr] = 3;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
@ -4846,7 +4846,7 @@ save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
n[5].f = w; n[5].f = w;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 4; ctx->ListState.ActiveAttribSize[attr] = 4;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
@ -4868,7 +4868,7 @@ save_Attr1fARB(GLenum attr, GLfloat x)
n[2].f = x; n[2].f = x;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 1; ctx->ListState.ActiveAttribSize[attr] = 1;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
@ -4890,7 +4890,7 @@ save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
n[3].f = y; n[3].f = y;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 2; ctx->ListState.ActiveAttribSize[attr] = 2;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
@ -4913,7 +4913,7 @@ save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
n[4].f = z; n[4].f = z;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 3; ctx->ListState.ActiveAttribSize[attr] = 3;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
@ -4937,7 +4937,7 @@ save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
n[5].f = w; n[5].f = w;
} }
ASSERT(attr < VERT_ATTRIB_MAX); ASSERT(attr < MAX_VERTEX_ATTRIBS);
ctx->ListState.ActiveAttribSize[attr] = 4; ctx->ListState.ActiveAttribSize[attr] = 4;
ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w); ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
@ -5432,7 +5432,7 @@ index_error(void)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib1fNV(GLuint index, GLfloat x) save_VertexAttrib1fNV(GLuint index, GLfloat x)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr1fNV(index, x); save_Attr1fNV(index, x);
else else
index_error(); index_error();
@ -5441,7 +5441,7 @@ save_VertexAttrib1fNV(GLuint index, GLfloat x)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib1fvNV(GLuint index, const GLfloat * v) save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr1fNV(index, v[0]); save_Attr1fNV(index, v[0]);
else else
index_error(); index_error();
@ -5450,7 +5450,7 @@ save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr2fNV(index, x, y); save_Attr2fNV(index, x, y);
else else
index_error(); index_error();
@ -5459,7 +5459,7 @@ save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib2fvNV(GLuint index, const GLfloat * v) save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr2fNV(index, v[0], v[1]); save_Attr2fNV(index, v[0], v[1]);
else else
index_error(); index_error();
@ -5468,7 +5468,7 @@ save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr3fNV(index, x, y, z); save_Attr3fNV(index, x, y, z);
else else
index_error(); index_error();
@ -5477,7 +5477,7 @@ save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib3fvNV(GLuint index, const GLfloat * v) save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr3fNV(index, v[0], v[1], v[2]); save_Attr3fNV(index, v[0], v[1], v[2]);
else else
index_error(); index_error();
@ -5487,7 +5487,7 @@ static void GLAPIENTRY
save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
GLfloat z, GLfloat w) GLfloat z, GLfloat w)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr4fNV(index, x, y, z, w); save_Attr4fNV(index, x, y, z, w);
else else
index_error(); index_error();
@ -5496,7 +5496,7 @@ save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib4fvNV(GLuint index, const GLfloat * v) save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
save_Attr4fNV(index, v[0], v[1], v[2], v[3]); save_Attr4fNV(index, v[0], v[1], v[2], v[3]);
else else
index_error(); index_error();
@ -5508,7 +5508,7 @@ save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib1fARB(GLuint index, GLfloat x) save_VertexAttrib1fARB(GLuint index, GLfloat x)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr1fARB(index, x); save_Attr1fARB(index, x);
else else
index_error(); index_error();
@ -5517,7 +5517,7 @@ save_VertexAttrib1fARB(GLuint index, GLfloat x)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib1fvARB(GLuint index, const GLfloat * v) save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr1fARB(index, v[0]); save_Attr1fARB(index, v[0]);
else else
index_error(); index_error();
@ -5526,7 +5526,7 @@ save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr2fARB(index, x, y); save_Attr2fARB(index, x, y);
else else
index_error(); index_error();
@ -5535,7 +5535,7 @@ save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib2fvARB(GLuint index, const GLfloat * v) save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr2fARB(index, v[0], v[1]); save_Attr2fARB(index, v[0], v[1]);
else else
index_error(); index_error();
@ -5544,7 +5544,7 @@ save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr3fARB(index, x, y, z); save_Attr3fARB(index, x, y, z);
else else
index_error(); index_error();
@ -5553,7 +5553,7 @@ save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib3fvARB(GLuint index, const GLfloat * v) save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr3fARB(index, v[0], v[1], v[2]); save_Attr3fARB(index, v[0], v[1], v[2]);
else else
index_error(); index_error();
@ -5563,7 +5563,7 @@ static void GLAPIENTRY
save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
GLfloat w) GLfloat w)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr4fARB(index, x, y, z, w); save_Attr4fARB(index, x, y, z, w);
else else
index_error(); index_error();
@ -5572,7 +5572,7 @@ save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
static void GLAPIENTRY static void GLAPIENTRY
save_VertexAttrib4fvARB(GLuint index, const GLfloat * v) save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
save_Attr4fARB(index, v[0], v[1], v[2], v[3]); save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
else else
index_error(); index_error();

44
src/mesa/main/mtypes.h
View file

@ -41,6 +41,7 @@
#include "glapitable.h" #include "glapitable.h"
#include "glthread.h" #include "glthread.h"
#include "math/m_matrix.h" /* GLmatrix */ #include "math/m_matrix.h" /* GLmatrix */
#include "bitset.h"
/** /**
@ -155,7 +156,19 @@ enum
VERT_ATTRIB_GENERIC1 = 17, VERT_ATTRIB_GENERIC1 = 17,
VERT_ATTRIB_GENERIC2 = 18, VERT_ATTRIB_GENERIC2 = 18,
VERT_ATTRIB_GENERIC3 = 19, VERT_ATTRIB_GENERIC3 = 19,
VERT_ATTRIB_MAX = 16 /* XXX not counting generic attribs yet */ VERT_ATTRIB_GENERIC4 = 20,
VERT_ATTRIB_GENERIC5 = 21,
VERT_ATTRIB_GENERIC6 = 22,
VERT_ATTRIB_GENERIC7 = 23,
VERT_ATTRIB_GENERIC8 = 24,
VERT_ATTRIB_GENERIC9 = 25,
VERT_ATTRIB_GENERIC10 = 26,
VERT_ATTRIB_GENERIC11 = 27,
VERT_ATTRIB_GENERIC12 = 28,
VERT_ATTRIB_GENERIC13 = 29,
VERT_ATTRIB_GENERIC14 = 30,
VERT_ATTRIB_GENERIC15 = 31,
VERT_ATTRIB_MAX = 32
}; };
/** /**
@ -183,11 +196,40 @@ enum
#define VERT_BIT_GENERIC1 (1 << VERT_ATTRIB_GENERIC1) #define VERT_BIT_GENERIC1 (1 << VERT_ATTRIB_GENERIC1)
#define VERT_BIT_GENERIC2 (1 << VERT_ATTRIB_GENERIC2) #define VERT_BIT_GENERIC2 (1 << VERT_ATTRIB_GENERIC2)
#define VERT_BIT_GENERIC3 (1 << VERT_ATTRIB_GENERIC3) #define VERT_BIT_GENERIC3 (1 << VERT_ATTRIB_GENERIC3)
#define VERT_BIT_GENERIC4 (1 << VERT_ATTRIB_GENERIC4)
#define VERT_BIT_GENERIC5 (1 << VERT_ATTRIB_GENERIC5)
#define VERT_BIT_GENERIC6 (1 << VERT_ATTRIB_GENERIC6)
#define VERT_BIT_GENERIC7 (1 << VERT_ATTRIB_GENERIC7)
#define VERT_BIT_GENERIC8 (1 << VERT_ATTRIB_GENERIC8)
#define VERT_BIT_GENERIC9 (1 << VERT_ATTRIB_GENERIC9)
#define VERT_BIT_GENERIC10 (1 << VERT_ATTRIB_GENERIC10)
#define VERT_BIT_GENERIC11 (1 << VERT_ATTRIB_GENERIC11)
#define VERT_BIT_GENERIC12 (1 << VERT_ATTRIB_GENERIC12)
#define VERT_BIT_GENERIC13 (1 << VERT_ATTRIB_GENERIC13)
#define VERT_BIT_GENERIC14 (1 << VERT_ATTRIB_GENERIC14)
#define VERT_BIT_GENERIC15 (1 << VERT_ATTRIB_GENERIC15)
#define VERT_BIT_TEX(u) (1 << (VERT_ATTRIB_TEX0 + (u))) #define VERT_BIT_TEX(u) (1 << (VERT_ATTRIB_TEX0 + (u)))
#define VERT_BIT_GENERIC(g) (1 << (VERT_ATTRIB_GENERIC0 + (g))) #define VERT_BIT_GENERIC(g) (1 << (VERT_ATTRIB_GENERIC0 + (g)))
/*@}*/ /*@}*/
/**
* GLSL allows shader writers to allocate vertex result attributes (varyings) in
* single float component granularity. This is in contrast to vertex / fragment
* programs, where result attributes (actually texcoords) were allocated
* in 4-component vectors of floats granularity.
* For performance reasons, it would be optimal to stick with this scheme on a scalar
* processor. Varyings will likely be allocated as 3-component vectors, so statistically
* we win 2 floats.
* The constant VARYINGS_PER_VECTOR tells us how much of float components we pack into
* one result vector. For scalar processor it would be 1, for vector processor - 4.
*
* NOTE: Currently we pack varyings into vertex attributes.
*/
#define VARYINGS_PER_VECTOR 2
#define VARYING_EMIT_STYLE EMIT_2F
#define MAX_VARYING_VECTORS ((MAX_VARYING_FLOATS + VARYINGS_PER_VECTOR - 1) / VARYINGS_PER_VECTOR)
/** /**
* Indexes for vertex program result attributes * Indexes for vertex program result attributes
*/ */

17
src/mesa/main/state.c
View file

@ -820,7 +820,11 @@ update_arrays( GLcontext *ctx )
/* find min of _MaxElement values for all enabled arrays */ /* find min of _MaxElement values for all enabled arrays */
/* 0 */ /* 0 */
if (ctx->VertexProgram._Enabled if (ctx->ShaderObjects._VertexShaderPresent
&& ctx->Array.VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled) {
min = ctx->Array.VertexAttrib[VERT_ATTRIB_GENERIC0]._MaxElement;
}
else if (ctx->VertexProgram._Enabled
&& ctx->Array.VertexAttrib[VERT_ATTRIB_POS].Enabled) { && ctx->Array.VertexAttrib[VERT_ATTRIB_POS].Enabled) {
min = ctx->Array.VertexAttrib[VERT_ATTRIB_POS]._MaxElement; min = ctx->Array.VertexAttrib[VERT_ATTRIB_POS]._MaxElement;
} }
@ -888,7 +892,7 @@ update_arrays( GLcontext *ctx )
} }
/* 8..15 */ /* 8..15 */
for (i = VERT_ATTRIB_TEX0; i < VERT_ATTRIB_MAX; i++) { for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {
if (ctx->VertexProgram._Enabled if (ctx->VertexProgram._Enabled
&& ctx->Array.VertexAttrib[i].Enabled) { && ctx->Array.VertexAttrib[i].Enabled) {
min = MIN2(min, ctx->Array.VertexAttrib[i]._MaxElement); min = MIN2(min, ctx->Array.VertexAttrib[i]._MaxElement);
@ -899,6 +903,15 @@ update_arrays( GLcontext *ctx )
} }
} }
/* 16..31 */
if (ctx->ShaderObjects._VertexShaderPresent) {
for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
if (ctx->Array.VertexAttrib[i].Enabled) {
min = MIN2(min, ctx->Array.VertexAttrib[i]._MaxElement);
}
}
}
if (ctx->Array.Index.Enabled) { if (ctx->Array.Index.Enabled) {
min = MIN2(min, ctx->Array.Index._MaxElement); min = MIN2(min, ctx->Array.Index._MaxElement);
} }

6
src/mesa/main/varray.c
View file

@ -1,8 +1,8 @@
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.1 * Version: 6.5
* *
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -441,7 +441,7 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
GET_CURRENT_CONTEXT(ctx); GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx);
if (index >= VERT_ATTRIB_MAX) { if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) {
_mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(index)"); _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(index)");
return; return;
} }

4
src/mesa/shader/arbprogparse.c
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -856,7 +856,7 @@ parse_generic_attrib_num(GLcontext *ctx, GLubyte ** inst,
{ {
GLint i = parse_integer(inst, Program); GLint i = parse_integer(inst, Program);
if ((i < 0) || (i > MAX_VERTEX_PROGRAM_ATTRIBS)) if ((i < 0) || (i >= MAX_VERTEX_PROGRAM_ATTRIBS))
{ {
_mesa_set_program_error (ctx, Program->Position, _mesa_set_program_error (ctx, Program->Position,
"Invalid generic vertex attribute index"); "Invalid generic vertex attribute index");

5
src/mesa/shader/arbprogram.c
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -124,10 +124,7 @@ _mesa_GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params)
break; break;
case GL_CURRENT_VERTEX_ATTRIB_ARB: case GL_CURRENT_VERTEX_ATTRIB_ARB:
FLUSH_CURRENT(ctx, 0); FLUSH_CURRENT(ctx, 0);
/* XXX should read:
COPY_4V(params, ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index]); COPY_4V(params, ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index]);
*/
COPY_4V(params, ctx->Current.Attrib[index]);
break; break;
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB: case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
if (!ctx->Extensions.ARB_vertex_buffer_object) { if (!ctx->Extensions.ARB_vertex_buffer_object) {

4
src/mesa/shader/nvvertexec.c
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -51,7 +51,7 @@ _mesa_init_vp_per_vertex_registers(GLcontext *ctx)
{ {
/* Input registers get initialized from the current vertex attribs */ /* Input registers get initialized from the current vertex attribs */
MEMCPY(ctx->VertexProgram.Inputs, ctx->Current.Attrib, MEMCPY(ctx->VertexProgram.Inputs, ctx->Current.Attrib,
VERT_ATTRIB_MAX * 4 * sizeof(GLfloat)); MAX_VERTEX_PROGRAM_ATTRIBS * 4 * sizeof(GLfloat));
if (ctx->VertexProgram.Current->IsNVProgram) { if (ctx->VertexProgram.Current->IsNVProgram) {
GLuint i; GLuint i;

10
src/mesa/swrast/s_arbshader.c
View file

@ -75,6 +75,16 @@ void _swrast_exec_arbshader (GLcontext *ctx, struct sw_span *span)
(**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_TEXCOORD, vec, j, (**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_TEXCOORD, vec, j,
4 * sizeof (GLfloat), GL_TRUE); 4 * sizeof (GLfloat), GL_TRUE);
} }
for (j = 0; j < MAX_VARYING_VECTORS; j++)
{
GLuint k;
for (k = 0; k < VARYINGS_PER_VECTOR; k++)
{
(**pro).UpdateVarying (pro, j * VARYINGS_PER_VECTOR + k,
&span->array->varying[i][j][k], GL_FALSE);
}
}
_slang_exec_fragment_shader (pro); _slang_exec_fragment_shader (pro);

7
src/mesa/swrast/s_context.h
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -66,6 +66,7 @@
#define SPAN_FLAT 0x400 /**< flat shading? */ #define SPAN_FLAT 0x400 /**< flat shading? */
#define SPAN_XY 0x800 #define SPAN_XY 0x800
#define SPAN_MASK 0x1000 #define SPAN_MASK 0x1000
#define SPAN_VARYING 0x2000
/*@}*/ /*@}*/
@ -90,6 +91,7 @@ struct span_arrays {
GLfloat texcoords[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH][4]; GLfloat texcoords[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH][4];
GLfloat lambda[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH]; GLfloat lambda[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH];
GLfloat coverage[MAX_WIDTH]; GLfloat coverage[MAX_WIDTH];
GLfloat varying[MAX_WIDTH][MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
/** This mask indicates which fragments are alive or culled */ /** This mask indicates which fragments are alive or culled */
GLubyte mask[MAX_WIDTH]; GLubyte mask[MAX_WIDTH];
@ -167,6 +169,9 @@ struct sw_span {
GLfloat texStepX[MAX_TEXTURE_COORD_UNITS][4]; GLfloat texStepX[MAX_TEXTURE_COORD_UNITS][4];
GLfloat texStepY[MAX_TEXTURE_COORD_UNITS][4]; GLfloat texStepY[MAX_TEXTURE_COORD_UNITS][4];
GLfixed intTex[2], intTexStep[2]; /* s, t only */ GLfixed intTex[2], intTexStep[2]; /* s, t only */
GLfloat var[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
GLfloat varStepX[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
GLfloat varStepY[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
/* partial derivatives wrt X and Y. */ /* partial derivatives wrt X and Y. */
GLfloat dzdx, dzdy; GLfloat dzdx, dzdy;

48
src/mesa/swrast/s_span.c
View file

@ -434,7 +434,8 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
GLfloat r = span->tex[u][2]; GLfloat r = span->tex[u][2];
GLfloat q = span->tex[u][3]; GLfloat q = span->tex[u][3];
GLuint i; GLuint i;
if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled) { if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled ||
ctx->ShaderObjects._FragmentShaderPresent) {
/* do perspective correction but don't divide s, t, r by q */ /* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->dwdx; const GLfloat dwdx = span->dwdx;
GLfloat w = span->w; GLfloat w = span->w;
@ -485,7 +486,8 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
GLfloat r = span->tex[u][2]; GLfloat r = span->tex[u][2];
GLfloat q = span->tex[u][3]; GLfloat q = span->tex[u][3];
GLuint i; GLuint i;
if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled) { if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled ||
ctx->ShaderObjects._FragmentShaderPresent) {
/* do perspective correction but don't divide s, t, r by q */ /* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->dwdx; const GLfloat dwdx = span->dwdx;
GLfloat w = span->w; GLfloat w = span->w;
@ -568,7 +570,8 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
GLfloat r = span->tex[0][2]; GLfloat r = span->tex[0][2];
GLfloat q = span->tex[0][3]; GLfloat q = span->tex[0][3];
GLuint i; GLuint i;
if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled) { if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled ||
ctx->ShaderObjects._FragmentShaderPresent) {
/* do perspective correction but don't divide s, t, r by q */ /* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->dwdx; const GLfloat dwdx = span->dwdx;
GLfloat w = span->w; GLfloat w = span->w;
@ -619,7 +622,8 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
GLfloat r = span->tex[0][2]; GLfloat r = span->tex[0][2];
GLfloat q = span->tex[0][3]; GLfloat q = span->tex[0][3];
GLuint i; GLuint i;
if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled) { if (ctx->FragmentProgram._Active || ctx->ATIFragmentShader._Enabled ||
ctx->ShaderObjects._FragmentShaderPresent) {
/* do perspective correction but don't divide s, t, r by q */ /* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->dwdx; const GLfloat dwdx = span->dwdx;
GLfloat w = span->w; GLfloat w = span->w;
@ -667,6 +671,38 @@ interpolate_texcoords(GLcontext *ctx, struct sw_span *span)
} }
/**
* Fill in the span.varying array from the interpolation values.
*/
static void
interpolate_varying(GLcontext *ctx, struct sw_span *span)
{
GLuint i, j;
ASSERT(span->interpMask & SPAN_VARYING);
ASSERT(!(span->arrayMask & SPAN_VARYING));
span->arrayMask |= SPAN_VARYING;
for (i = 0; i < MAX_VARYING_VECTORS; i++) {
for (j = 0; j < VARYINGS_PER_VECTOR; j++) {
const GLfloat dvdx = span->varStepX[i][j];
GLfloat v = span->var[i][j];
const GLfloat dwdx = span->dwdx;
GLfloat w = span->w;
GLuint k;
for (k = 0; k < span->end; k++) {
GLfloat invW = 1.0f / w;
span->array->varying[k][i][j] = v * invW;
v += dvdx;
w += dwdx;
}
}
}
}
/** /**
* Apply the current polygon stipple pattern to a span of pixels. * Apply the current polygon stipple pattern to a span of pixels.
*/ */
@ -1139,6 +1175,10 @@ _swrast_write_rgba_span( GLcontext *ctx, struct sw_span *span)
interpolate_texcoords(ctx, span); interpolate_texcoords(ctx, span);
} }
if (ctx->ShaderObjects._FragmentShaderPresent) {
interpolate_varying(ctx, span);
}
/* This is the normal place to compute the resulting fragment color/Z. /* This is the normal place to compute the resulting fragment color/Z.
* As an optimization, we try to defer this until after Z/stencil * As an optimization, we try to defer this until after Z/stencil
* testing in order to try to avoid computing colors that we won't * testing in order to try to avoid computing colors that we won't

66
src/mesa/swrast/s_tritemp.h
View file

@ -28,7 +28,7 @@
* This file is #include'd to generate custom triangle rasterizers. * This file is #include'd to generate custom triangle rasterizers.
* *
* The following macros may be defined to indicate what auxillary information * The following macros may be defined to indicate what auxillary information
* must be interplated across the triangle: * must be interpolated across the triangle:
* INTERP_Z - if defined, interpolate vertex Z values * INTERP_Z - if defined, interpolate vertex Z values
* INTERP_W - if defined, interpolate vertex W values * INTERP_W - if defined, interpolate vertex W values
* INTERP_FOG - if defined, interpolate fog values * INTERP_FOG - if defined, interpolate fog values
@ -41,6 +41,7 @@
* INTERP_TEX - if defined, interpolate set 0 float STRQ texcoords * INTERP_TEX - if defined, interpolate set 0 float STRQ texcoords
* NOTE: OpenGL STRQ = Mesa STUV (R was taken for red) * NOTE: OpenGL STRQ = Mesa STUV (R was taken for red)
* INTERP_MULTITEX - if defined, interpolate N units of STRQ texcoords * INTERP_MULTITEX - if defined, interpolate N units of STRQ texcoords
* INTERP_VARYING - if defined, interpolate M floats of GLSL varyings
* *
* When one can directly address pixels in the color buffer the following * When one can directly address pixels in the color buffer the following
* macros can be defined and used to compute pixel addresses during * macros can be defined and used to compute pixel addresses during
@ -142,6 +143,20 @@
#ifdef INTERP_VARYING
#define VARYING_LOOP(CODE)\
{\
GLuint iv, ic;\
for (iv = 0; iv < MAX_VARYING_VECTORS; iv++) {\
for (ic = 0; ic < VARYINGS_PER_VECTOR; ic++) {\
CODE\
}\
}\
}
#endif
/* /*
* Some code we unfortunately need to prevent negative interpolated colors. * Some code we unfortunately need to prevent negative interpolated colors.
*/ */
@ -648,6 +663,19 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
) )
} }
#endif #endif
#ifdef INTERP_VARYING
span.interpMask |= SPAN_VARYING;
{
/* win[3] is 1/W */
const GLfloat wMax = vMax->win[3], wMin = vMin->win[3], wMid = vMid->win[3];
VARYING_LOOP(
GLfloat eMaj_dvar = vMax->attribute[iv][ic] * wMax - vMin->attribute[iv][ic] * wMin;
GLfloat eBot_dvar = vMid->attribute[iv][ic] * wMid - vMin->attribute[iv][ic] * wMin;
span.varStepX[iv][ic] = oneOverArea * (eMaj_dvar * eBot.dy - eMaj.dy * eBot_dvar);
span.varStepY[iv][ic] = oneOverArea * (eMaj.dx * eBot_dvar - eMaj_dvar * eBot.dx);
)
}
#endif
/* /*
* We always sample at pixel centers. However, we avoid * We always sample at pixel centers. However, we avoid
@ -751,6 +779,11 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
GLfloat duOuter[MAX_TEXTURE_COORD_UNITS], duInner[MAX_TEXTURE_COORD_UNITS]; GLfloat duOuter[MAX_TEXTURE_COORD_UNITS], duInner[MAX_TEXTURE_COORD_UNITS];
GLfloat dvOuter[MAX_TEXTURE_COORD_UNITS], dvInner[MAX_TEXTURE_COORD_UNITS]; GLfloat dvOuter[MAX_TEXTURE_COORD_UNITS], dvInner[MAX_TEXTURE_COORD_UNITS];
#endif #endif
#ifdef INTERP_VARYING
GLfloat varLeft[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
GLfloat dvarOuter[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
GLfloat dvarInner[MAX_VARYING_VECTORS][VARYINGS_PER_VECTOR];
#endif
for (subTriangle=0; subTriangle<=1; subTriangle++) { for (subTriangle=0; subTriangle<=1; subTriangle++) {
EdgeT *eLeft, *eRight; EdgeT *eLeft, *eRight;
@ -1023,6 +1056,15 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
duOuter[u] = span.texStepY[u][2] + dxOuter * span.texStepX[u][2]; duOuter[u] = span.texStepY[u][2] + dxOuter * span.texStepX[u][2];
dvOuter[u] = span.texStepY[u][3] + dxOuter * span.texStepX[u][3]; dvOuter[u] = span.texStepY[u][3] + dxOuter * span.texStepX[u][3];
) )
#endif
#ifdef INTERP_VARYING
VARYING_LOOP(
const GLfloat invW = vLower->win[3];
const GLfloat var0 = vLower->attribute[iv][ic] * invW;
varLeft[iv][ic] = var0 + (span.varStepX[iv][ic] * adjx +
span.varStepY[iv][ic] * adjy) * (1.0f / FIXED_SCALE);
dvarOuter[iv][ic] = span.varStepY[iv][ic] + dxOuter * span.varStepX[iv][ic];
)
#endif #endif
} /*if setupLeft*/ } /*if setupLeft*/
@ -1086,6 +1128,11 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
dvInner[u] = dvOuter[u] + span.texStepX[u][3]; dvInner[u] = dvOuter[u] + span.texStepX[u][3];
) )
#endif #endif
#ifdef INTERP_VARYING
VARYING_LOOP(
dvarInner[iv][ic] = dvarOuter[iv][ic] + span.varStepX[iv][ic];
)
#endif
while (lines > 0) { while (lines > 0) {
/* initialize the span interpolants to the leftmost value */ /* initialize the span interpolants to the leftmost value */
@ -1135,6 +1182,11 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
span.tex[u][3] = vLeft[u]; span.tex[u][3] = vLeft[u];
) )
#endif #endif
#ifdef INTERP_VARYING
VARYING_LOOP(
span.var[iv][ic] = varLeft[iv][ic];
)
#endif
/* This is where we actually generate fragments */ /* This is where we actually generate fragments */
/* XXX the test for span.y > 0 _shouldn't_ be needed but /* XXX the test for span.y > 0 _shouldn't_ be needed but
@ -1222,6 +1274,11 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
uLeft[u] += duOuter[u]; uLeft[u] += duOuter[u];
vLeft[u] += dvOuter[u]; vLeft[u] += dvOuter[u];
) )
#endif
#ifdef INTERP_VARYING
VARYING_LOOP(
varLeft[iv][ic] += dvarOuter[iv][ic];
)
#endif #endif
} }
else { else {
@ -1267,6 +1324,11 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
uLeft[u] += duInner[u]; uLeft[u] += duInner[u];
vLeft[u] += dvInner[u]; vLeft[u] += dvInner[u];
) )
#endif
#ifdef INTERP_VARYING
VARYING_LOOP(
varLeft[iv][ic] += dvarInner[iv][ic];
)
#endif #endif
} }
} /*while lines>0*/ } /*while lines>0*/
@ -1299,7 +1361,9 @@ static void NAME(GLcontext *ctx, const SWvertex *v0,
#undef INTERP_INT_TEX #undef INTERP_INT_TEX
#undef INTERP_TEX #undef INTERP_TEX
#undef INTERP_MULTITEX #undef INTERP_MULTITEX
#undef INTERP_VARYING
#undef TEX_UNIT_LOOP #undef TEX_UNIT_LOOP
#undef VARYING_LOOP
#undef S_SCALE #undef S_SCALE
#undef T_SCALE #undef T_SCALE

3
src/mesa/swrast/swrast.h
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -73,6 +73,7 @@ typedef struct {
GLfloat fog; GLfloat fog;
GLfloat index; GLfloat index;
GLfloat pointSize; GLfloat pointSize;
GLfloat attribute[MAX_VERTEX_ATTRIBS][4];
} SWvertex; } SWvertex;

40
src/mesa/swrast_setup/ss_context.c
View file

@ -1,8 +1,8 @@
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.1 * Version: 6.5
* *
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -93,7 +93,6 @@ do { \
e++; \ e++; \
} while (0) } while (0)
/* /*
* We patch this function into tnl->Driver.Render.Start. * We patch this function into tnl->Driver.Render.Start.
* It's called when we start rendering a vertex buffer. * It's called when we start rendering a vertex buffer.
@ -119,43 +118,52 @@ _swsetup_RenderStart( GLcontext *ctx )
VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr; VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
if (tnl->render_inputs != swsetup->last_index) { if (!RENDERINPUTS_EQUAL(tnl->render_inputs_bitset, swsetup->last_index_bitset)) {
GLuint index = tnl->render_inputs; DECLARE_RENDERINPUTS(index_bitset);
struct tnl_attr_map map[_TNL_ATTRIB_MAX]; struct tnl_attr_map map[_TNL_ATTRIB_MAX];
int i, e = 0; int i, e = 0;
RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, win ); EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, win );
if (index & _TNL_BIT_COLOR0) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR0 ))
EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4CHAN_4F_RGBA, color ); EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4CHAN_4F_RGBA, color );
if (index & _TNL_BIT_COLOR1) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ))
EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_4CHAN_4F_RGBA, specular); EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_4CHAN_4F_RGBA, specular);
if (index & _TNL_BIT_FOG) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG ))
EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1F, fog); EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1F, fog);
if (index & _TNL_BITS_TEX_ANY) { if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) { for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
if (index & _TNL_BIT_TEX(i)) { if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_4F, texcoord[i] ); EMIT_ATTR( _TNL_ATTRIB_TEX(i), EMIT_4F, texcoord[i] );
} }
} }
} }
if (index & _TNL_BIT_INDEX) if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_ATTRIBUTE, _TNL_LAST_ATTRIBUTE )) {
for (i = 0; i < MAX_VERTEX_ATTRIBS; i++) {
if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_ATTRIBUTE(i) )) {
EMIT_ATTR( _TNL_ATTRIB_ATTRIBUTE(i), VARYING_EMIT_STYLE, attribute[i] );
}
}
}
if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_INDEX ))
EMIT_ATTR( _TNL_ATTRIB_INDEX, EMIT_1F, index ); EMIT_ATTR( _TNL_ATTRIB_INDEX, EMIT_1F, index );
if (index & _TNL_BIT_POINTSIZE) if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE ))
EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, pointSize ); EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, pointSize );
_tnl_install_attrs( ctx, map, e, _tnl_install_attrs( ctx, map, e,
ctx->Viewport._WindowMap.m, ctx->Viewport._WindowMap.m,
sizeof(SWvertex) ); sizeof(SWvertex) );
swsetup->last_index = index; RENDERINPUTS_COPY( swsetup->last_index_bitset, index_bitset );
} }
} }
/* /*
@ -205,7 +213,7 @@ _swsetup_Wakeup( GLcontext *ctx )
_swsetup_InvalidateState( ctx, ~0 ); _swsetup_InvalidateState( ctx, ~0 );
swsetup->verts = (SWvertex *)tnl->clipspace.vertex_buf; swsetup->verts = (SWvertex *)tnl->clipspace.vertex_buf;
swsetup->last_index = 0; RENDERINPUTS_ZERO( swsetup->last_index_bitset );
} }

7
src/mesa/swrast_setup/ss_context.h
View file

@ -1,9 +1,9 @@
/* /*
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 4.1 * Version: 6.5
* *
* Copyright (C) 1999-2002 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -32,11 +32,12 @@
#include "mtypes.h" #include "mtypes.h"
#include "swrast/swrast.h" #include "swrast/swrast.h"
#include "swrast_setup.h" #include "swrast_setup.h"
#include "tnl/t_context.h"
typedef struct { typedef struct {
GLuint NewState; GLuint NewState;
GLenum render_prim; GLenum render_prim;
GLuint last_index; DECLARE_RENDERINPUTS(last_index_bitset);
SWvertex *verts; SWvertex *verts;
} SScontext; } SScontext;

31
src/mesa/tnl/t_context.c
View file

@ -2,7 +2,7 @@
* Mesa 3-D graphics library * Mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -170,32 +170,43 @@ _tnl_InvalidateState( GLcontext *ctx, GLuint new_state )
/* Calculate tnl->render_inputs: /* Calculate tnl->render_inputs:
*/ */
if (ctx->Visual.rgbMode) { if (ctx->Visual.rgbMode) {
tnl->render_inputs = (_TNL_BIT_POS| GLuint i;
_TNL_BIT_COLOR0|
(ctx->Texture._EnabledCoordUnits << _TNL_ATTRIB_TEX0)); RENDERINPUTS_ZERO( tnl->render_inputs_bitset );
RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POS );
RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR0 );
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
if (ctx->Texture._EnabledCoordUnits & (1 << i)) {
RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX(i) );
}
}
if (NEED_SECONDARY_COLOR(ctx)) if (NEED_SECONDARY_COLOR(ctx))
tnl->render_inputs |= _TNL_BIT_COLOR1; RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR1 );
} }
else { else {
tnl->render_inputs |= (_TNL_BIT_POS|_TNL_BIT_INDEX); RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POS );
RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_INDEX );
} }
if (ctx->Fog.Enabled || if (ctx->Fog.Enabled ||
(ctx->FragmentProgram._Active && (ctx->FragmentProgram._Active &&
ctx->FragmentProgram._Current->FogOption != GL_NONE)) ctx->FragmentProgram._Current->FogOption != GL_NONE))
tnl->render_inputs |= _TNL_BIT_FOG; RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_FOG );
if (ctx->Polygon.FrontMode != GL_FILL || if (ctx->Polygon.FrontMode != GL_FILL ||
ctx->Polygon.BackMode != GL_FILL) ctx->Polygon.BackMode != GL_FILL)
tnl->render_inputs |= _TNL_BIT_EDGEFLAG; RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_EDGEFLAG );
if (ctx->RenderMode == GL_FEEDBACK) if (ctx->RenderMode == GL_FEEDBACK)
tnl->render_inputs |= _TNL_BIT_TEX0; RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_TEX0 );
if (ctx->Point._Attenuated || if (ctx->Point._Attenuated ||
(ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled)) (ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled))
tnl->render_inputs |= _TNL_BIT_POINTSIZE; RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POINTSIZE );
if (ctx->ShaderObjects._VertexShaderPresent || ctx->ShaderObjects._FragmentShaderPresent)
RENDERINPUTS_SET_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_ATTRIBUTE, _TNL_LAST_ATTRIBUTE );
} }

154
src/mesa/tnl/t_context.h
View file

@ -2,7 +2,7 @@
* mesa 3-D graphics library * mesa 3-D graphics library
* Version: 6.5 * Version: 6.5
* *
* Copyright (C) 1999-2005 Brian Paul All Rights Reserved. * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* *
* Permission is hereby granted, free of charge, to any person obtaining a * Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"), * copy of this software and associated documentation files (the "Software"),
@ -92,6 +92,12 @@
* number of bits allocated for these numbers in places like vertex * number of bits allocated for these numbers in places like vertex
* program instruction formats and register layouts. * program instruction formats and register layouts.
*/ */
/* The bit space exhaustion is a fact now, done by _TNL_ATTRIB_ATTRIBUTE* for
* GLSL vertex shader which cannot be aliased with conventional vertex attribs.
* Compacting _TNL_ATTRIB_MAT_* attribs would not work, they would not give
* as many free bits (11 plus already 1 free bit) as _TNL_ATTRIB_ATTRIBUTE*
* attribs want (16).
*/
enum { enum {
_TNL_ATTRIB_POS = 0, _TNL_ATTRIB_POS = 0,
_TNL_ATTRIB_WEIGHT = 1, _TNL_ATTRIB_WEIGHT = 1,
@ -109,98 +115,56 @@ enum {
_TNL_ATTRIB_TEX5 = 13, _TNL_ATTRIB_TEX5 = 13,
_TNL_ATTRIB_TEX6 = 14, _TNL_ATTRIB_TEX6 = 14,
_TNL_ATTRIB_TEX7 = 15, _TNL_ATTRIB_TEX7 = 15,
_TNL_ATTRIB_MAT_FRONT_AMBIENT = 16, _TNL_ATTRIB_ATTRIBUTE0 = 16,
_TNL_ATTRIB_MAT_BACK_AMBIENT = 17, _TNL_ATTRIB_ATTRIBUTE1 = 17,
_TNL_ATTRIB_MAT_FRONT_DIFFUSE = 18, _TNL_ATTRIB_ATTRIBUTE2 = 18,
_TNL_ATTRIB_MAT_BACK_DIFFUSE = 19, _TNL_ATTRIB_ATTRIBUTE3 = 19,
_TNL_ATTRIB_MAT_FRONT_SPECULAR = 20, _TNL_ATTRIB_ATTRIBUTE4 = 20,
_TNL_ATTRIB_MAT_BACK_SPECULAR = 21, _TNL_ATTRIB_ATTRIBUTE5 = 21,
_TNL_ATTRIB_MAT_FRONT_EMISSION = 22, _TNL_ATTRIB_ATTRIBUTE6 = 22,
_TNL_ATTRIB_MAT_BACK_EMISSION = 23, _TNL_ATTRIB_ATTRIBUTE7 = 23,
_TNL_ATTRIB_MAT_FRONT_SHININESS = 24, _TNL_ATTRIB_ATTRIBUTE8 = 24,
_TNL_ATTRIB_MAT_BACK_SHININESS = 25, _TNL_ATTRIB_ATTRIBUTE9 = 25,
_TNL_ATTRIB_MAT_FRONT_INDEXES = 26, _TNL_ATTRIB_ATTRIBUTE10 = 26,
_TNL_ATTRIB_MAT_BACK_INDEXES = 27, _TNL_ATTRIB_ATTRIBUTE11 = 27,
_TNL_ATTRIB_INDEX = 28, _TNL_ATTRIB_ATTRIBUTE12 = 28,
_TNL_ATTRIB_EDGEFLAG = 29, _TNL_ATTRIB_ATTRIBUTE13 = 29,
_TNL_ATTRIB_POINTSIZE = 30, _TNL_ATTRIB_ATTRIBUTE14 = 30,
_TNL_ATTRIB_MAX = 31 _TNL_ATTRIB_ATTRIBUTE15 = 31,
_TNL_ATTRIB_MAT_FRONT_AMBIENT = 32,
_TNL_ATTRIB_MAT_BACK_AMBIENT = 33,
_TNL_ATTRIB_MAT_FRONT_DIFFUSE = 34,
_TNL_ATTRIB_MAT_BACK_DIFFUSE = 35,
_TNL_ATTRIB_MAT_FRONT_SPECULAR = 36,
_TNL_ATTRIB_MAT_BACK_SPECULAR = 37,
_TNL_ATTRIB_MAT_FRONT_EMISSION = 38,
_TNL_ATTRIB_MAT_BACK_EMISSION = 39,
_TNL_ATTRIB_MAT_FRONT_SHININESS = 40,
_TNL_ATTRIB_MAT_BACK_SHININESS = 41,
_TNL_ATTRIB_MAT_FRONT_INDEXES = 42,
_TNL_ATTRIB_MAT_BACK_INDEXES = 43,
_TNL_ATTRIB_INDEX = 44,
_TNL_ATTRIB_EDGEFLAG = 45,
_TNL_ATTRIB_POINTSIZE = 46,
_TNL_ATTRIB_MAX = 47
} ; } ;
/* Will probably have to revise this scheme fairly shortly, eg. by #define _TNL_ATTRIB_TEX(u) (_TNL_ATTRIB_TEX0 + (u))
* compacting all the MAT flags down to one bit, or by using two #define _TNL_ATTRIB_ATTRIBUTE(n) (_TNL_ATTRIB_ATTRIBUTE0 + (n))
* dwords to store the flags.
/* Define bit ranges instead of bit masks.
*/ */
#define _TNL_BIT_POS (1<<0) #define _TNL_FIRST_PROG _TNL_ATTRIB_WEIGHT
#define _TNL_BIT_WEIGHT (1<<1) #define _TNL_LAST_PROG _TNL_ATTRIB_TEX7
#define _TNL_BIT_NORMAL (1<<2)
#define _TNL_BIT_COLOR0 (1<<3)
#define _TNL_BIT_COLOR1 (1<<4)
#define _TNL_BIT_FOG (1<<5)
#define _TNL_BIT_SIX (1<<6)
#define _TNL_BIT_SEVEN (1<<7)
#define _TNL_BIT_TEX0 (1<<8)
#define _TNL_BIT_TEX1 (1<<9)
#define _TNL_BIT_TEX2 (1<<10)
#define _TNL_BIT_TEX3 (1<<11)
#define _TNL_BIT_TEX4 (1<<12)
#define _TNL_BIT_TEX5 (1<<13)
#define _TNL_BIT_TEX6 (1<<14)
#define _TNL_BIT_TEX7 (1<<15)
#define _TNL_BIT_MAT_FRONT_AMBIENT (1<<16)
#define _TNL_BIT_MAT_BACK_AMBIENT (1<<17)
#define _TNL_BIT_MAT_FRONT_DIFFUSE (1<<18)
#define _TNL_BIT_MAT_BACK_DIFFUSE (1<<19)
#define _TNL_BIT_MAT_FRONT_SPECULAR (1<<20)
#define _TNL_BIT_MAT_BACK_SPECULAR (1<<21)
#define _TNL_BIT_MAT_FRONT_EMISSION (1<<22)
#define _TNL_BIT_MAT_BACK_EMISSION (1<<23)
#define _TNL_BIT_MAT_FRONT_SHININESS (1<<24)
#define _TNL_BIT_MAT_BACK_SHININESS (1<<25)
#define _TNL_BIT_MAT_FRONT_INDEXES (1<<26)
#define _TNL_BIT_MAT_BACK_INDEXES (1<<27)
#define _TNL_BIT_INDEX (1<<28)
#define _TNL_BIT_EDGEFLAG (1<<29)
#define _TNL_BIT_POINTSIZE (1<<30)
#define _TNL_BIT_TEX(u) (1 << (_TNL_ATTRIB_TEX0 + (u))) #define _TNL_FIRST_TEX _TNL_ATTRIB_TEX0
#define _TNL_LAST_TEX _TNL_ATTRIB_TEX7
#define _TNL_FIRST_ATTRIBUTE _TNL_ATTRIB_ATTRIBUTE0
#define _TNL_LAST_ATTRIBUTE _TNL_ATTRIB_ATTRIBUTE15
#define _TNL_FIRST_MAT _TNL_ATTRIB_MAT_FRONT_AMBIENT
#define _TNL_BITS_MAT_ANY (_TNL_BIT_MAT_FRONT_AMBIENT | \ #define _TNL_LAST_MAT _TNL_ATTRIB_MAT_BACK_INDEXES
_TNL_BIT_MAT_BACK_AMBIENT | \
_TNL_BIT_MAT_FRONT_DIFFUSE | \
_TNL_BIT_MAT_BACK_DIFFUSE | \
_TNL_BIT_MAT_FRONT_SPECULAR | \
_TNL_BIT_MAT_BACK_SPECULAR | \
_TNL_BIT_MAT_FRONT_EMISSION | \
_TNL_BIT_MAT_BACK_EMISSION | \
_TNL_BIT_MAT_FRONT_SHININESS | \
_TNL_BIT_MAT_BACK_SHININESS | \
_TNL_BIT_MAT_FRONT_INDEXES | \
_TNL_BIT_MAT_BACK_INDEXES)
#define _TNL_BITS_TEX_ANY (_TNL_BIT_TEX0 | \
_TNL_BIT_TEX1 | \
_TNL_BIT_TEX2 | \
_TNL_BIT_TEX3 | \
_TNL_BIT_TEX4 | \
_TNL_BIT_TEX5 | \
_TNL_BIT_TEX6 | \
_TNL_BIT_TEX7)
#define _TNL_BITS_PROG_ANY (_TNL_BIT_POS | \
_TNL_BIT_WEIGHT | \
_TNL_BIT_NORMAL | \
_TNL_BIT_COLOR0 | \
_TNL_BIT_COLOR1 | \
_TNL_BIT_FOG | \
_TNL_BIT_SIX | \
_TNL_BIT_SEVEN | \
_TNL_BITS_TEX_ANY)
#define PRIM_BEGIN 0x10 #define PRIM_BEGIN 0x10
@ -444,6 +408,7 @@ struct vertex_buffer
GLvector4f *SecondaryColorPtr[2]; /* _TNL_BIT_COLOR1 */ GLvector4f *SecondaryColorPtr[2]; /* _TNL_BIT_COLOR1 */
GLvector4f *PointSizePtr; /* _TNL_BIT_POS */ GLvector4f *PointSizePtr; /* _TNL_BIT_POS */
GLvector4f *FogCoordPtr; /* _TNL_BIT_FOG */ GLvector4f *FogCoordPtr; /* _TNL_BIT_FOG */
GLvector4f *VaryingPtr[MAX_VARYING_VECTORS];
struct tnl_prim *Primitive; struct tnl_prim *Primitive;
GLuint PrimitiveCount; GLuint PrimitiveCount;
@ -732,6 +697,19 @@ struct tnl_device_driver
}; };
#define DECLARE_RENDERINPUTS(name) BITSET64_DECLARE(name, _TNL_ATTRIB_MAX)
#define RENDERINPUTS_COPY BITSET64_COPY
#define RENDERINPUTS_EQUAL BITSET64_EQUAL
#define RENDERINPUTS_ZERO BITSET64_ZERO
#define RENDERINPUTS_ONES BITSET64_ONES
#define RENDERINPUTS_TEST BITSET64_TEST
#define RENDERINPUTS_SET BITSET64_SET
#define RENDERINPUTS_CLEAR BITSET64_CLEAR
#define RENDERINPUTS_TEST_RANGE BITSET64_TEST_RANGE
#define RENDERINPUTS_SET_RANGE BITSET64_SET_RANGE
#define RENDERINPUTS_CLEAR_RANGE BITSET64_CLEAR_RANGE
/** /**
* Context state for T&L context. * Context state for T&L context.
*/ */
@ -783,7 +761,7 @@ typedef struct
*/ */
GLboolean DiscardPrimitive; GLboolean DiscardPrimitive;
GLuint render_inputs; DECLARE_RENDERINPUTS(render_inputs_bitset);
GLvertexformat exec_vtxfmt; GLvertexformat exec_vtxfmt;
GLvertexformat save_vtxfmt; GLvertexformat save_vtxfmt;

32
src/mesa/tnl/t_save_api.c
View file

@ -936,7 +936,7 @@ static void GLAPIENTRY _save_MultiTexCoord4fv( GLenum target, const GLfloat *v )
static void GLAPIENTRY _save_VertexAttrib1fNV( GLuint index, GLfloat x ) static void GLAPIENTRY _save_VertexAttrib1fNV( GLuint index, GLfloat x )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR1F( index, x ); DISPATCH_ATTR1F( index, x );
else else
enum_error(); enum_error();
@ -944,7 +944,7 @@ static void GLAPIENTRY _save_VertexAttrib1fNV( GLuint index, GLfloat x )
static void GLAPIENTRY _save_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) static void GLAPIENTRY _save_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR1FV( index, v ); DISPATCH_ATTR1FV( index, v );
else else
enum_error(); enum_error();
@ -952,7 +952,7 @@ static void GLAPIENTRY _save_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
static void GLAPIENTRY _save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) static void GLAPIENTRY _save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR2F( index, x, y ); DISPATCH_ATTR2F( index, x, y );
else else
enum_error(); enum_error();
@ -960,7 +960,7 @@ static void GLAPIENTRY _save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat
static void GLAPIENTRY _save_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) static void GLAPIENTRY _save_VertexAttrib2fvNV( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR2FV( index, v ); DISPATCH_ATTR2FV( index, v );
else else
enum_error(); enum_error();
@ -969,7 +969,7 @@ static void GLAPIENTRY _save_VertexAttrib2fvNV( GLuint index, const GLfloat *v )
static void GLAPIENTRY _save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, static void GLAPIENTRY _save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y,
GLfloat z ) GLfloat z )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR3F( index, x, y, z ); DISPATCH_ATTR3F( index, x, y, z );
else else
enum_error(); enum_error();
@ -977,7 +977,7 @@ static void GLAPIENTRY _save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat
static void GLAPIENTRY _save_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) static void GLAPIENTRY _save_VertexAttrib3fvNV( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR3FV( index, v ); DISPATCH_ATTR3FV( index, v );
else else
enum_error(); enum_error();
@ -986,7 +986,7 @@ static void GLAPIENTRY _save_VertexAttrib3fvNV( GLuint index, const GLfloat *v )
static void GLAPIENTRY _save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, static void GLAPIENTRY _save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y,
GLfloat z, GLfloat w ) GLfloat z, GLfloat w )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR4F( index, x, y, z, w ); DISPATCH_ATTR4F( index, x, y, z, w );
else else
enum_error(); enum_error();
@ -994,7 +994,7 @@ static void GLAPIENTRY _save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat
static void GLAPIENTRY _save_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) static void GLAPIENTRY _save_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
DISPATCH_ATTR4FV( index, v ); DISPATCH_ATTR4FV( index, v );
else else
enum_error(); enum_error();
@ -1004,7 +1004,7 @@ static void GLAPIENTRY _save_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib1fARB( GLuint index, GLfloat x ) _save_VertexAttrib1fARB( GLuint index, GLfloat x )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR1F( index, x ); DISPATCH_ATTR1F( index, x );
else else
enum_error(); enum_error();
@ -1013,7 +1013,7 @@ _save_VertexAttrib1fARB( GLuint index, GLfloat x )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib1fvARB( GLuint index, const GLfloat *v ) _save_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR1FV( index, v ); DISPATCH_ATTR1FV( index, v );
else else
enum_error(); enum_error();
@ -1022,7 +1022,7 @@ _save_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) _save_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR2F( index, x, y ); DISPATCH_ATTR2F( index, x, y );
else else
enum_error(); enum_error();
@ -1031,7 +1031,7 @@ _save_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib2fvARB( GLuint index, const GLfloat *v ) _save_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR2FV( index, v ); DISPATCH_ATTR2FV( index, v );
else else
enum_error(); enum_error();
@ -1040,7 +1040,7 @@ _save_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) _save_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR3F( index, x, y, z ); DISPATCH_ATTR3F( index, x, y, z );
else else
enum_error(); enum_error();
@ -1049,7 +1049,7 @@ _save_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib3fvARB( GLuint index, const GLfloat *v ) _save_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR3FV( index, v ); DISPATCH_ATTR3FV( index, v );
else else
enum_error(); enum_error();
@ -1058,7 +1058,7 @@ _save_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) _save_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR4F( index, x, y, z, w ); DISPATCH_ATTR4F( index, x, y, z, w );
else else
enum_error(); enum_error();
@ -1067,7 +1067,7 @@ _save_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat
static void GLAPIENTRY static void GLAPIENTRY
_save_VertexAttrib4fvARB( GLuint index, const GLfloat *v ) _save_VertexAttrib4fvARB( GLuint index, const GLfloat *v )
{ {
if (index < VERT_ATTRIB_MAX) if (index < MAX_VERTEX_ATTRIBS)
DISPATCH_ATTR4FV( index, v ); DISPATCH_ATTR4FV( index, v );
else else
enum_error(); enum_error();

23
src/mesa/tnl/t_vb_arbshader.c
View file

@ -37,6 +37,7 @@
typedef struct typedef struct
{ {
GLvector4f outputs[VERT_RESULT_MAX]; GLvector4f outputs[VERT_RESULT_MAX];
GLvector4f varyings[MAX_VARYING_VECTORS];
GLvector4f ndc_coords; GLvector4f ndc_coords;
GLubyte *clipmask; GLubyte *clipmask;
GLubyte ormask; GLubyte ormask;
@ -63,6 +64,11 @@ static GLboolean construct_arb_vertex_shader (GLcontext *ctx, struct tnl_pipelin
_mesa_vector4f_alloc (&store->outputs[i], 0, size, 32); _mesa_vector4f_alloc (&store->outputs[i], 0, size, 32);
store->outputs[i].size = 4; store->outputs[i].size = 4;
} }
for (i = 0; i < MAX_VARYING_VECTORS; i++)
{
_mesa_vector4f_alloc (&store->varyings[i], 0, size, 32);
store->varyings[i].size = 4;
}
_mesa_vector4f_alloc (&store->ndc_coords, 0, size, 32); _mesa_vector4f_alloc (&store->ndc_coords, 0, size, 32);
store->clipmask = (GLubyte *) ALIGN_MALLOC (size, 32); store->clipmask = (GLubyte *) ALIGN_MALLOC (size, 32);
@ -79,6 +85,8 @@ static void destruct_arb_vertex_shader (struct tnl_pipeline_stage *stage)
for (i = 0; i < VERT_RESULT_MAX; i++) for (i = 0; i < VERT_RESULT_MAX; i++)
_mesa_vector4f_free (&store->outputs[i]); _mesa_vector4f_free (&store->outputs[i]);
for (i = 0; i < MAX_VARYING_VECTORS; i++)
_mesa_vector4f_free (&store->varyings[i]);
_mesa_vector4f_free (&store->ndc_coords); _mesa_vector4f_free (&store->ndc_coords);
ALIGN_FREE (store->clipmask); ALIGN_FREE (store->clipmask);
@ -206,6 +214,17 @@ static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stag
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store); fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store);
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store); fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store);
/* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */ /* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
for (j = 0; j < MAX_VARYING_VECTORS; j++)
{
GLuint k;
for (k = 0; k < VARYINGS_PER_VECTOR; k++)
{
(**pro).UpdateVarying (pro, j * VARYINGS_PER_VECTOR + k,
&store->varyings[j].data[i][k], GL_TRUE);
}
}
} }
vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS]; vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
@ -218,6 +237,8 @@ static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stag
vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1]; vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1];
vb->FogCoordPtr = &store->outputs[VERT_RESULT_FOGC]; vb->FogCoordPtr = &store->outputs[VERT_RESULT_FOGC];
vb->PointSizePtr = &store->outputs[VERT_RESULT_PSIZ]; vb->PointSizePtr = &store->outputs[VERT_RESULT_PSIZ];
for (i = 0; i < MAX_VARYING_VECTORS; i++)
vb->VaryingPtr[i] = &store->varyings[i];
vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0]; vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0];
vb->AttribPtr[VERT_ATTRIB_COLOR1] = vb->SecondaryColorPtr[0]; vb->AttribPtr[VERT_ATTRIB_COLOR1] = vb->SecondaryColorPtr[0];
@ -225,6 +246,8 @@ static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stag
for (i = 0; i < ctx->Const.MaxTextureUnits; i++) for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
vb->AttribPtr[VERT_ATTRIB_TEX0 + i] = vb->TexCoordPtr[i]; vb->AttribPtr[VERT_ATTRIB_TEX0 + i] = vb->TexCoordPtr[i];
vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ]; vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ];
for (i = 0; i < MAX_VARYING_VECTORS; i++)
vb->AttribPtr[_TNL_ATTRIB_ATTRIBUTE0 + i] = vb->VaryingPtr[i];
store->ormask = 0; store->ormask = 0;
store->andmask = CLIP_FRUSTUM_BITS; store->andmask = CLIP_FRUSTUM_BITS;

61
src/mesa/tnl/t_vtx_generic.c
View file

@ -364,42 +364,42 @@ static void GLAPIENTRY _tnl_MultiTexCoord4fv( GLenum target,
static void GLAPIENTRY _tnl_VertexAttrib1fNV( GLuint index, GLfloat x ) static void GLAPIENTRY _tnl_VertexAttrib1fNV( GLuint index, GLfloat x )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR1F( index, x ); DISPATCH_ATTR1F( index, x );
} }
static void GLAPIENTRY _tnl_VertexAttrib1fvNV( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib1fvNV( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR1FV( index, v ); DISPATCH_ATTR1FV( index, v );
} }
static void GLAPIENTRY _tnl_VertexAttrib2fNV( GLuint index, GLfloat x, static void GLAPIENTRY _tnl_VertexAttrib2fNV( GLuint index, GLfloat x,
GLfloat y ) GLfloat y )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR2F( index, x, y ); DISPATCH_ATTR2F( index, x, y );
} }
static void GLAPIENTRY _tnl_VertexAttrib2fvNV( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib2fvNV( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR2FV( index, v ); DISPATCH_ATTR2FV( index, v );
} }
static void GLAPIENTRY _tnl_VertexAttrib3fNV( GLuint index, GLfloat x, static void GLAPIENTRY _tnl_VertexAttrib3fNV( GLuint index, GLfloat x,
GLfloat y, GLfloat z ) GLfloat y, GLfloat z )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR3F( index, x, y, z ); DISPATCH_ATTR3F( index, x, y, z );
} }
static void GLAPIENTRY _tnl_VertexAttrib3fvNV( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib3fvNV( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR3FV( index, v ); DISPATCH_ATTR3FV( index, v );
} }
@ -407,60 +407,73 @@ static void GLAPIENTRY _tnl_VertexAttrib4fNV( GLuint index, GLfloat x,
GLfloat y, GLfloat z, GLfloat y, GLfloat z,
GLfloat w ) GLfloat w )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR4F( index, x, y, z, w ); DISPATCH_ATTR4F( index, x, y, z, w );
} }
static void GLAPIENTRY _tnl_VertexAttrib4fvNV( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib4fvNV( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) index = ERROR_ATTRIB;
DISPATCH_ATTR4FV( index, v ); DISPATCH_ATTR4FV( index, v );
} }
/*
* XXX adjust index
*/
static void GLAPIENTRY _tnl_VertexAttrib1fARB( GLuint index, GLfloat x ) static void GLAPIENTRY _tnl_VertexAttrib1fARB( GLuint index, GLfloat x )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR1F( index, x ); DISPATCH_ATTR1F( index, x );
} }
static void GLAPIENTRY _tnl_VertexAttrib1fvARB( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib1fvARB( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR1FV( index, v ); DISPATCH_ATTR1FV( index, v );
} }
static void GLAPIENTRY _tnl_VertexAttrib2fARB( GLuint index, GLfloat x, static void GLAPIENTRY _tnl_VertexAttrib2fARB( GLuint index, GLfloat x,
GLfloat y ) GLfloat y )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR2F( index, x, y ); DISPATCH_ATTR2F( index, x, y );
} }
static void GLAPIENTRY _tnl_VertexAttrib2fvARB( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib2fvARB( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR2FV( index, v ); DISPATCH_ATTR2FV( index, v );
} }
static void GLAPIENTRY _tnl_VertexAttrib3fARB( GLuint index, GLfloat x, static void GLAPIENTRY _tnl_VertexAttrib3fARB( GLuint index, GLfloat x,
GLfloat y, GLfloat z ) GLfloat y, GLfloat z )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR3F( index, x, y, z ); DISPATCH_ATTR3F( index, x, y, z );
} }
static void GLAPIENTRY _tnl_VertexAttrib3fvARB( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib3fvARB( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR3FV( index, v ); DISPATCH_ATTR3FV( index, v );
} }
@ -468,14 +481,20 @@ static void GLAPIENTRY _tnl_VertexAttrib4fARB( GLuint index, GLfloat x,
GLfloat y, GLfloat z, GLfloat y, GLfloat z,
GLfloat w ) GLfloat w )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR4F( index, x, y, z, w ); DISPATCH_ATTR4F( index, x, y, z, w );
} }
static void GLAPIENTRY _tnl_VertexAttrib4fvARB( GLuint index, static void GLAPIENTRY _tnl_VertexAttrib4fvARB( GLuint index,
const GLfloat *v ) const GLfloat *v )
{ {
if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; if (index >= MAX_VERTEX_ATTRIBS)
index = ERROR_ATTRIB;
else
index += VERT_ATTRIB_GENERIC0;
DISPATCH_ATTR4FV( index, v ); DISPATCH_ATTR4FV( index, v );
} }