From 23caf20169ac38436ee9c13914f1d6aa7cf6bb5e Mon Sep 17 00:00:00 2001 From: Keith Whitwell Date: Thu, 16 Nov 2000 21:05:34 +0000 Subject: Move the transform and lighting code to two new directories math: Provides basic matrix and vector functionality that might be useful to multiple software t&l implementations, and is used by core mesa to manage the Model, Project, etc matrices. tnl: The real transform & lighting code from core mesa, including everything from glVertex3f through vertex buffer handling, transformation, clipping, lighting and handoff to a driver for rasterization. The interfaces of these can be further tightened up, but the basic splitting up of state and code move is done. --- src/mesa/main/eval.c | 1397 +------------------------------------------------- 1 file changed, 1 insertion(+), 1396 deletions(-) (limited to 'src/mesa/main/eval.c') diff --git a/src/mesa/main/eval.c b/src/mesa/main/eval.c index 1c779eb5e3..1cb8e26d1a 100644 --- a/src/mesa/main/eval.c +++ b/src/mesa/main/eval.c @@ -1,4 +1,4 @@ -/* $Id: eval.c,v 1.14 2000/10/30 13:32:00 keithw Exp $ */ +/* $Id: eval.c,v 1.15 2000/11/16 21:05:35 keithw Exp $ */ /* * Mesa 3-D graphics library @@ -49,479 +49,9 @@ #include "mem.h" #include "mmath.h" #include "types.h" -#include "vb.h" -#include "vbcull.h" -#include "vbfill.h" -#include "vbxform.h" #endif -static GLfloat inv_tab[MAX_EVAL_ORDER]; - -/* - * Do one-time initialization for evaluators. - */ -void gl_init_eval( void ) -{ - static int init_flag = 0; - GLuint i; - - /* Compute a table of nCr (combination) values used by the - * Bernstein polynomial generator. - */ - - /* KW: precompute 1/x for useful x. - */ - if (init_flag==0) - { - for (i = 1 ; i < MAX_EVAL_ORDER ; i++) - inv_tab[i] = 1.0 / i; - } - - init_flag = 1; -} - - - -/* - * Horner scheme for Bezier curves - * - * Bezier curves can be computed via a Horner scheme. - * Horner is numerically less stable than the de Casteljau - * algorithm, but it is faster. For curves of degree n - * the complexity of Horner is O(n) and de Casteljau is O(n^2). - * Since stability is not important for displaying curve - * points I decided to use the Horner scheme. - * - * A cubic Bezier curve with control points b0, b1, b2, b3 can be - * written as - * - * (([3] [3] ) [3] ) [3] - * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3 - * - * [n] - * where s=1-t and the binomial coefficients [i]. These can - * be computed iteratively using the identity: - * - * [n] [n ] [n] - * [i] = (n-i+1)/i * [i-1] and [0] = 1 - */ - - -static void -horner_bezier_curve(const GLfloat *cp, GLfloat *out, GLfloat t, - GLuint dim, GLuint order) -{ - GLfloat s, powert; - GLuint i, k, bincoeff; - - if(order >= 2) - { - bincoeff = order-1; - s = 1.0-t; - - for(k=0; k constant curve */ - { - for(k=0; k uorder) - { - if(uorder >= 2) - { - GLfloat s, poweru; - GLuint j, k, bincoeff; - - /* Compute the control polygon for the surface-curve in u-direction */ - for(j=0; j cn defines a curve in v */ - horner_bezier_curve(cn, out, v, dim, vorder); - } - else /* vorder <= uorder */ - { - if(vorder > 1) - { - GLuint i; - - /* Compute the control polygon for the surface-curve in u-direction */ - for(i=0; i cn defines a curve in u */ - horner_bezier_curve(cn, out, u, dim, uorder); - } -} - -/* - * The direct de Casteljau algorithm is used when a point on the - * surface and the tangent directions spanning the tangent plane - * should be computed (this is needed to compute normals to the - * surface). In this case the de Casteljau algorithm approach is - * nicer because a point and the partial derivatives can be computed - * at the same time. To get the correct tangent length du and dv - * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. - * Since only the directions are needed, this scaling step is omitted. - * - * De Casteljau needs additional storage for uorder*vorder - * values in the control net cn. - */ - -static void -de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv, - GLfloat u, GLfloat v, GLuint dim, - GLuint uorder, GLuint vorder) -{ - GLfloat *dcn = cn + uorder*vorder*dim; - GLfloat us = 1.0-u, vs = 1.0-v; - GLuint h, i, j, k; - GLuint minorder = uorder < vorder ? uorder : vorder; - GLuint uinc = vorder*dim; - GLuint dcuinc = vorder; - - /* Each component is evaluated separately to save buffer space */ - /* This does not drasticaly decrease the performance of the */ - /* algorithm. If additional storage for (uorder-1)*(vorder-1) */ - /* points would be available, the components could be accessed */ - /* in the innermost loop which could lead to less cache misses. */ - -#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] -#define DCN(I, J) dcn[(I)*dcuinc+(J)] - if(minorder < 3) - { - if(uorder==vorder) - { - for(k=0; ku1; - const GLfloat du = map->du; - GLfloat (*to)[4] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) { - GLfloat u = (coord[i][0] - u1) * du; - ASSIGN_4V(to[i], 0,0,0,1); - horner_bezier_curve(map->Points, to[i], u, dimension, map->Order); - } - - dest->count = i; - dest->start = VEC_ELT(dest, GLfloat, start); - dest->size = MAX2(dest->size, dimension); - dest->flags |= dirty_flags[dimension]; - return dest; -} - - -static GLvector1ui *eval1_1ui( GLvector1ui *dest, - GLfloat coord[][4], - const GLuint *flags, - GLuint start, - struct gl_1d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - GLuint *to = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat tmp; - horner_bezier_curve(map->Points, &tmp, u, 1, map->Order); - to[i] = (GLuint) (GLint) tmp; - } - - dest->start = VEC_ELT(dest, GLuint, start); - dest->count = i; - return dest; -} - -static GLvector3f *eval1_norm( GLvector3f *dest, - GLfloat coord[][4], - GLuint *flags, /* not const */ - GLuint start, - struct gl_1d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - GLfloat (*to)[3] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) { - GLfloat u = (coord[i][0] - u1) * du; - horner_bezier_curve(map->Points, to[i], u, 3, map->Order); - flags[i+1] |= VERT_NORM; /* reset */ - } - - dest->start = VEC_ELT(dest, GLfloat, start); - dest->count = i; - return dest; -} - -static GLvector4ub *eval1_color( GLvector4ub *dest, - GLfloat coord[][4], - GLuint *flags, /* not const */ - GLuint start, - struct gl_1d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - GLubyte (*to)[4] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat fcolor[4]; - horner_bezier_curve(map->Points, fcolor, u, 4, map->Order); - FLOAT_RGBA_TO_CHAN_RGBA(to[i], fcolor); - flags[i+1] |= VERT_RGBA; /* reset */ - } - - dest->start = VEC_ELT(dest, GLubyte, start); - dest->count = i; - return dest; -} - - - - -static GLvector4f *eval2_obj_norm( GLvector4f *obj_ptr, - GLvector3f *norm_ptr, - GLfloat coord[][4], - GLuint *flags, - GLuint start, - GLuint dimension, - struct gl_2d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - const GLfloat v1 = map->v1; - const GLfloat dv = map->dv; - GLfloat (*obj)[4] = obj_ptr->data; - GLfloat (*normal)[3] = norm_ptr->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat v = (coord[i][1] - v1) * dv; - GLfloat du[4], dv[4]; - - ASSIGN_4V(obj[i], 0,0,0,1); - de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension, - map->Uorder, map->Vorder); - - CROSS3(normal[i], du, dv); - NORMALIZE_3FV(normal[i]); - flags[i+1] |= VERT_NORM; - } - - obj_ptr->start = VEC_ELT(obj_ptr, GLfloat, start); - obj_ptr->count = i; - obj_ptr->size = MAX2(obj_ptr->size, dimension); - obj_ptr->flags |= dirty_flags[dimension]; - return obj_ptr; -} - - -static GLvector4f *eval2_4f( GLvector4f *dest, - GLfloat coord[][4], - const GLuint *flags, - GLuint start, - GLuint dimension, - struct gl_2d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - const GLfloat v1 = map->v1; - const GLfloat dv = map->dv; - GLfloat (*to)[4] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat v = (coord[i][1] - v1) * dv; - horner_bezier_surf(map->Points, to[i], u, v, dimension, - map->Uorder, map->Vorder); - } - - dest->start = VEC_ELT(dest, GLfloat, start); - dest->count = i; - dest->size = MAX2(dest->size, dimension); - dest->flags |= dirty_flags[dimension]; - return dest; -} - - -static GLvector3f *eval2_norm( GLvector3f *dest, - GLfloat coord[][4], - GLuint *flags, - GLuint start, - struct gl_2d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - const GLfloat v1 = map->v1; - const GLfloat dv = map->dv; - GLfloat (*to)[3] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat v = (coord[i][1] - v1) * dv; - horner_bezier_surf(map->Points, to[i], u, v, 3, - map->Uorder, map->Vorder); - flags[i+1] |= VERT_NORM; /* reset */ - } - - dest->start = VEC_ELT(dest, GLfloat, start); - dest->count = i; - return dest; -} - - -static GLvector1ui *eval2_1ui( GLvector1ui *dest, - GLfloat coord[][4], - const GLuint *flags, - GLuint start, - struct gl_2d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - const GLfloat v1 = map->v1; - const GLfloat dv = map->dv; - GLuint *to = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat v = (coord[i][1] - v1) * dv; - GLfloat tmp; - horner_bezier_surf(map->Points, &tmp, u, v, 1, - map->Uorder, map->Vorder); - - to[i] = (GLuint) (GLint) tmp; - } - - dest->start = VEC_ELT(dest, GLuint, start); - dest->count = i; - return dest; -} - - - -static GLvector4ub *eval2_color( GLvector4ub *dest, - GLfloat coord[][4], - GLuint *flags, - GLuint start, - struct gl_2d_map *map ) -{ - const GLfloat u1 = map->u1; - const GLfloat du = map->du; - const GLfloat v1 = map->v1; - const GLfloat dv = map->dv; - GLubyte (*to)[4] = dest->data; - GLuint i; - - for (i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) { - GLfloat u = (coord[i][0] - u1) * du; - GLfloat v = (coord[i][1] - v1) * dv; - GLfloat fcolor[4]; - horner_bezier_surf(map->Points, fcolor, u, v, 4, - map->Uorder, map->Vorder); - FLOAT_RGBA_TO_CHAN_RGBA(to[i], fcolor); - flags[i+1] |= VERT_RGBA; /* reset */ - } - - dest->start = VEC_ELT(dest, GLubyte, start); - dest->count = i; - return dest; -} - - -static GLvector4f *copy_4f( GLvector4f *out, CONST GLvector4f *in, - const GLuint *flags, - GLuint start ) -{ - GLfloat (*to)[4] = out->data; - GLfloat (*from)[4] = in->data; - GLuint i; - - for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (!(flags[i] & VERT_EVAL_ANY)) - COPY_4FV( to[i], from[i] ); - - out->start = VEC_ELT(out, GLfloat, start); - return out; -} - -static GLvector3f *copy_3f( GLvector3f *out, CONST GLvector3f *in, - const GLuint *flags, - GLuint start ) -{ - GLfloat (*to)[3] = out->data; - GLfloat (*from)[3] = in->data; - GLuint i; - - for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (!(flags[i] & VERT_EVAL_ANY)) - COPY_3V( to[i], from[i] ); - - out->start = VEC_ELT(out, GLfloat, start); - return out; -} - -static GLvector4ub *copy_4ub( GLvector4ub *out, - CONST GLvector4ub *in, - const GLuint *flags, - GLuint start ) -{ - GLubyte (*to)[4] = out->data; - GLubyte (*from)[4] = in->data; - GLuint i; - - for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (!(flags[i] & VERT_EVAL_ANY)) - COPY_4UBV( to[i], from[i] ); - - out->start = VEC_ELT(out, GLubyte, start); - return out; -} - -static GLvector1ui *copy_1ui( GLvector1ui *out, - CONST GLvector1ui *in, - const GLuint *flags, - GLuint start ) -{ - GLuint *to = out->data; - CONST GLuint *from = in->data; - GLuint i; - - for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) - if (!(flags[i] & VERT_EVAL_ANY)) - to[i] = from[i]; - - out->start = VEC_ELT(out, GLuint, start); - return out; -} - - -/* KW: Rewrote this to perform eval on a whole buffer at once. - * Only evaluates active data items, and avoids scribbling - * the source buffer if we are running from a display list. - * - * If the user (in this case looser) sends eval coordinates - * or runs a display list containing eval coords with no - * vertex maps enabled, we have to either copy all non-eval - * data to a new buffer, or find a way of working around - * the eval data. I choose the second option. - * - * KW: This code not reached by cva - use IM to access storage. - */ -void gl_eval_vb( struct vertex_buffer *VB ) -{ - struct immediate *IM = VB->IM; - GLcontext *ctx = VB->ctx; - GLuint req = ctx->CVA.elt.inputs; - GLfloat (*coord)[4] = VB->ObjPtr->data; - GLuint *flags = VB->Flag; - GLuint new_flags = 0; - - - GLuint any_eval1 = VB->OrFlag & (VERT_EVAL_C1|VERT_EVAL_P1); - GLuint any_eval2 = VB->OrFlag & (VERT_EVAL_C2|VERT_EVAL_P2); - GLuint all_eval = IM->AndFlag & VERT_EVAL_ANY; - - /* Handle the degenerate cases. - */ - if (any_eval1 && !ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) { - VB->PurgeFlags |= (VERT_EVAL_C1|VERT_EVAL_P1); - VB->EarlyCull = 0; - any_eval1 = GL_FALSE; - } - - if (any_eval2 && !ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) { - VB->PurgeFlags |= (VERT_EVAL_C2|VERT_EVAL_P2); - VB->EarlyCull = 0; - any_eval2 = GL_FALSE; - } - - /* KW: This really is a degenerate case - doing this disables - * culling, and causes dummy values for the missing vertices to be - * transformed and clip tested. It also forces the individual - * cliptesting of each primitive in vb_render. I wish there was a - * nice alternative, but I can't say I want to put effort into - * optimizing such a bad usage of the library - I'd much rather - * work on useful changes. - */ - if (VB->PurgeFlags) { - if (!any_eval1 && !any_eval2 && all_eval) VB->Count = VB->Start; - gl_purge_vertices( VB ); - if (!any_eval1 && !any_eval2) return; - } else - VB->IndirectCount = VB->Count; - - /* Translate points into coords. - */ - if (any_eval1 && (VB->OrFlag & VERT_EVAL_P1)) - { - eval_points1( IM->Obj, coord, flags, IM->Start, - ctx->Eval.MapGrid1du, - ctx->Eval.MapGrid1u1); - - coord = IM->Obj; - } - - if (any_eval2 && (VB->OrFlag & VERT_EVAL_P2)) - { - eval_points2( IM->Obj, coord, flags, IM->Start, - ctx->Eval.MapGrid2du, - ctx->Eval.MapGrid2u1, - ctx->Eval.MapGrid2dv, - ctx->Eval.MapGrid2v1 ); - - coord = IM->Obj; - } - - /* Perform the evaluations on active data elements. - */ - if (req & VERT_INDEX) - { - GLvector1ui *in_index = VB->IndexPtr; - GLvector1ui *out_index = &IM->v.Index; - - if (ctx->Eval.Map1Index && any_eval1) - VB->IndexPtr = eval1_1ui( out_index, coord, flags, IM->Start, - &ctx->EvalMap.Map1Index ); - - if (ctx->Eval.Map2Index && any_eval2) - VB->IndexPtr = eval2_1ui( out_index, coord, flags, IM->Start, - &ctx->EvalMap.Map2Index ); - - if (VB->IndexPtr != in_index) { - new_flags |= VERT_INDEX; - if (!all_eval) - VB->IndexPtr = copy_1ui( out_index, in_index, flags, IM->Start ); - } - } - - if (req & VERT_RGBA) - { - GLvector4ub *in_color = VB->ColorPtr; - GLvector4ub *out_color = &IM->v.Color; - - if (ctx->Eval.Map1Color4 && any_eval1) - VB->ColorPtr = eval1_color( out_color, coord, flags, IM->Start, - &ctx->EvalMap.Map1Color4 ); - - if (ctx->Eval.Map2Color4 && any_eval2) - VB->ColorPtr = eval2_color( out_color, coord, flags, IM->Start, - &ctx->EvalMap.Map2Color4 ); - - if (VB->ColorPtr != in_color) { - new_flags |= VERT_RGBA; - if (!all_eval) - VB->ColorPtr = copy_4ub( out_color, in_color, flags, IM->Start ); - } - - VB->Color[0] = VB->Color[1] = VB->ColorPtr; - } - - - if (req & VERT_NORM) - { - GLvector3f *in_normal = VB->NormalPtr; - GLvector3f *out_normal = &IM->v.Normal; - - if (ctx->Eval.Map1Normal && any_eval1) - VB->NormalPtr = eval1_norm( out_normal, coord, flags, IM->Start, - &ctx->EvalMap.Map1Normal ); - - if (ctx->Eval.Map2Normal && any_eval2) - VB->NormalPtr = eval2_norm( out_normal, coord, flags, IM->Start, - &ctx->EvalMap.Map2Normal ); - - new_flags |= VERT_NORM; - - if (VB->NormalPtr != in_normal) { - if (!all_eval) - VB->NormalPtr = copy_3f( out_normal, in_normal, flags, IM->Start ); - } - } - - - if (req & VERT_TEX_ANY(0)) - { - GLvector4f *tc = VB->TexCoordPtr[0]; - GLvector4f *in = tc; - GLvector4f *out = &IM->v.TexCoord[0]; - - if (any_eval1) { - if (ctx->Eval.Map1TextureCoord4) - tc = eval1_4f( out, coord, flags, IM->Start, - 4, &ctx->EvalMap.Map1Texture4); - else if (ctx->Eval.Map1TextureCoord3) - tc = eval1_4f( out, coord, flags, IM->Start, 3, - &ctx->EvalMap.Map1Texture3); - else if (ctx->Eval.Map1TextureCoord2) - tc = eval1_4f( out, coord, flags, IM->Start, 2, - &ctx->EvalMap.Map1Texture2); - else if (ctx->Eval.Map1TextureCoord1) - tc = eval1_4f( out, coord, flags, IM->Start, 1, - &ctx->EvalMap.Map1Texture1); - } - - if (any_eval2) { - if (ctx->Eval.Map2TextureCoord4) - tc = eval2_4f( out, coord, flags, IM->Start, - 4, &ctx->EvalMap.Map2Texture4); - else if (ctx->Eval.Map2TextureCoord3) - tc = eval2_4f( out, coord, flags, IM->Start, - 3, &ctx->EvalMap.Map2Texture3); - else if (ctx->Eval.Map2TextureCoord2) - tc = eval2_4f( out, coord, flags, IM->Start, - 2, &ctx->EvalMap.Map2Texture2); - else if (ctx->Eval.Map2TextureCoord1) - tc = eval2_4f( out, coord, flags, IM->Start, - 1, &ctx->EvalMap.Map2Texture1); - } - - if (tc != in) { - new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */ - if (!all_eval) - tc = copy_4f( out, in, flags, IM->Start ); - } - - VB->TexCoordPtr[0] = tc; - } - - - { - GLvector4f *in = VB->ObjPtr; - GLvector4f *out = &IM->v.Obj; - GLvector4f *obj = in; - - if (any_eval1) { - if (ctx->Eval.Map1Vertex4) - obj = eval1_4f( out, coord, flags, IM->Start, - 4, &ctx->EvalMap.Map1Vertex4); - else - obj = eval1_4f( out, coord, flags, IM->Start, - 3, &ctx->EvalMap.Map1Vertex3); - } - - if (any_eval2) { - GLvector3f *in_normal = VB->NormalPtr; - GLvector3f *out_normal = &IM->v.Normal; - - if (ctx->Eval.Map2Vertex4) - { - if (ctx->Eval.AutoNormal && (req & VERT_NORM)) { - obj = eval2_obj_norm( out, out_normal, coord, flags, - IM->Start, 4, &ctx->EvalMap.Map2Vertex4 ); - VB->NormalPtr = out_normal; - new_flags |= VERT_NORM; - } - else - obj = eval2_4f( out, coord, flags, IM->Start, - 4, &ctx->EvalMap.Map2Vertex4 ); - } - else if (ctx->Eval.Map2Vertex3) - { - if (ctx->Eval.AutoNormal && (req & VERT_NORM)) { - obj = eval2_obj_norm( out, out_normal, coord, flags, - IM->Start, 3, &ctx->EvalMap.Map2Vertex3 ); - VB->NormalPtr = out_normal; - new_flags |= VERT_NORM; - } - else - obj = eval2_4f( out, coord, flags, IM->Start, - 3, &ctx->EvalMap.Map2Vertex3 ); - } - - - if (VB->NormalPtr != in_normal) { - if (!all_eval) - VB->NormalPtr = copy_3f( out_normal, in_normal, flags, - IM->Start ); - } - } - - if (obj != in && !all_eval) - obj = copy_4f( out, in, flags, IM->Start ); - - VB->ObjPtr = obj; - } - - if (new_flags) { - GLuint *oldflags = VB->Flag; - GLuint *flags = VB->Flag = VB->EvaluatedFlags; - GLuint i; - GLuint count = VB->Count; - GLuint andflag = VB->IM->AndFlag; - - if (!flags) { - VB->EvaluatedFlags = (GLuint *) MALLOC(VB->Size * sizeof(GLuint)); - flags = VB->Flag = VB->EvaluatedFlags; - } - - if (all_eval) { - for (i = 0 ; i <= count ; i++) - flags[i] = oldflags[i] | new_flags; - andflag |= new_flags; - } else { - andflag = ~0; - for (i = 0 ; i <= count ; i++) { - flags[i] = oldflags[i]; - if (flags[i] & VERT_EVAL_ANY) - flags[i] |= new_flags; - andflag &= flags[i]; - } - } - - VB->OrFlag |= new_flags; - VB->CullMode = (GLubyte) ((andflag & VERT_NORM) ? 0 : COMPACTED_NORMALS); - } -} - - void _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) { @@ -2694,279 +1574,4 @@ _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2, -/* KW: If are compiling, we don't know whether eval will produce a - * vertex when it is run in the future. If this is pure immediate - * mode, eval is a noop if neither vertex map is enabled. - * - * Thus we need to have a check in the display list code or - * elsewhere for eval(1,2) vertices in the case where - * map(1,2)_vertex is disabled, and to purge those vertices from - * the vb. This is currently done - * via modifications to the cull_vb and render_vb operations, and - * by using the existing cullmask mechanism for all other operations. - */ - - -/* KW: Because the eval values don't become 'current', fixup will flow - * through these vertices, and then evaluation will write on top - * of the fixup results. - * - * This is a little inefficient, but at least it is correct. This - * could be short-circuited in the case where all vertices are - * eval-vertices, or more generally by a cullmask in fixup. - * - * Note: using Obj to hold eval coord data. This data is actually - * transformed if eval is disabled. But disabling eval & sending - * eval coords is stupid, right? - */ - - -#define EVALCOORD1(IM, x) \ -{ \ - GLuint count = IM->Count++; \ - IM->Flag[count] |= VERT_EVAL_C1; \ - ASSIGN_4V(IM->Obj[count], x, 0, 0, 1); \ - if (count == VB_MAX-1) \ - _mesa_maybe_transform_vb( IM ); \ -} - -#define EVALCOORD2(IM, x, y) \ -{ \ - GLuint count = IM->Count++; \ - IM->Flag[count] |= VERT_EVAL_C2; \ - ASSIGN_4V(IM->Obj[count], x, y, 0, 1); \ - if (count == VB_MAX-1) \ - _mesa_maybe_transform_vb( IM ); \ -} - -#define EVALPOINT1(IM, x) \ -{ \ - GLuint count = IM->Count++; \ - IM->Flag[count] |= VERT_EVAL_P1; \ - ASSIGN_4V(IM->Obj[count], x, 0, 0, 1); \ - if (count == VB_MAX-1) \ - _mesa_maybe_transform_vb( IM ); \ -} - -#define EVALPOINT2(IM, x, y) \ -{ \ - GLuint count = IM->Count++; \ - IM->Flag[count] |= VERT_EVAL_P2; \ - ASSIGN_4V(IM->Obj[count], x, y, 0, 1); \ - if (count == VB_MAX-1) \ - _mesa_maybe_transform_vb( IM ); \ -} - - -/* Lame internal function: - */ -static void -eval_coord1f( GLcontext *CC, GLfloat u ) -{ - struct immediate *i = CC->input; - EVALCOORD1( i, u ); -} - - -void -_mesa_EvalCoord1d( GLdouble u ) -{ - GET_IMMEDIATE; - EVALCOORD1( IM, (GLfloat) u ); -} - - -void -_mesa_EvalCoord1f( GLfloat u ) -{ - GET_IMMEDIATE; - EVALCOORD1( IM, u ); -} - - -void -_mesa_EvalCoord1dv( const GLdouble *u ) -{ - GET_IMMEDIATE; - EVALCOORD1( IM, (GLfloat) *u ); -} - - -void -_mesa_EvalCoord1fv( const GLfloat *u ) -{ - GET_IMMEDIATE; - EVALCOORD1( IM, (GLfloat) *u ); -} - - -void -_mesa_EvalCoord2d( GLdouble u, GLdouble v ) -{ - GET_IMMEDIATE; - EVALCOORD2( IM, (GLfloat) u, (GLfloat) v ); -} - - -void -_mesa_EvalCoord2f( GLfloat u, GLfloat v ) -{ - GET_IMMEDIATE; - EVALCOORD2( IM, u, v ); -} - - -/* Lame internal function: - */ -static void -eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v ) -{ - struct immediate *i = CC->input; - EVALCOORD2( i, u, v ); -} - - -void -_mesa_EvalCoord2dv( const GLdouble *u ) -{ - GET_IMMEDIATE; - EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] ); -} - - -void -_mesa_EvalCoord2fv( const GLfloat *u ) -{ - GET_IMMEDIATE; - EVALCOORD2( IM, u[0], u[1] ); -} - - -void -_mesa_EvalPoint1( GLint i ) -{ - GET_IMMEDIATE; - EVALPOINT1( IM, i ); -} - - -void -_mesa_EvalPoint2( GLint i, GLint j ) -{ - GET_IMMEDIATE; - EVALPOINT2( IM, i, j ); -} - - - - -void -_mesa_EvalMesh1( GLenum mode, GLint i1, GLint i2 ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint i; - GLfloat u, du; - GLenum prim; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh1"); - - switch (mode) { - case GL_POINT: - prim = GL_POINTS; - break; - case GL_LINE: - prim = GL_LINE_STRIP; - break; - default: - gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" ); - return; - } - - /* No effect if vertex maps disabled. - */ - if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) - return; - - du = ctx->Eval.MapGrid1du; - u = ctx->Eval.MapGrid1u1 + i1 * du; - - /* KW: Could short-circuit this to avoid the immediate mechanism. - */ - RESET_IMMEDIATE(ctx); - - gl_Begin( ctx, prim ); - for (i=i1;i<=i2;i++,u+=du) { - eval_coord1f( ctx, u ); - } - gl_End(ctx); -} - - - -void -_mesa_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) -{ - GET_CURRENT_CONTEXT(ctx); - GLint i, j; - GLfloat u, du, v, dv, v1, u1; - - ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh2"); - - /* No effect if vertex maps disabled. - */ - if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) - return; - - du = ctx->Eval.MapGrid2du; - dv = ctx->Eval.MapGrid2dv; - v1 = ctx->Eval.MapGrid2v1 + j1 * dv; - u1 = ctx->Eval.MapGrid2u1 + i1 * du; - - RESET_IMMEDIATE(ctx); - - switch (mode) { - case GL_POINT: - gl_Begin( ctx, GL_POINTS ); - for (v=v1,j=j1;j<=j2;j++,v+=dv) { - for (u=u1,i=i1;i<=i2;i++,u+=du) { - eval_coord2f( ctx, u, v ); - } - } - gl_End(ctx); - break; - case GL_LINE: - for (v=v1,j=j1;j<=j2;j++,v+=dv) { - gl_Begin( ctx, GL_LINE_STRIP ); - for (u=u1,i=i1;i<=i2;i++,u+=du) { - eval_coord2f( ctx, u, v ); - } - gl_End(ctx); - } - for (u=u1,i=i1;i<=i2;i++,u+=du) { - gl_Begin( ctx, GL_LINE_STRIP ); - for (v=v1,j=j1;j<=j2;j++,v+=dv) { - eval_coord2f( ctx, u, v ); - } - gl_End(ctx); - } - break; - case GL_FILL: - for (v=v1,j=j1;j