-/* $Id: t_context.h,v 1.45 2003/03/28 01:39:04 brianp Exp $ */
+/* $Id: t_context.h,v 1.46 2003/03/31 18:19:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint PrimitiveLength[IMM_SIZE]; /* BEGIN/END */
GLuint Flag[IMM_SIZE]; /* VERT_BIT_* flags */
- /* All vertex attributes (position, normal, color, secondary color,
- * texcoords, fog coord) are stored in the Attrib[] arrays instead
- * of individual arrays as we did prior to Mesa 4.1.
- *
- * XXX may need to use 32-byte aligned allocation for this!!!
- * XXX replace this with GLfloat *Attrib[VERT_ATTRIB_MAX] and allocate
- * the attribute arrays as needed, so save memory. As is, we're using
- * 256 bytes per vertex (16 attribs * 4 comps/attrib * 4 bytes/comp).
+ /* Attrib is an array [MAX_VERT_ATTRIBS] of pointer to array [][4]
+ * of GLfloat.
+ * We only pre-allocate the vertex position array. The other vertex
+ * attribute arrays are only allocated when needed to save memory.
*/
- GLfloat Attrib[VERT_ATTRIB_MAX][IMM_SIZE][4]; /* GL_NV_vertex_program */
+ GLfloat (*Attrib[VERT_ATTRIB_MAX])[4];
GLfloat *NormalLengthPtr; /* length of normal vectors (display list only) */
struct vertex_arrays
{
- /* XXX move a bunch of these fields into the Attribs[] array??? */
+ /* Conventional vertex attribute arrays */
GLvector4f Obj;
GLvector4f Normal;
struct gl_client_array Color;
struct gl_client_array SecondaryColor;
- GLvector1ui Index;
- GLvector1ub EdgeFlag;
+ GLvector4f FogCoord;
GLvector4f TexCoord[MAX_TEXTURE_COORD_UNITS];
+ GLvector1ub EdgeFlag;
+ GLvector1ui Index;
GLvector1ui Elt;
- GLvector4f FogCoord;
/* These attributes don't alias with the conventional attributes.
* The GL_NV_vertex_program extension defines 16 extra sets of vertex
-/* $Id: t_imm_alloc.c,v 1.19 2003/03/29 17:09:42 brianp Exp $ */
+/* $Id: t_imm_alloc.c,v 1.20 2003/03/31 18:19:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
immed->TexSize = 0;
immed->NormalLengthPtr = 0;
+ /* Only allocate space for vertex positions right now. Color, texcoord,
+ * etc storage will be allocated as needed.
+ */
+ immed->Attrib[VERT_ATTRIB_POS] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+
+ /* Enable this to allocate all attribute arrays up front */
+ if (0)
+ {
+ int i;
+ for (i = 1; i < VERT_ATTRIB_MAX; i++) {
+ immed->Attrib[i] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+ }
+ }
+
immed->CopyTexSize = 0;
immed->CopyStart = immed->Start;
real_free_immediate( struct immediate *immed )
{
static int freed = 0;
+ GLuint i;
+
+ for (i =0; i < VERT_ATTRIB_MAX; i++) {
+ if (immed->Attrib[i])
+ _mesa_free(immed->Attrib[i]);
+ immed->Attrib[i] = NULL;
+ }
if (immed->Material) {
FREE( immed->Material );
-/* $Id: t_imm_api.c,v 1.39 2003/01/14 04:55:47 brianp Exp $ */
+/* $Id: t_imm_api.c,v 1.40 2003/03/31 18:19:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
}
-
-
-
-
/* Both streams now outside begin/end.
*
* Leave SavedBeginState untouched -- attempt to gather several
}
+/* If the given vertex attribute array hasn't been allocated yet,
+ * allocate it now.
+ */
+#define CHECK_ATTRIB_ARRAY(IM, ATTR) \
+ if (!IM->Attrib[ATTR]) { \
+ IM->Attrib[ATTR] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat)); \
+ if (!IM->Attrib[ATTR]) { \
+ GET_CURRENT_CONTEXT(ctx); \
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glVertex/Normal/etc"); \
+ return; \
+ } \
+ }
+
+
#define COLOR( r, g, b, a ) \
{ \
GET_IMMEDIATE; \
GLuint count = IM->Count; \
- GLfloat *color = IM->Attrib[VERT_ATTRIB_COLOR0][count]; \
- IM->Flag[count] |= VERT_BIT_COLOR0; \
+ GLfloat *color; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_COLOR0); \
+ color = IM->Attrib[VERT_ATTRIB_COLOR0][count]; \
color[0] = r; \
color[1] = g; \
color[2] = b; \
color[3] = a; \
+ IM->Flag[count] |= VERT_BIT_COLOR0; \
}
static void
-
#define SECONDARY_COLOR( r, g, b ) \
{ \
- GLuint count; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ GLfloat *color; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_COLOR1); \
+ color = IM->Attrib[VERT_ATTRIB_COLOR0][count]; \
+ color[0] = r; \
+ color[1] = g; \
+ color[2] = b; \
IM->Flag[count] |= VERT_BIT_COLOR1; \
- IM->Attrib[VERT_ATTRIB_COLOR1][count][0] = r; \
- IM->Attrib[VERT_ATTRIB_COLOR1][count][1] = g; \
- IM->Attrib[VERT_ATTRIB_COLOR1][count][2] = b; \
}
static void
static void
_tnl_FogCoordfEXT( GLfloat f )
{
- GLuint count;
GET_IMMEDIATE;
- count = IM->Count;
- IM->Attrib[VERT_ATTRIB_FOG][count][0] = f; /*FogCoord[count] = f;*/
+ GLuint count = IM->Count;
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_FOG);
+ IM->Attrib[VERT_ATTRIB_FOG][count][0] = f;
IM->Flag[count] |= VERT_BIT_FOG;
}
static void
_tnl_FogCoordfvEXT( const GLfloat *v )
{
- GLuint count;
GET_IMMEDIATE;
- count = IM->Count;
- IM->Attrib[VERT_ATTRIB_FOG][count][0] = v[0]; /*FogCoord[count] = v[0];*/
+ GLuint count = IM->Count;
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_FOG);
+ IM->Attrib[VERT_ATTRIB_FOG][count][0] = v[0];
IM->Flag[count] |= VERT_BIT_FOG;
}
#define NORMAL( x, y, z ) \
{ \
- GLuint count; \
- GLfloat *normal; \
GET_IMMEDIATE; \
- count = IM->Count; \
- IM->Flag[count] |= VERT_BIT_NORMAL; \
+ GLuint count = IM->Count; \
+ GLfloat *normal; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_NORMAL); \
normal = IM->Attrib[VERT_ATTRIB_NORMAL][count]; \
ASSIGN_3V(normal, x,y,z); \
+ IM->Flag[count] |= VERT_BIT_NORMAL; \
}
-#if defined(USE_IEEE)
+#if defined(USE_IEEE_foo)
#define NORMALF( x, y, z ) \
{ \
- GLuint count; \
- fi_type *normal; \
GET_IMMEDIATE; \
- count = IM->Count; \
- IM->Flag[count] |= VERT_BIT_NORMAL; \
+ GLuint count = IM->Count; \
+ fi_type *normal; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_NORMAL); \
normal = (fi_type *)IM->Attrib[VERT_ATTRIB_NORMAL][count]; \
normal[0].i = ((fi_type *)&(x))->i; \
normal[1].i = ((fi_type *)&(y))->i; \
normal[2].i = ((fi_type *)&(z))->i; \
+ IM->Flag[count] |= VERT_BIT_NORMAL; \
}
#else
#define NORMALF NORMAL
_tnl_Normal3fv( const GLfloat *v )
{
NORMALF( v[0], v[1], v[2] );
-/* struct immediate *IM = (struct immediate *)(((GLcontext *) _glapi_Context)->swtnl_im); */
-/* IM->Flag[IM->Count] = VERT_NORM; */
}
#define TEXCOORD1(s) \
{ \
- GLuint count; \
- GLfloat *tc; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ GLfloat *tc; \
IM->Flag[count] |= VERT_BIT_TEX0; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0); \
tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
ASSIGN_4V(tc,s,0,0,1); \
}
#define TEXCOORD2(s, t) \
{ \
- GLuint count; \
- GLfloat *tc; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ GLfloat *tc; \
IM->Flag[count] |= VERT_BIT_TEX0; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0); \
tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
ASSIGN_4V(tc, s, t, 0, 1); \
}
#define TEXCOORD3(s, t, u) \
{ \
- GLuint count; \
- GLfloat *tc; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ GLfloat *tc; \
IM->Flag[count] |= VERT_BIT_TEX0; \
IM->TexSize |= TEX_0_SIZE_3; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0); \
tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
ASSIGN_4V(tc, s, t, u, 1); \
}
#define TEXCOORD4(s, t, u, v) \
{ \
- GLuint count; \
- GLfloat *tc; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ GLfloat *tc; \
IM->Flag[count] |= VERT_BIT_TEX0; \
IM->TexSize |= TEX_0_SIZE_4; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0); \
tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
ASSIGN_4V(tc, s, t, u, v); \
}
#if defined(USE_IEEE)
#define TEXCOORD2F(s, t) \
{ \
- GLuint count; \
- fi_type *tc; \
GET_IMMEDIATE; \
- count = IM->Count; \
+ GLuint count = IM->Count; \
+ fi_type *tc; \
IM->Flag[count] |= VERT_BIT_TEX0; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0); \
tc = (fi_type *)IM->Attrib[VERT_ATTRIB_TEX0][count]; \
tc[0].i = ((fi_type *)&(s))->i; \
tc[1].i = ((fi_type *)&(t))->i; \
GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BIT_POS; \
ASSIGN_4V(dest, x, y, 0, 1); \
-/* ASSERT(IM->Flag[IM->Count]==0); */ \
+ /*ASSERT(IM->Flag[IM->Count]==0);*/ \
if (count == IMM_MAXDATA - 1) \
_tnl_flush_immediate( NULL, IM ); \
}
GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BITS_OBJ_23; \
ASSIGN_4V(dest, x, y, z, 1); \
-/* ASSERT(IM->Flag[IM->Count]==0); */ \
+ /*ASSERT(IM->Flag[IM->Count]==0);*/ \
if (count == IMM_MAXDATA - 1) \
_tnl_flush_immediate( NULL, IM ); \
}
dest[1].i = ((fi_type *)&(y))->i; \
dest[2].i = 0; \
dest[3].i = IEEE_ONE; \
-/* ASSERT(IM->Flag[IM->Count]==0); */ \
+ /*ASSERT(IM->Flag[IM->Count]==0);*/ \
if (count == IMM_MAXDATA - 1) \
_tnl_flush_immediate( NULL, IM ); \
}
dest[1].i = ((fi_type *)&(y))->i; \
dest[2].i = ((fi_type *)&(z))->i; \
dest[3].i = IEEE_ONE; \
-/* ASSERT(IM->Flag[IM->Count]==0); */ \
+ /*ASSERT(IM->Flag[IM->Count]==0);*/ \
if (count == IMM_MAXDATA - 1) \
_tnl_flush_immediate( NULL, IM ); \
}
#define MAX_TARGET (GL_TEXTURE0_ARB + MAX_TEXTURE_COORD_UNITS)
-#define MULTI_TEXCOORD1(target, s) \
-{ \
- GET_IMMEDIATE; \
- GLuint texunit = target - GL_TEXTURE0_ARB; \
- if (texunit < IM->MaxTextureUnits) { \
- GLuint count = IM->Count; \
- GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
- ASSIGN_4V(tc, s, 0.0F, 0.0F, 1.0F); \
- IM->Flag[count] |= VERT_BIT_TEX(texunit); \
- } \
-}
-
-#define MULTI_TEXCOORD2(target, s, t) \
-{ \
- GET_IMMEDIATE; \
- GLuint texunit = target - GL_TEXTURE0_ARB; \
- if (texunit < IM->MaxTextureUnits) { \
- GLuint count = IM->Count; \
- GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
- ASSIGN_4V(tc, s, t, 0.0F, 1.0F); \
- IM->Flag[count] |= VERT_BIT_TEX(texunit); \
- } \
+#define MULTI_TEXCOORD1(target, s) \
+{ \
+ GET_IMMEDIATE; \
+ const GLuint texunit = target - GL_TEXTURE0_ARB; \
+ if (texunit < IM->MaxTextureUnits) { \
+ const GLuint count = IM->Count; \
+ GLfloat *tc; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0 + texunit); \
+ tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
+ ASSIGN_4V(tc, s, 0.0F, 0.0F, 1.0F); \
+ IM->Flag[count] |= VERT_BIT_TEX(texunit); \
+ } \
}
-#define MULTI_TEXCOORD3(target, s, t, u) \
-{ \
- GET_IMMEDIATE; \
- GLuint texunit = target - GL_TEXTURE0_ARB; \
- if (texunit < IM->MaxTextureUnits) { \
- GLuint count = IM->Count; \
- GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
- ASSIGN_4V(tc, s, t, u, 1.0F); \
- IM->Flag[count] |= VERT_BIT_TEX(texunit); \
- IM->TexSize |= TEX_SIZE_3(texunit); \
- } \
+#define MULTI_TEXCOORD2(target, s, t) \
+{ \
+ GET_IMMEDIATE; \
+ const GLuint texunit = target - GL_TEXTURE0_ARB; \
+ if (texunit < IM->MaxTextureUnits) { \
+ const GLuint count = IM->Count; \
+ GLfloat *tc; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0 + texunit); \
+ tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
+ ASSIGN_4V(tc, s, t, 0.0F, 1.0F); \
+ IM->Flag[count] |= VERT_BIT_TEX(texunit); \
+ } \
}
-#define MULTI_TEXCOORD4(target, s, t, u, v) \
-{ \
- GET_IMMEDIATE; \
- GLuint texunit = target - GL_TEXTURE0_ARB; \
- if (texunit < IM->MaxTextureUnits) { \
- GLuint count = IM->Count; \
- GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
- ASSIGN_4V(tc, s, t, u, v); \
- IM->Flag[count] |= VERT_BIT_TEX(texunit); \
- IM->TexSize |= TEX_SIZE_4(texunit); \
- } \
+#define MULTI_TEXCOORD3(target, s, t, u) \
+{ \
+ GET_IMMEDIATE; \
+ const GLuint texunit = target - GL_TEXTURE0_ARB; \
+ if (texunit < IM->MaxTextureUnits) { \
+ const GLuint count = IM->Count; \
+ GLfloat *tc; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0 + texunit); \
+ tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
+ ASSIGN_4V(tc, s, t, u, 1.0F); \
+ IM->Flag[count] |= VERT_BIT_TEX(texunit); \
+ IM->TexSize |= TEX_SIZE_3(texunit); \
+ } \
}
-#if defined(USE_IEEE)
-#define MULTI_TEXCOORD2F(target, s, t) \
+#define MULTI_TEXCOORD4(target, s, t, u, v) \
{ \
GET_IMMEDIATE; \
- GLuint texunit = target - GL_TEXTURE0_ARB; \
+ const GLuint texunit = target - GL_TEXTURE0_ARB; \
if (texunit < IM->MaxTextureUnits) { \
- GLuint count = IM->Count; \
- fi_type *tc = (fi_type *)IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count];\
+ const GLuint count = IM->Count; \
+ GLfloat *tc; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0 + texunit); \
+ tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
+ ASSIGN_4V(tc, s, t, u, v); \
IM->Flag[count] |= VERT_BIT_TEX(texunit); \
- tc[0].i = ((fi_type *)&(s))->i; \
- tc[1].i = ((fi_type *)&(t))->i; \
- tc[2].i = 0; \
- tc[3].i = IEEE_ONE; \
+ IM->TexSize |= TEX_SIZE_4(texunit); \
} \
}
+
+#if defined(USE_IEEE)
+#define MULTI_TEXCOORD2F(target, s, t) \
+{ \
+ GET_IMMEDIATE; \
+ const GLuint texunit = target - GL_TEXTURE0_ARB; \
+ if (texunit < IM->MaxTextureUnits) { \
+ const GLuint count = IM->Count; \
+ fi_type *tc; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_TEX0 + texunit); \
+ tc = (fi_type *)IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
+ IM->Flag[count] |= VERT_BIT_TEX(texunit); \
+ tc[0].i = ((fi_type *)&(s))->i; \
+ tc[1].i = ((fi_type *)&(t))->i; \
+ tc[2].i = 0; \
+ tc[3].i = IEEE_ONE; \
+ } \
+}
#else
#define MULTI_TEXCOORD2F MULTI_TEXCOORD2
#endif
*/
#define EVALCOORD1(IM, x) \
{ \
- GLuint count = IM->Count++; \
- GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
+ const GLuint count = IM->Count++; \
+ GLfloat *dest; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_POS); \
+ dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BIT_EVAL_C1; \
ASSIGN_4V(dest, x, 0, 0, 1); \
if (count == IMM_MAXDATA-1) \
#define EVALCOORD2(IM, x, y) \
{ \
- GLuint count = IM->Count++; \
- GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
+ const GLuint count = IM->Count++; \
+ GLfloat *dest; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_POS); \
+ dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BIT_EVAL_C2; \
ASSIGN_4V(dest, x, y, 0, 1); \
if (count == IMM_MAXDATA-1) \
#define EVALPOINT1(IM, x) \
{ \
- GLuint count = IM->Count++; \
- GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
+ const GLuint count = IM->Count++; \
+ GLfloat *dest; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_POS); \
+ dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BIT_EVAL_P1; \
ASSIGN_4V(dest, x, 0, 0, 1); \
if (count == IMM_MAXDATA-1) \
#define EVALPOINT2(IM, x, y) \
{ \
- GLuint count = IM->Count++; \
- GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
+ const GLuint count = IM->Count++; \
+ GLfloat *dest; \
+ CHECK_ATTRIB_ARRAY(IM, VERT_ATTRIB_POS); \
+ dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
IM->Flag[count] |= VERT_BIT_EVAL_P2; \
ASSIGN_4V(dest, x, y, 0, 1); \
if (count == IMM_MAXDATA-1) \
static void
_tnl_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
- if (index < 16) {
+ if (index < VERT_ATTRIB_MAX) {
GET_IMMEDIATE;
const GLuint count = IM->Count;
- GLfloat *attrib = IM->Attrib[index][count];
+ GLfloat *attrib;
+ CHECK_ATTRIB_ARRAY(IM, index);
+ attrib = IM->Attrib[index][count];
ASSIGN_4V(attrib, x, y, z, w);
IM->Flag[count] |= (1 << index);
if (index == 0) {
static void
_tnl_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
{
- if (index < 16) {
+ if (index < VERT_ATTRIB_MAX) {
GET_IMMEDIATE;
const GLuint count = IM->Count;
- GLfloat *attrib = IM->Attrib[index][count];
+ GLfloat *attrib;
+ CHECK_ATTRIB_ARRAY(IM, index);
+ attrib = IM->Attrib[index][count];
COPY_4V(attrib, v);
IM->Flag[count] |= (1 << index);
if (index == 0) {
-/* $Id: t_imm_dlist.c,v 1.47 2003/03/28 01:39:05 brianp Exp $ */
+/* $Id: t_imm_dlist.c,v 1.48 2003/03/31 18:19:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint *flags = IM->Flag + IM->Start;
GLuint count = IM->Count - IM->Start;
+#if 0
+ if (!IM->Attrib[VERT_ATTRIB_NORMAL])
+ return;
+#endif
+
if (!dest) {
dest = IM->NormalLengthPtr = (GLfloat *) ALIGN_MALLOC( IMM_SIZE*sizeof(GLfloat), 32 );
if (!dest) return;
node->MaterialOrMask = im->MaterialOrMask;
node->MaterialAndMask = im->MaterialAndMask;
- if (tnl->CalcDListNormalLengths) {
+ /*
+ * XXX always allocate VERT_ATTRIB_NORMAL array now???
+ */
+ if (tnl->CalcDListNormalLengths && IM->Attrib[VERT_ATTRIB_NORMAL]) {
build_normal_lengths( im );
}
-/* $Id: t_imm_elt.c,v 1.21 2003/03/01 01:50:27 brianp Exp $ */
+/* $Id: t_imm_elt.c,v 1.22 2003/03/31 18:19:56 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint *flags = IM->Flag;
GLuint *elts = IM->Elt;
GLuint translate = ctx->Array._Enabled;
- GLuint i;
+ GLuint i, attr;
if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
_mesa_debug(ctx, "exec_array_elements %d .. %d\n", start, count);
translate |= VERT_BITS_OBJ_23;
}
+ /* Allocate destination attribute arrays if needed */
+ for (attr = 1; attr < VERT_ATTRIB_MAX; attr++) {
+ if ((translate & (1 << attr)) && !IM->Attrib[attr]) {
+ IM->Attrib[attr] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+ if (!IM->Attrib[attr]) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "vertex processing2");
+ return;
+ }
+ }
+ }
+
if (translate & VERT_BIT_NORMAL)
_tnl_trans_elt_4f( IM->Attrib[VERT_ATTRIB_NORMAL],
-/* $Id: t_imm_eval.c,v 1.28 2003/03/01 01:50:27 brianp Exp $ */
+/* $Id: t_imm_eval.c,v 1.29 2003/03/31 18:19:57 brianp Exp $ */
/*
* Mesa 3-D graphics library
GLuint req = 0;
GLuint purge_flags = 0;
GLfloat (*coord)[4] = IM->Attrib[VERT_ATTRIB_POS] + IM->CopyStart;
+ GLuint attr;
if (IM->AndFlag & VERT_BITS_EVAL_ANY)
copycount = IM->Start - IM->CopyStart; /* just copy copied vertices */
}
}
+ /* Allocate vertex attribute storage now */
+ for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
+ if ((req & (1 << attr)) && !store->Attrib[attr]) {
+ store->Attrib[attr] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+ if (!store->Attrib[attr]) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "evaluator processing");
+ return;
+ }
+ }
+ }
+
+
/* Perform the evaluations on active data elements.
*/
if (req & VERT_BIT_INDEX) {
-/* $Id: t_imm_fixup.c,v 1.41 2003/03/28 01:39:05 brianp Exp $ */
+/* $Id: t_imm_fixup.c,v 1.42 2003/03/31 18:19:57 brianp Exp $ */
/*
* Mesa 3-D graphics library
static const GLuint intro[GL_POLYGON+2] = { 0,0,2,2,0,2,2,0,2,2,0 };
void
-_tnl_fixup_4f( GLfloat data[][4], GLuint flag[], GLuint start, GLuint match )
+_tnl_fixup_4f( GLfloat data[][4], const GLuint flag[],
+ GLuint start, GLuint match )
{
GLuint i = start;
}
void
-_tnl_fixup_3f( float data[][3], GLuint flag[], GLuint start, GLuint match )
+_tnl_fixup_3f( GLfloat data[][3], const GLuint flag[],
+ GLuint start, GLuint match )
{
GLuint i = start;
-
for (;;) {
if ((flag[++i] & match) == 0) {
/* _mesa_debug(NULL, "_tnl_fixup_3f copy to %p values %f %f %f\n", */
}
void
-_tnl_fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match )
+_tnl_fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match)
{
GLuint i = start;
static void
-fixup_first_4f( GLfloat data[][4], GLuint flag[], GLuint match,
- GLuint start, GLfloat *dflt )
+fixup_first_4f( GLfloat data[][4], const GLuint flag[], GLuint match,
+ GLuint start, const GLfloat *dflt )
{
GLuint i = start-1;
match |= VERT_BIT_END_VB;
#if 0
static void
-fixup_first_3f( GLfloat data[][3], GLuint flag[], GLuint match,
- GLuint start, GLfloat *dflt )
+fixup_first_3f( GLfloat data[][3], const GLuint flag[], GLuint match,
+ GLuint start, const GLfloat *dflt )
{
GLuint i = start-1;
match |= VERT_BIT_END_VB;
#endif
static void
-fixup_first_1ui( GLuint data[], GLuint flag[], GLuint match,
- GLuint start, GLuint dflt )
+fixup_first_1ui( GLuint data[], const GLuint flag[], GLuint match,
+ GLuint start, const GLuint dflt )
{
GLuint i = start-1;
match |= VERT_BIT_END_VB;
#if 00
static void
-fixup_first_1f( GLfloat data[], GLuint flag[], GLuint match,
+fixup_first_1f( GLfloat data[], const GLuint flag[], GLuint match,
GLuint start, GLfloat dflt )
{
GLuint i = start-1;
#endif
static void
-fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
+fixup_first_1ub( GLubyte data[], const GLuint flag[], GLuint match,
GLuint start, GLubyte dflt )
{
GLuint i = start-1;
* struct at the given position according to copyMask.
*/
static void copy_from_current( GLcontext *ctx, struct immediate *IM,
- GLuint pos, GLuint copyMask )
+ GLuint pos, GLuint copyMask )
{
GLuint attrib, attribBit;
for (attrib = 0, attribBit = 1; attrib < 16; attrib++, attribBit <<= 1) {
if (copyMask & attribBit) {
+ if (!IM->Attrib[attrib]) {
+ IM->Attrib[attrib] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+ if (!IM->Attrib[attrib]) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "vertex processing3");
+ return;
+ }
+ }
COPY_4FV( IM->Attrib[attrib][pos], ctx->Current.Attrib[attrib]);
}
}
fixup = 0;
if (fixup) {
- GLuint copy = fixup & ~IM->Flag[start];
-
+ const GLuint copy = fixup & ~IM->Flag[start];
/* Equivalent to a lazy copy-from-current when setting up the
* immediate.
if (fixup & VERT_BITS_TEX_ANY) {
GLuint i;
for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
- if (fixup & VERT_BIT_TEX(i)) {
+ if ((fixup & VERT_BIT_TEX(i))) {
if (orflag & VERT_BIT_TEX(i))
_tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_TEX0 + i], IM->Flag,
start, VERT_BIT_TEX(i) );
}
}
-
- if (fixup & VERT_BIT_EDGEFLAG) {
- if (orflag & VERT_BIT_EDGEFLAG)
- _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_BIT_EDGEFLAG );
- else
- fixup_first_1ub( IM->EdgeFlag, IM->Flag, VERT_BIT_END_VB, start,
- IM->EdgeFlag[start] );
- }
-
- if (fixup & VERT_BIT_INDEX) {
- if (orflag & VERT_BIT_INDEX)
- _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_BIT_INDEX );
- else
- fixup_first_1ui( IM->Index, IM->Flag, VERT_BIT_END_VB, start,
- IM->Index[start] );
- }
-
if (fixup & VERT_BIT_COLOR0) {
if (orflag & VERT_BIT_COLOR0)
_tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_COLOR0], IM->Flag, start,
_tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag, start,
VERT_BIT_COLOR1 );
else
- fixup_first_4f( IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag, VERT_BIT_END_VB, start,
+ fixup_first_4f( IM->Attrib[VERT_ATTRIB_COLOR1], IM->Flag,
+ VERT_BIT_END_VB, start,
IM->Attrib[VERT_ATTRIB_COLOR1][start] );
}
_tnl_fixup_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag,
start, VERT_BIT_FOG );
else
- fixup_first_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag, VERT_BIT_END_VB,
+ fixup_first_4f( IM->Attrib[VERT_ATTRIB_FOG], IM->Flag,
+ VERT_BIT_END_VB,
start, IM->Attrib[VERT_ATTRIB_FOG][start] );
}
VERT_BIT_END_VB, start,
IM->Attrib[VERT_ATTRIB_NORMAL][start] );
}
+
+ if (fixup & VERT_BIT_EDGEFLAG) {
+ if (orflag & VERT_BIT_EDGEFLAG)
+ _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_BIT_EDGEFLAG );
+ else
+ fixup_first_1ub( IM->EdgeFlag, IM->Flag, VERT_BIT_END_VB, start,
+ IM->EdgeFlag[start] );
+ }
+
+ if (fixup & VERT_BIT_INDEX) {
+ if (orflag & VERT_BIT_INDEX)
+ _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_BIT_INDEX );
+ else
+ fixup_first_1ui( IM->Index, IM->Flag, VERT_BIT_END_VB, start,
+ IM->Index[start] );
+ }
+
}
/* Prune possible half-filled slot.
}
else {
GLuint copy = tnl->pipeline.inputs & (prev->CopyOrFlag|prev->Evaluated);
- GLuint flag;
+ GLuint flag, attr;
if (is_fan_like[ctx->Driver.CurrentExecPrimitive]) {
flag = ((prev->CopyOrFlag|prev->Evaluated) & VERT_BITS_FIXUP);
/* _tnl_print_vert_flags("prev copyorflag", prev->CopyOrFlag); */
/* _tnl_print_vert_flags("flag", flag); */
+ /* Allocate attribute arrays in the destination immediate struct */
+ for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
+ if ((copy & (1 << attr)) && !next->Attrib[attr]) {
+ next->Attrib[attr] = _mesa_malloc(IMM_SIZE * 4 * sizeof(GLfloat));
+ if (!next->Attrib[attr]) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "vertex processing");
+ return;
+ }
+ }
+ }
+
/* Copy whole vertices
*/
for (i = 0 ; i < count ; i++)
* struct. (Copied rows should not be evaluated twice).
*
* Note these pointers are null when inactive.
+ *
+ * XXX try to use a loop over vertex attribs here.
*/
COPY_4FV( next->Attrib[VERT_ATTRIB_POS][dst],
inputs->Obj.data[isrc] );
if (copy & VERT_BIT_NORMAL) {
-/* _mesa_debug(ctx, "copy vert norm %d to %d (%p): %f %f %f\n", */
-/* isrc, dst, */
-/* next->Normal[dst], */
-/* inputs->Normal.data[isrc][0], */
-/* inputs->Normal.data[isrc][1], */
-/* inputs->Normal.data[isrc][2]); */
- COPY_3FV( next->Attrib[VERT_ATTRIB_NORMAL][dst], inputs->Normal.data[isrc] );
+ COPY_3FV( next->Attrib[VERT_ATTRIB_NORMAL][dst],
+ inputs->Normal.data[isrc] );
}
if (copy & VERT_BIT_COLOR0)
COPY_4FV( next->Attrib[VERT_ATTRIB_COLOR0][dst],
((GLfloat (*)[4])inputs->Color.Ptr)[isrc] );
- if (copy & VERT_BIT_INDEX)
- next->Index[dst] = inputs->Index.data[isrc];
-
if (copy & VERT_BITS_TEX_ANY) {
GLuint i;
for (i = 0 ; i < prev->MaxTextureUnits ; i++) {
}
}
- /* Remaining values should be the same in the 'input' struct and the
- * original immediate.
- */
- if (copy & (VERT_BIT_ELT|VERT_BIT_EDGEFLAG|VERT_BIT_COLOR1|VERT_BIT_FOG|
- VERT_BIT_MATERIAL)) {
-
- if (prev->Flag[src] & VERT_BIT_MATERIAL)
- copy_material(next, prev, dst, src);
-
- next->Elt[dst] = prev->Elt[src];
- next->EdgeFlag[dst] = prev->EdgeFlag[src];
+ /* the rest aren't used for evaluators */
+ if (copy & VERT_BIT_COLOR1)
COPY_4FV( next->Attrib[VERT_ATTRIB_COLOR1][dst],
prev->Attrib[VERT_ATTRIB_COLOR1][src] );
+
+ if (copy & VERT_BIT_FOG)
COPY_4FV( next->Attrib[VERT_ATTRIB_FOG][dst],
prev->Attrib[VERT_ATTRIB_FOG][src] );
- }
+
+
+ if (copy & VERT_BIT_INDEX)
+ next->Index[dst] = inputs->Index.data[isrc];
+
+ if (copy & VERT_BIT_EDGEFLAG)
+ next->EdgeFlag[dst] = prev->EdgeFlag[src];
+
+ if (copy & VERT_BIT_ELT)
+ next->Elt[dst] = prev->Elt[src];
+
+ if (copy & VERT_BIT_MATERIAL)
+ if (prev->Flag[src] & VERT_BIT_MATERIAL)
+ copy_material(next, prev, dst, src);
next->Flag[dst] = flag;
next->CopyOrFlag |= prev->Flag[src] & (VERT_BITS_FIXUP|
* attributes.
*/
+#if 0
+ GLuint attr;
+ for (attr = 1; attr < VERT_ATTRIB_MAX; attr++) {
+ if (fixup & (1 << attr)) {
+ if (attr == VERT_ATTRIB_COLOR0) {
+ /* special case, darn */
+ if (IM->CopyOrFlag & VERT_BIT_COLOR0)
+ fixup_first_4f(IM->Attrib[VERT_ATTRIB_COLOR0], IM->Flag,
+ VERT_BIT_COLOR0, start,
+ ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
+ else
+ fixup &= ~VERT_BIT_COLOR0;
+ }
+ else {
+ fixup_first_4f(IM->Attrib[attr], IM->Flag,
+ 1 << attr, start, ctx->Current.Attrib[attr] );
+ }
+ }
+ }
+
+#else
if (fixup & VERT_BIT_NORMAL) {
fixup_first_4f(IM->Attrib[VERT_ATTRIB_NORMAL], IM->Flag,
VERT_BIT_NORMAL, start,
ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i] );
}
}
+#endif
if (fixup & VERT_BIT_EDGEFLAG)
fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_BIT_EDGEFLAG, start,
-
-
-
static void copy_none( TNLcontext *tnl, GLuint start, GLuint count, GLuint ovf)
{
(void) (start && ovf && tnl && count);
}
-void _tnl_upgrade_current_data( GLcontext *ctx,
- GLuint required,
- GLuint flags )
+/*
+ * Called via the VB->import_data function pointer.
+ */
+void
+_tnl_upgrade_current_data( GLcontext *ctx, GLuint required, GLuint flags )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
-/* $Id: t_imm_fixup.h,v 1.6 2001/06/04 16:09:28 keithw Exp $ */
+/* $Id: t_imm_fixup.h,v 1.7 2003/03/31 18:19:57 brianp Exp $ */
/*
* Mesa 3-D graphics library
- * Version: 3.5
+ * Version: 5.1
*
- * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
extern void _tnl_fixup_1ui( GLuint *data, GLuint flag[],
GLuint start, GLuint match );
-extern void _tnl_fixup_3f( float data[][3], GLuint flag[],
+extern void _tnl_fixup_3f( GLfloat data[][3], const GLuint flag[],
GLuint start, GLuint match );
-extern void _tnl_fixup_4f( GLfloat data[][4], GLuint flag[],
+extern void _tnl_fixup_4f( GLfloat data[][4], const GLuint flag[],
GLuint start, GLuint match );
extern void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM );
projects / mesa.git / commitdiff