#include "colormac.h"
#include "r200_reg.h"
-#define ENABLE_HW_3D_TEXTURE 0 /* XXX this is temporary! */
+#define ENABLE_HW_3D_TEXTURE 1 /* XXX this is temporary! */
struct r200_context;
typedef struct r200_context r200ContextRec;
#define VTX_COLOR(v,n) (((v)>>(R200_VTX_COLOR_0_SHIFT+(n)*2))&\
R200_VTX_COLOR_MASK)
+/**
+ * Given the \c R200_SE_VTX_FMT_1 for the current vertex state, determine
+ * how many components are in texture coordinate \c n.
+ */
+#define VTX_TEXn_COUNT(v,n) (((v) >> (3 * n)) & 0x07)
+
#define MAT_CMD_0 0
#define MAT_ELT_0 1
#define MAT_STATE_SIZE 17
struct dynfn SecondaryColor3fvEXT;
struct dynfn Normal3f;
struct dynfn Normal3fv;
+ struct dynfn TexCoord3f;
+ struct dynfn TexCoord3fv;
struct dynfn TexCoord2f;
struct dynfn TexCoord2fv;
struct dynfn TexCoord1f;
struct dynfn TexCoord1fv;
+ struct dynfn MultiTexCoord3fARB;
+ struct dynfn MultiTexCoord3fvARB;
struct dynfn MultiTexCoord2fARB;
struct dynfn MultiTexCoord2fvARB;
struct dynfn MultiTexCoord1fARB;
struct dynfn *(*SecondaryColor3fvEXT)( GLcontext *, const int * );
struct dynfn *(*Normal3f)( GLcontext *, const int * );
struct dynfn *(*Normal3fv)( GLcontext *, const int * );
+ struct dynfn *(*TexCoord3f)( GLcontext *, const int * );
+ struct dynfn *(*TexCoord3fv)( GLcontext *, const int * );
struct dynfn *(*TexCoord2f)( GLcontext *, const int * );
struct dynfn *(*TexCoord2fv)( GLcontext *, const int * );
struct dynfn *(*TexCoord1f)( GLcontext *, const int * );
struct dynfn *(*TexCoord1fv)( GLcontext *, const int * );
+ struct dynfn *(*MultiTexCoord3fARB)( GLcontext *, const int * );
+ struct dynfn *(*MultiTexCoord3fvARB)( GLcontext *, const int * );
struct dynfn *(*MultiTexCoord2fARB)( GLcontext *, const int * );
struct dynfn *(*MultiTexCoord2fvARB)( GLcontext *, const int * );
struct dynfn *(*MultiTexCoord1fARB)( GLcontext *, const int * );
void (*notify)( void );
GLint vertex_size;
- /* A maximum total of 15 elements per vertex: 3 floats for position, 3
+ /* A maximum total of 17 elements per vertex: 3 floats for position, 3
* floats for normal, 4 floats for color, 4 bytes for secondary color,
- * 2 floats for each texture unit (4 floats total).
+ * 3 floats for each texture unit (6 floats total).
*
- * As soon as the 3rd TMU is supported or cube maps (or 3D textures) are
- * supported, this value will grow.
+ * As soon as the 3rd through 6th TMUs are supported, this value will grow.
*
* The position data is never actually stored here, so 3 elements could be
* trimmed out of the buffer.
*/
- union { float f; int i; r200_color_t color; } vertex[15];
+ union { float f; int i; r200_color_t color; } vertex[17];
GLfloat *normalptr;
GLfloat *floatcolorptr;
GLuint nr = 0;
GLuint vfmt0 = 0, vfmt1 = 0;
GLuint count = VB->Count;
+ GLuint i;
+ GLuint re_cntl;
if (1) {
if (!rmesa->tcl.obj.buf)
/* vtx = (rmesa->hw.tcl.cmd[TCL_OUTPUT_VTXFMT] & */
/* ~(R200_TCL_VTX_Q0|R200_TCL_VTX_Q1)); */
- if (inputs & VERT_BIT_TEX0) {
- if (!rmesa->tcl.tex[0].buf)
- emit_vector( ctx,
- &(rmesa->tcl.tex[0]),
- (char *)VB->TexCoordPtr[0]->data,
- VB->TexCoordPtr[0]->size,
- VB->TexCoordPtr[0]->stride,
- count );
-
- vfmt1 |= VB->TexCoordPtr[0]->size << R200_VTX_TEX0_COMP_CNT_SHIFT;
- component[nr++] = &rmesa->tcl.tex[0];
+ re_cntl = rmesa->hw.set.cmd[SET_RE_CNTL] & ~(R200_VTX_STQ0_D3D |
+ R200_VTX_STQ1_D3D |
+ R200_VTX_STQ2_D3D |
+ R200_VTX_STQ3_D3D |
+ R200_VTX_STQ4_D3D |
+ R200_VTX_STQ5_D3D );
+ for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+ if (inputs & (VERT_BIT_TEX0 << i)) {
+ if (!rmesa->tcl.tex[i].buf)
+ emit_vector( ctx,
+ &(rmesa->tcl.tex[i]),
+ (char *)VB->TexCoordPtr[i]->data,
+ VB->TexCoordPtr[i]->size,
+ VB->TexCoordPtr[i]->stride,
+ count );
+
+ if ( ctx->Texture.Unit[i]._ReallyEnabled == TEXTURE_CUBE_BIT ) {
+ re_cntl |= R200_VTX_STQ0_D3D << (2 * i);
+ }
+
+ vfmt1 |= VB->TexCoordPtr[i]->size << (i * 3);
+ component[nr++] = &rmesa->tcl.tex[i];
+ }
}
- if (inputs & VERT_BIT_TEX1) {
- if (!rmesa->tcl.tex[1].buf)
- emit_vector( ctx,
- &(rmesa->tcl.tex[1]),
- (char *)VB->TexCoordPtr[1]->data,
- VB->TexCoordPtr[1]->size,
- VB->TexCoordPtr[1]->stride,
- count );
-
- vfmt1 |= VB->TexCoordPtr[1]->size << R200_VTX_TEX1_COMP_CNT_SHIFT;
- component[nr++] = &rmesa->tcl.tex[1];
+ if ( re_cntl != rmesa->hw.set.cmd[SET_RE_CNTL] ) {
+ R200_STATECHANGE( rmesa, set );
+ rmesa->hw.set.cmd[SET_RE_CNTL] = re_cntl;
}
if (vfmt0 != rmesa->hw.vtx.cmd[VTX_VTXFMT_0] ||
GLuint sz = VB->TexCoordPtr[i]->size;
GLuint emit;
- /* r200 doesn't like 1D or 4D texcoords (is that true?):
+ /* r200 doesn't like 4D texcoords (is that true?):
*/
- switch (sz) {
- case 1:
- case 2:
- case 3: /* no attempt at cube texturing so far */
- emit = EMIT_2F;
- sz = 2;
- break;
- case 4:
+ if (sz != 4) {
+ emit = EMIT_1F + (sz - 1);
+ }
+ else {
+ sz = 3;
emit = EMIT_3F_XYW;
- sz = 3;
- break;
- default:
- continue;
- };
+ }
fmt_1 |= sz << (3 * i);
EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_SZ(sz), 0 );
#define TEXOBJ_TXFORMAT_X_MASK (R200_DEPTH_LOG2_MASK | \
R200_TEXCOORD_MASK | \
+ R200_CLAMP_Q_MASK | \
R200_VOLUME_FILTER_MASK)
count_func( "SecondaryColor3ubv", &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
count_func( "Normal3f", &rmesa->vb.dfn_cache.Normal3f );
count_func( "Normal3fv", &rmesa->vb.dfn_cache.Normal3fv );
+ count_func( "TexCoord3f", &rmesa->vb.dfn_cache.TexCoord3f );
+ count_func( "TexCoord3fv", &rmesa->vb.dfn_cache.TexCoord3fv );
count_func( "TexCoord2f", &rmesa->vb.dfn_cache.TexCoord2f );
count_func( "TexCoord2fv", &rmesa->vb.dfn_cache.TexCoord2fv );
count_func( "TexCoord1f", &rmesa->vb.dfn_cache.TexCoord1f );
count_func( "TexCoord1fv", &rmesa->vb.dfn_cache.TexCoord1fv );
+ count_func( "MultiTexCoord3fARB", &rmesa->vb.dfn_cache.MultiTexCoord3fARB );
+ count_func( "MultiTexCoord3fvARB", &rmesa->vb.dfn_cache.MultiTexCoord3fvARB );
count_func( "MultiTexCoord2fARB", &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
count_func( "MultiTexCoord2fvARB", &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
count_func( "MultiTexCoord1fARB", &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
void r200_copy_to_current( GLcontext *ctx )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
+ unsigned i;
if (R200_DEBUG & DEBUG_VFMT)
fprintf(stderr, "%s\n", __FUNCTION__);
ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2] = UBYTE_TO_FLOAT( rmesa->vb.specptr->blue );
}
- if (rmesa->vb.vtxfmt_1 & (7 << R200_VTX_TEX0_COMP_CNT_SHIFT)) {
- ctx->Current.Attrib[VERT_ATTRIB_TEX0][0] = rmesa->vb.texcoordptr[0][0];
- ctx->Current.Attrib[VERT_ATTRIB_TEX0][1] = rmesa->vb.texcoordptr[0][1];
- ctx->Current.Attrib[VERT_ATTRIB_TEX0][2] = 0.0F;
- ctx->Current.Attrib[VERT_ATTRIB_TEX0][3] = 1.0F;
- }
+ for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+ const unsigned count = VTX_TEXn_COUNT( rmesa->vb.vtxfmt_1, i );
+ GLfloat * const src = rmesa->vb.texcoordptr[i];
+
+ if ( count != 0 ) {
+ switch( count ) {
+ case 3:
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][1] = src[1];
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][2] = src[2];
+ break;
+ case 2:
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][1] = src[1];
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][2] = 0.0F;
+ break;
+ case 1:
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][1] = 0.0F;
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][2] = 0.0F;
+ break;
+ }
- if (rmesa->vb.vtxfmt_1 & (7 << R200_VTX_TEX1_COMP_CNT_SHIFT)) {
- ctx->Current.Attrib[VERT_ATTRIB_TEX1][0] = rmesa->vb.texcoordptr[1][0];
- ctx->Current.Attrib[VERT_ATTRIB_TEX1][1] = rmesa->vb.texcoordptr[1][1];
- ctx->Current.Attrib[VERT_ATTRIB_TEX1][2] = 0.0F;
- ctx->Current.Attrib[VERT_ATTRIB_TEX1][3] = 1.0F;
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][0] = src[0];
+ ctx->Current.Attrib[VERT_ATTRIB_TEX0+i][3] = 1.0F;
+ }
}
ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
}
+static void dispatch_texcoord( GLuint count, GLfloat * f )
+{
+ switch( count ) {
+ case 3:
+ _glapi_Dispatch->TexCoord3fv( f );
+ break;
+ case 2:
+ _glapi_Dispatch->TexCoord2fv( f );
+ break;
+ case 1:
+ _glapi_Dispatch->TexCoord1fv( f );
+ break;
+ default:
+ assert( count == 0 );
+ break;
+ }
+}
+
+static void dispatch_multitexcoord( GLuint count, GLuint unit, GLfloat * f )
+{
+ switch( count ) {
+ case 3:
+ _glapi_Dispatch->MultiTexCoord3fvARB( GL_TEXTURE0+unit, f );
+ break;
+ case 2:
+ _glapi_Dispatch->MultiTexCoord2fvARB( GL_TEXTURE0+unit, f );
+ break;
+ case 1:
+ _glapi_Dispatch->MultiTexCoord1fvARB( GL_TEXTURE0+unit, f );
+ break;
+ default:
+ assert( count == 0 );
+ break;
+ }
+}
+
static void VFMT_FALLBACK( const char *caller )
{
GET_CURRENT_CONTEXT(ctx);
GLuint ind1 = rmesa->vb.vtxfmt_1;
GLuint nrverts;
GLfloat alpha = 1.0;
+ GLuint count;
+ GLuint unit;
if (R200_DEBUG & (DEBUG_FALLBACKS|DEBUG_VFMT))
fprintf(stderr, "%s from %s\n", __FUNCTION__, caller);
*/
for (i = 0 ; i < nrverts; i++) {
GLuint offset = 3;
+
if (ind0 & R200_VTX_N0) {
_glapi_Dispatch->Normal3fv( &tmp[i][offset] );
offset += 3;
offset++;
}
- if (ind1 & (7 << R200_VTX_TEX0_COMP_CNT_SHIFT)) {
- _glapi_Dispatch->TexCoord2fv( &tmp[i][offset] );
- offset += 2;
- }
+ count = VTX_TEXn_COUNT( ind1, 0 );
+ dispatch_texcoord( count, &tmp[i][offset] );
+ offset += count;
- if (ind1 & (7 << R200_VTX_TEX1_COMP_CNT_SHIFT)) {
- _glapi_Dispatch->MultiTexCoord2fvARB( GL_TEXTURE1, &tmp[i][offset] );
- offset += 2;
+ for ( unit = 1 ; unit < ctx->Const.MaxTextureUnits ; unit++ ) {
+ count = VTX_TEXn_COUNT( ind1, unit );
+ dispatch_multitexcoord( count, unit, &tmp[i][offset] );
+ offset += count;
}
_glapi_Dispatch->Vertex3fv( &tmp[i][0] );
rmesa->vb.specptr->green,
rmesa->vb.specptr->blue );
- if (ind1 & (7 << R200_VTX_TEX0_COMP_CNT_SHIFT)) {
- _glapi_Dispatch->TexCoord2fv( rmesa->vb.texcoordptr[0] );
- }
+ count = VTX_TEXn_COUNT( ind1, 0 );
+ dispatch_texcoord( count, rmesa->vb.texcoordptr[0] );
- if (ind1 & (7 << R200_VTX_TEX1_COMP_CNT_SHIFT)) {
- _glapi_Dispatch->MultiTexCoord2fvARB( GL_TEXTURE1, rmesa->vb.texcoordptr[1] );
+ for ( unit = 1 ; unit < ctx->Const.MaxTextureUnits ; unit++ ) {
+ count = VTX_TEXn_COUNT( ind1, unit );
+ dispatch_multitexcoord( count, unit, rmesa->vb.texcoordptr[unit] );
}
}
}
-
+/**
+ * Determines the hardware vertex format based on the current state vector.
+ *
+ * \returns
+ * If the hardware TCL unit is capable of handling the current state vector,
+ * \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
+ *
+ * \todo
+ * Make this color format selection data driven. If we receive only ubytes,
+ * send color as ubytes. Also check if converting (with free checking for
+ * overflow) is cheaper than sending floats directly.
+ *
+ * \todo
+ * When intializing texture coordinates, it might be faster to just copy the
+ * entire \c VERT_ATTRIB_TEX0 vector into the vertex buffer. It may mean that
+ * some of the data (i.e., the last texture coordinate components) get copied
+ * over, but that still may be faster than the conditional branching. If
+ * nothing else, the code will be smaller and easier to follow.
+ */
static GLboolean check_vtx_fmt( GLcontext *ctx )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
GLuint ind0 = R200_VTX_Z0;
GLuint ind1 = 0;
+ GLuint i;
+ GLuint count[R200_MAX_TEXTURE_UNITS];
+ GLuint re_cntl;
+
if (rmesa->TclFallback || rmesa->vb.fell_back || ctx->CompileFlag)
return GL_FALSE;
if (ctx->Light.Enabled) {
ind0 |= R200_VTX_N0;
- /* TODO: make this data driven: If we receive only ubytes, send
- * color as ubytes. Also check if converting (with free
- * checking for overflow) is cheaper than sending floats
- * directly.
- */
if (ctx->Light.ColorMaterialEnabled)
ind0 |= R200_VTX_FP_RGBA << R200_VTX_COLOR_0_SHIFT;
else
}
}
- if (ctx->Texture.Unit[0]._ReallyEnabled) {
- if (ctx->Texture.Unit[0].TexGenEnabled) {
- if (rmesa->TexGenNeedNormals[0]) {
- ind0 |= R200_VTX_N0;
+ re_cntl = rmesa->hw.set.cmd[SET_RE_CNTL] & ~(R200_VTX_STQ0_D3D |
+ R200_VTX_STQ1_D3D |
+ R200_VTX_STQ2_D3D |
+ R200_VTX_STQ3_D3D |
+ R200_VTX_STQ4_D3D |
+ R200_VTX_STQ5_D3D );
+ for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+ count[i] = 0;
+
+ if (ctx->Texture.Unit[i]._ReallyEnabled) {
+ if (ctx->Texture.Unit[i].TexGenEnabled) {
+ if (rmesa->TexGenNeedNormals[i]) {
+ ind0 |= R200_VTX_N0;
+ }
}
- } else {
- if (ctx->Current.Attrib[VERT_ATTRIB_TEX0][2] != 0.0F ||
- ctx->Current.Attrib[VERT_ATTRIB_TEX0][3] != 1.0) {
- if (R200_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
- fprintf(stderr, "%s: rq0\n", __FUNCTION__);
- return GL_FALSE;
+ else {
+ switch( ctx->Texture.Unit[i]._ReallyEnabled ) {
+ case TEXTURE_CUBE_BIT:
+ re_cntl |= R200_VTX_STQ0_D3D << (2 * i);
+ /* FALLTHROUGH */
+ case TEXTURE_3D_BIT:
+ count[i] = 3;
+ break;
+ case TEXTURE_2D_BIT:
+ case TEXTURE_RECT_BIT:
+ count[i] = 2;
+ break;
+ case TEXTURE_1D_BIT:
+ count[i] = 1;
+ break;
+ }
+
+ ind1 |= count[i] << (3 * i);
}
- ind1 |= 2 << R200_VTX_TEX0_COMP_CNT_SHIFT;
}
}
- if (ctx->Texture.Unit[1]._ReallyEnabled) {
- if (ctx->Texture.Unit[1].TexGenEnabled) {
- if (rmesa->TexGenNeedNormals[1]) {
- ind0 |= R200_VTX_N0;
- }
- } else {
- if (ctx->Current.Attrib[VERT_ATTRIB_TEX1][2] != 0.0F ||
- ctx->Current.Attrib[VERT_ATTRIB_TEX1][3] != 1.0) {
- if (R200_DEBUG & (DEBUG_VFMT|DEBUG_FALLBACKS))
- fprintf(stderr, "%s: rq1\n", __FUNCTION__);
- return GL_FALSE;
- }
- ind1 |= 2 << R200_VTX_TEX1_COMP_CNT_SHIFT;
- }
+ if ( re_cntl != rmesa->hw.set.cmd[SET_RE_CNTL] ) {
+ R200_STATECHANGE( rmesa, set );
+ rmesa->hw.set.cmd[SET_RE_CNTL] = re_cntl;
}
if (R200_DEBUG & (DEBUG_VFMT|DEBUG_STATE))
}
- if (ind1 & (7 << R200_VTX_TEX0_COMP_CNT_SHIFT)) {
- rmesa->vb.texcoordptr[0] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
- rmesa->vb.vertex_size += 2;
- rmesa->vb.texcoordptr[0][0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0][0];
- rmesa->vb.texcoordptr[0][1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0][1];
- }
+ for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+ if ( count[i] != 0 ) {
+ float * const attr = ctx->Current.Attrib[VERT_ATTRIB_TEX0+i];
+ unsigned j;
- if (ind1 & (7 << R200_VTX_TEX1_COMP_CNT_SHIFT)) {
- rmesa->vb.texcoordptr[1] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
- rmesa->vb.vertex_size += 2;
- rmesa->vb.texcoordptr[1][0] = ctx->Current.Attrib[VERT_ATTRIB_TEX1][0];
- rmesa->vb.texcoordptr[1][1] = ctx->Current.Attrib[VERT_ATTRIB_TEX1][1];
- }
+ rmesa->vb.texcoordptr[i] = &rmesa->vb.vertex[rmesa->vb.vertex_size].f;
+
+ for ( j = 0 ; j < count[i] ; j++ ) {
+ rmesa->vb.texcoordptr[i][j] = attr[j];
+ }
+
+ rmesa->vb.vertex_size += count[i];
+ }
+ }
if (rmesa->vb.installed_vertex_format != rmesa->vb.vtxfmt_0) {
if (R200_DEBUG & DEBUG_VFMT)
if (R200_DEBUG & DEBUG_VFMT)
fprintf(stderr, "%s -- success\n", __FUNCTION__);
-
+
+ fprintf( stderr, "[%s:%u] vertex size = %u\n", __func__, __LINE__,
+ rmesa->vb.vertex_size );
+
return GL_TRUE;
}
vfmt->EvalMesh2 = r200_fallback_EvalMesh2;
vfmt->EvalPoint1 = r200_fallback_EvalPoint1;
vfmt->EvalPoint2 = r200_fallback_EvalPoint2;
- vfmt->TexCoord3f = r200_fallback_TexCoord3f;
- vfmt->TexCoord3fv = r200_fallback_TexCoord3fv;
vfmt->TexCoord4f = r200_fallback_TexCoord4f;
vfmt->TexCoord4fv = r200_fallback_TexCoord4fv;
- vfmt->MultiTexCoord3fARB = r200_fallback_MultiTexCoord3fARB;
- vfmt->MultiTexCoord3fvARB = r200_fallback_MultiTexCoord3fvARB;
vfmt->MultiTexCoord4fARB = r200_fallback_MultiTexCoord4fARB;
vfmt->MultiTexCoord4fvARB = r200_fallback_MultiTexCoord4fvARB;
vfmt->Vertex4f = r200_fallback_Vertex4f;
make_empty_list( &rmesa->vb.dfn_cache.SecondaryColor3ubvEXT );
make_empty_list( &rmesa->vb.dfn_cache.Normal3f );
make_empty_list( &rmesa->vb.dfn_cache.Normal3fv );
+ make_empty_list( &rmesa->vb.dfn_cache.TexCoord3f );
+ make_empty_list( &rmesa->vb.dfn_cache.TexCoord3fv );
make_empty_list( &rmesa->vb.dfn_cache.TexCoord2f );
make_empty_list( &rmesa->vb.dfn_cache.TexCoord2fv );
make_empty_list( &rmesa->vb.dfn_cache.TexCoord1f );
make_empty_list( &rmesa->vb.dfn_cache.TexCoord1fv );
+ make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord3fARB );
+ make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord3fvARB );
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
free_funcs( &rmesa->vb.dfn_cache.SecondaryColor3fvEXT );
free_funcs( &rmesa->vb.dfn_cache.Normal3f );
free_funcs( &rmesa->vb.dfn_cache.Normal3fv );
+ free_funcs( &rmesa->vb.dfn_cache.TexCoord3f );
+ free_funcs( &rmesa->vb.dfn_cache.TexCoord3fv );
free_funcs( &rmesa->vb.dfn_cache.TexCoord2f );
free_funcs( &rmesa->vb.dfn_cache.TexCoord2fv );
free_funcs( &rmesa->vb.dfn_cache.TexCoord1f );
free_funcs( &rmesa->vb.dfn_cache.TexCoord1fv );
+ free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord3fARB );
+ free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord3fvARB );
free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fARB );
free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord2fvARB );
free_funcs( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
/* TexCoord
*/
-static void r200_TexCoord1f( GLfloat s )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[0];
- dest[0] = s;
- dest[1] = 0;
-}
-static void r200_TexCoord1fv( const GLfloat *v )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[0];
- dest[0] = v[0];
- dest[1] = 0;
-}
-
-static void r200_TexCoord2f( GLfloat s, GLfloat t )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[0];
- dest[0] = s;
- dest[1] = t;
-}
+#define TEX_to_nF(N, P, S, T, R) \
+ static void r200_TexCoord ## N P \
+ { \
+ GET_CURRENT_CONTEXT(ctx); r200ContextPtr rmesa = R200_CONTEXT(ctx); \
+ GLfloat * const dest = rmesa->vb.texcoordptr[0]; \
+ switch( ctx->Texture.Unit[0]._ReallyEnabled ) { \
+ case TEXTURE_CUBE_BIT: \
+ case TEXTURE_3D_BIT: \
+ dest[2] = R; \
+ case TEXTURE_2D_BIT: \
+ case TEXTURE_RECT_BIT: \
+ dest[1] = T; \
+ case TEXTURE_1D_BIT: \
+ dest[0] = S; \
+ } \
+ }
-static void r200_TexCoord2fv( const GLfloat *v )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[0];
- dest[0] = v[0];
- dest[1] = v[1];
-}
+TEX_to_nF( 1f, (GLfloat s), s, 0.0, 0.0 )
+TEX_to_nF( 2f, (GLfloat s, GLfloat t), s, t, 0.0 )
+TEX_to_nF( 3f, (GLfloat s, GLfloat t, GLfloat r), s, t, r )
+TEX_to_nF( 1fv, (const GLfloat * v), v[0], 0.0, 0.0 )
+TEX_to_nF( 2fv, (const GLfloat * v), v[0], v[1], 0.0 )
+TEX_to_nF( 3fv, (const GLfloat * v), v[0], v[1], v[2] )
/* MultiTexcoord
* the subtraction has been omitted.
*/
-static void r200_MultiTexCoord1fARB( GLenum target, GLfloat s )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[target & 1];
- dest[0] = s;
- dest[1] = 0;
-}
-
-static void r200_MultiTexCoord1fvARB( GLenum target, const GLfloat *v )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[target & 1];
- dest[0] = v[0];
- dest[1] = 0;
-}
+#define MTEX_to_nF(N, P, U, S, T, R) \
+ static void r200_MultiTexCoord ## N ## ARB P \
+ { \
+ GET_CURRENT_CONTEXT(ctx); r200ContextPtr rmesa = R200_CONTEXT(ctx); \
+ GLfloat * const dest = rmesa->vb.texcoordptr[U]; \
+ switch( ctx->Texture.Unit[U]._ReallyEnabled ) { \
+ case TEXTURE_CUBE_BIT: \
+ case TEXTURE_3D_BIT: \
+ dest[2] = R; \
+ case TEXTURE_2D_BIT: \
+ case TEXTURE_RECT_BIT: \
+ dest[1] = T; \
+ case TEXTURE_1D_BIT: \
+ dest[0] = S; \
+ } \
+ }
-static void r200_MultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[target & 1];
- dest[0] = s;
- dest[1] = t;
-}
+MTEX_to_nF( 1f, (GLenum target, GLfloat s), (target & 1), s, 0.0, 0.0 )
+MTEX_to_nF( 2f, (GLenum target, GLfloat s, GLfloat t), (target & 1), s, t, 0.0 )
+MTEX_to_nF( 3f, (GLenum target, GLfloat s, GLfloat t, GLfloat r), (target & 1), s, t, r )
-static void r200_MultiTexCoord2fvARB( GLenum target, const GLfloat *v )
-{
- GET_CURRENT_CONTEXT(ctx);
- r200ContextPtr rmesa = R200_CONTEXT(ctx);
- GLfloat *dest = rmesa->vb.texcoordptr[target & 1];
- dest[0] = v[0];
- dest[1] = v[1];
-}
+MTEX_to_nF( 1fv, (GLenum target, const GLfloat *v), (target & 1), v[0], 0.0, 0.0 )
+MTEX_to_nF( 2fv, (GLenum target, const GLfloat *v), (target & 1), v[0], v[1], 0.0 )
+MTEX_to_nF( 3fv, (GLenum target, const GLfloat *v), (target & 1), v[0], v[1], v[2] )
static struct dynfn *lookup( struct dynfn *l, const int *key )
{
+
+
/* VTXFMT_0
*/
#define MASK_XYZW (R200_VTX_W0|R200_VTX_Z0)
typedef void (*p3f)( GLfloat, GLfloat, GLfloat );
typedef void (*p2f)( GLfloat, GLfloat );
typedef void (*p1f)( GLfloat );
+typedef void (*pe3f)( GLenum, GLfloat, GLfloat, GLfloat );
typedef void (*pe2f)( GLenum, GLfloat, GLfloat );
typedef void (*pe1f)( GLenum, GLfloat );
typedef void (*p4ub)( GLubyte, GLubyte, GLubyte, GLubyte );
CHOOSE_SECONDARY_COLOR(SecondaryColor3fvEXT, pfv, MASK_SPEC, 0,
(const GLfloat *v), (v))
+CHOOSE(TexCoord3f, p3f, ~0, MASK_ST0,
+ (GLfloat a,GLfloat b,GLfloat c), (a,b,c))
+CHOOSE(TexCoord3fv, pfv, ~0, MASK_ST0,
+ (const GLfloat *v), (v))
CHOOSE(TexCoord2f, p2f, ~0, MASK_ST0,
(GLfloat a,GLfloat b), (a,b))
CHOOSE(TexCoord2fv, pfv, ~0, MASK_ST0,
CHOOSE(TexCoord1fv, pfv, ~0, MASK_ST0,
(const GLfloat *v), (v))
+CHOOSE(MultiTexCoord3fARB, pe3f, ~0, ~0,
+ (GLenum u,GLfloat a,GLfloat b,GLfloat c), (u,a,b,c))
+CHOOSE(MultiTexCoord3fvARB, pefv, ~0, ~0,
+ (GLenum u,const GLfloat *v), (u,v))
CHOOSE(MultiTexCoord2fARB, pe2f, ~0, ~0,
(GLenum u,GLfloat a,GLfloat b), (u,a,b))
CHOOSE(MultiTexCoord2fvARB, pefv, ~0, ~0,
vfmt->MultiTexCoord1fvARB = choose_MultiTexCoord1fvARB;
vfmt->MultiTexCoord2fARB = choose_MultiTexCoord2fARB;
vfmt->MultiTexCoord2fvARB = choose_MultiTexCoord2fvARB;
+ vfmt->MultiTexCoord3fARB = choose_MultiTexCoord3fARB;
+ vfmt->MultiTexCoord3fvARB = choose_MultiTexCoord3fvARB;
vfmt->Normal3f = choose_Normal3f;
vfmt->Normal3fv = choose_Normal3fv;
vfmt->TexCoord1f = choose_TexCoord1f;
vfmt->TexCoord1fv = choose_TexCoord1fv;
vfmt->TexCoord2f = choose_TexCoord2f;
vfmt->TexCoord2fv = choose_TexCoord2fv;
+ vfmt->TexCoord3f = choose_TexCoord3f;
+ vfmt->TexCoord3fv = choose_TexCoord3fv;
vfmt->Vertex2f = choose_Vertex2f;
vfmt->Vertex2fv = choose_Vertex2fv;
vfmt->Vertex3f = choose_Vertex3f;
gen->Color4ubv = codegen_noop;
gen->Normal3f = codegen_noop;
gen->Normal3fv = codegen_noop;
+
+ gen->TexCoord3f = codegen_noop;
+ gen->TexCoord3fv = codegen_noop;
gen->TexCoord2f = codegen_noop;
gen->TexCoord2fv = codegen_noop;
+ gen->TexCoord1f = codegen_noop;
+ gen->TexCoord1fv = codegen_noop;
+
+ gen->MultiTexCoord3fARB = codegen_noop;
+ gen->MultiTexCoord3fvARB = codegen_noop;
gen->MultiTexCoord2fARB = codegen_noop;
gen->MultiTexCoord2fvARB = codegen_noop;
+ gen->MultiTexCoord1fARB = codegen_noop;
+ gen->MultiTexCoord1fvARB = codegen_noop;
+
gen->Vertex2f = codegen_noop;
gen->Vertex2fv = codegen_noop;
gen->Color3ub = codegen_noop;
gen->SecondaryColor3fvEXT = codegen_noop;
gen->SecondaryColor3ubEXT = codegen_noop;
gen->SecondaryColor3ubvEXT = codegen_noop;
- gen->TexCoord1f = codegen_noop;
- gen->TexCoord1fv = codegen_noop;
- gen->MultiTexCoord1fARB = codegen_noop;
- gen->MultiTexCoord1fvARB = codegen_noop;
if (useCodegen) {
#if defined(USE_X86_ASM)
}
}
+#if 0 /* Temporarily disabled as it is broken w/the new cubemap code. - idr */
static struct dynfn *r200_makeSSETexCoord2fv( GLcontext *ctx, const int * key )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
}
return dfn;
}
+#endif
void r200InitSSECodegen( struct dfn_generators *gen )
{
gen->Normal3f = (void *) r200_makeSSENormal3f;
gen->Color3fv = (void *) r200_makeSSEColor3fv;
gen->Color3f = (void *) r200_makeSSEColor3f;
+#if 0 /* Temporarily disabled as it is broken w/the new cubemap code. - idr */
gen->TexCoord2fv = (void *) r200_makeSSETexCoord2fv;
gen->TexCoord2f = (void *) r200_makeSSETexCoord2f;
gen->MultiTexCoord2fvARB = (void *) r200_makeSSEMultiTexCoord2fv;
gen->MultiTexCoord2fARB = (void *) r200_makeSSEMultiTexCoord2f;
+#endif
}
}
+#if 0 /* Temporarily disabled as it is broken w/the new cubemap code. - idr */
struct dynfn *r200_makeX86TexCoord2fv( GLcontext *ctx, const int *key )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
}
return dfn;
}
-
+#endif
void r200InitX86Codegen( struct dfn_generators *gen )
{
gen->Color4ubv = r200_makeX86Color4ubv; /* PKCOLOR only */
gen->Normal3f = r200_makeX86Normal3f;
gen->Normal3fv = r200_makeX86Normal3fv;
+#if 0 /* Temporarily disabled as it is broken w/the new cubemap code. - idr */
gen->TexCoord2f = r200_makeX86TexCoord2f;
gen->TexCoord2fv = r200_makeX86TexCoord2fv;
gen->MultiTexCoord2fARB = r200_makeX86MultiTexCoord2fARB;
gen->MultiTexCoord2fvARB = r200_makeX86MultiTexCoord2fvARB;
+#endif
gen->Color3f = r200_makeX86Color3f;
gen->Color3fv = r200_makeX86Color3fv;
projects / mesa.git / commitdiff