Cleanup of derived state calculation prior to seperating software T&L

into a new directory.  Specifically the handling of changes to lighting
lighting space (light in model vs. light in eye) have been revamped.

Moved several derived values used only by swrast into that directory.

Removed direct calls to swrast_flush() from vbrender.c -- pushed into
ctx->Driver.RenderFinish.

Optimized flat-shading case in swrast_setup.

src/mesa/drivers/glide/fxdd.c

@@ -766,6 +766,10 @@ int fxDDInitFxMesaContext( fxMesaContext fxMesa )
    _swrast_CreateContext( fxMesa->glCtx );
    _swsetup_CreateContext( fxMesa->glCtx );
 
+   /* Tell the software rasterizer to use pixel fog always.
+    */
+   _swrast_allow_vertex_fog( fxMesa->glCtx, GL_FALSE );
+   _swrast_allow_pixel_fog( fxMesa->glCtx, GL_TRUE );
 
    fxSetupDDPointers(fxMesa->glCtx);
    fxDDInitExtensions(fxMesa->glCtx);  
@@ -992,7 +996,7 @@ void fxSetupDDPointers(GLcontext *ctx)
   ctx->Driver.Flush=NULL;
 
   ctx->Driver.RenderStart=NULL;
-  ctx->Driver.RenderFinish=NULL;
+  ctx->Driver.RenderFinish=_swrast_flush;
 
   ctx->Driver.TexImage2D = fxDDTexImage2D;
   ctx->Driver.TexSubImage2D = fxDDTexSubImage2D;

src/mesa/drivers/x11/xm_dd.c

@@ -1,4 +1,4 @@
-/* $Id: xm_dd.c,v 1.3 2000/11/05 18:26:12 keithw Exp $ */
+/* $Id: xm_dd.c,v 1.4 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -947,7 +947,7 @@ void xmesa_init_pointers( GLcontext *ctx )
    ctx->Driver.Finish = finish;
    
    ctx->Driver.RenderStart = 0;
-   ctx->Driver.RenderFinish = 0;
+   ctx->Driver.RenderFinish = _swrast_flush;
 
    ctx->Driver.SetDrawBuffer = set_draw_buffer;
    ctx->Driver.SetReadBuffer = set_read_buffer;

src/mesa/main/buffers.c

@@ -1,4 +1,4 @@
-/* $Id: buffers.c,v 1.18 2000/10/31 18:09:44 keithw Exp $ */
+/* $Id: buffers.c,v 1.19 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -98,14 +98,14 @@ _mesa_Clear( GLbitfield mask )
       fprintf(stderr, "glClear 0x%x\n", mask);
 
    if (ctx->NewState) {
-      gl_update_state( ctx );
+      gl_update_state( ctx );	/* update _Xmin, etc */
    }
 
    if (ctx->RenderMode==GL_RENDER) {
-      const GLint x = ctx->DrawBuffer->Xmin;
-      const GLint y = ctx->DrawBuffer->Ymin;
-      const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
-      const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+      const GLint x = ctx->DrawBuffer->_Xmin;
+      const GLint y = ctx->DrawBuffer->_Ymin;
+      const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+      const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
       GLbitfield ddMask;
       GLbitfield newMask;
 

src/mesa/main/clip.c

@@ -1,4 +1,4 @@
-/* $Id: clip.c,v 1.13 2000/11/05 18:40:57 keithw Exp $ */
+/* $Id: clip.c,v 1.14 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -215,19 +215,6 @@ _mesa_ClipPlane( GLenum plane, const GLdouble *eq )
 }
 
 
-void gl_update_userclip( GLcontext *ctx )
-{
-   GLuint p;
-   
-   for (p = 0 ; p < MAX_CLIP_PLANES ; p++) {
-      if (ctx->Transform.ClipEnabled[p]) {
-	 gl_transform_vector( ctx->Transform._ClipUserPlane[p],
-			      ctx->Transform.EyeUserPlane[p],
-			      ctx->ProjectionMatrix.inv );
-      }
-   }
-}
-
 void
 _mesa_GetClipPlane( GLenum plane, GLdouble *equation )
 {

src/mesa/main/context.c

@@ -1,4 +1,4 @@
-/* $Id: context.c,v 1.103 2000/11/05 18:40:57 keithw Exp $ */
+/* $Id: context.c,v 1.104 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -1308,10 +1308,6 @@ init_attrib_groups( GLcontext *ctx )
    ctx->Select.Hits = 0;
    ctx->Select.NameStackDepth = 0;
 
-   /* Optimized Accum buffer */
-   ctx->IntegerAccumMode = GL_TRUE;
-   ctx->IntegerAccumScaler = 0.0;
-
    /* Renderer and client attribute stacks */
    ctx->AttribStackDepth = 0;
    ctx->ClientAttribStackDepth = 0;
@@ -1336,12 +1332,11 @@ init_attrib_groups( GLcontext *ctx )
    /* Miscellaneous */
    ctx->NewState = _NEW_ALL;
    ctx->RenderMode = GL_RENDER;
-   ctx->_NeedNormals = GL_FALSE;
    ctx->_ImageTransferState = 0;
 
-   ctx->_NeedEyeCoords = GL_FALSE;
-   ctx->_NeedEyeNormals = GL_FALSE;
-   ctx->_vb_proj_matrix = &ctx->_ModelProjectMatrix;
+   ctx->_NeedNormals = 0;
+   ctx->_NeedEyeCoords = 0;
+   ctx->_ModelViewInvScale = 1.0;
 
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
 

src/mesa/main/dd.h

@@ -1,4 +1,4 @@
-/* $Id: dd.h,v 1.39 2000/11/10 17:36:42 brianp Exp $ */
+/* $Id: dd.h,v 1.40 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -799,13 +799,6 @@ struct dd_function_table {
     * gl_render_vb() function in vbrender.c for more details.  
     */
 
-   void (*ReducedPrimitiveChange)( GLcontext *ctx, GLenum primitive );
-   /* If registered, this will be called when rendering transitions between
-    * points, lines and triangles.  It is not called on transitions between 
-    * primtives such as GL_TRIANGLES and GL_TRIANGLE_STRIPS, or between
-    * triangles and quads or triangles and polygons.
-    */
-
    GLboolean (*MultipassFunc)( struct vertex_buffer *VB, GLuint passno );
    /* Driver may request additional render passes by returning GL_TRUE
     * when this function is called.  This function will be called
@@ -819,6 +812,11 @@ struct dd_function_table {
    /***
     *** NEW in Mesa 3.x
     ***/
+   void (*LightingSpaceChange)( GLcontext *ctx );
+   /* Notify driver that the special derived value _NeedEyeCoords has
+    * changed.  
+    */
+   
 
    void (*RegisterVB)( struct vertex_buffer *VB );
    void (*UnregisterVB)( struct vertex_buffer *VB );
@@ -890,7 +888,7 @@ struct dd_function_table {
    void (*Hint)(GLcontext *ctx, GLenum target, GLenum mode);
    void (*IndexMask)(GLcontext *ctx, GLuint mask);
    void (*Lightfv)(GLcontext *ctx, GLenum light,
-		   GLenum pname, const GLfloat *params, GLint nparams );
+		   GLenum pname, const GLfloat *params );
    void (*LightModelfv)(GLcontext *ctx, GLenum pname, const GLfloat *params);
    void (*LineStipple)(GLcontext *ctx, GLint factor, GLushort pattern );
    void (*LineWidth)(GLcontext *ctx, GLfloat width);

src/mesa/main/light.c

@@ -1,4 +1,4 @@
-/* $Id: light.c,v 1.23 2000/11/05 18:40:58 keithw Exp $ */
+/* $Id: light.c,v 1.24 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -91,93 +91,85 @@ void
 _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLint l;
-   GLint nParams;
+   GLint i = (GLint) (light - GL_LIGHT0);
+   struct gl_light *l = &ctx->Light.Light[i];
 
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLight");
 
-   l = (GLint) (light - GL_LIGHT0);
-
-   if (l < 0 || l >= MAX_LIGHTS) {
+   if (i < 0 || i >= MAX_LIGHTS) {
       gl_error( ctx, GL_INVALID_ENUM, "glLight" );
       return;
    }
 
    switch (pname) {
       case GL_AMBIENT:
-         COPY_4V( ctx->Light.Light[l].Ambient, params );
-         nParams = 4;
+         COPY_4V( l->Ambient, params );
          break;
       case GL_DIFFUSE:
-         COPY_4V( ctx->Light.Light[l].Diffuse, params );
-         nParams = 4;
+         COPY_4V( l->Diffuse, params );
          break;
       case GL_SPECULAR:
-         COPY_4V( ctx->Light.Light[l].Specular, params );
-         nParams = 4;
+         COPY_4V( l->Specular, params );
          break;
       case GL_POSITION:
 	 /* transform position by ModelView matrix */
-	 TRANSFORM_POINT( ctx->Light.Light[l].EyePosition, 
-			  ctx->ModelView.m,
-                          params );
-         nParams = 4;
+	 TRANSFORM_POINT( l->EyePosition, ctx->ModelView.m, params );
+	 if (l->EyePosition[3] != 0.0F) 
+	    l->_Flags |= LIGHT_POSITIONAL;
+	 else
+	    l->_Flags &= ~LIGHT_POSITIONAL;
          break;
       case GL_SPOT_DIRECTION:
 	 /* transform direction by inverse modelview */
 	 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
 	    gl_matrix_analyze( &ctx->ModelView );
 	 }
-	 TRANSFORM_NORMAL( ctx->Light.Light[l].EyeDirection,
-			   params,
-			   ctx->ModelView.inv );
-         nParams = 3;
+	 TRANSFORM_NORMAL( l->EyeDirection, params, ctx->ModelView.inv );
          break;
       case GL_SPOT_EXPONENT:
          if (params[0]<0.0 || params[0]>128.0) {
             gl_error( ctx, GL_INVALID_VALUE, "glLight" );
             return;
          }
-         if (ctx->Light.Light[l].SpotExponent != params[0]) {
-            ctx->Light.Light[l].SpotExponent = params[0];
-            gl_compute_spot_exp_table( &ctx->Light.Light[l] );
+         if (l->SpotExponent != params[0]) {
+            l->SpotExponent = params[0];
+            gl_compute_spot_exp_table( l );
          }
-         nParams = 1;
          break;
       case GL_SPOT_CUTOFF:
          if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
             gl_error( ctx, GL_INVALID_VALUE, "glLight" );
             return;
          }
-         ctx->Light.Light[l].SpotCutoff = params[0];
-         ctx->Light.Light[l]._CosCutoff = cos(params[0]*DEG2RAD);
-         if (ctx->Light.Light[l]._CosCutoff < 0) 
-	    ctx->Light.Light[l]._CosCutoff = 0;
-         nParams = 1;
+         l->SpotCutoff = params[0];
+         l->_CosCutoff = cos(params[0]*DEG2RAD);
+         if (l->_CosCutoff < 0) 
+	    l->_CosCutoff = 0;
+	 if (l->SpotCutoff != 180.0F)
+	    l->_Flags |= LIGHT_SPOT;
+	 else
+	    l->_Flags &= ~LIGHT_SPOT;
          break;
       case GL_CONSTANT_ATTENUATION:
          if (params[0]<0.0) {
             gl_error( ctx, GL_INVALID_VALUE, "glLight" );
             return;
          }
-         ctx->Light.Light[l].ConstantAttenuation = params[0];
-         nParams = 1;
+         l->ConstantAttenuation = params[0];
          break;
       case GL_LINEAR_ATTENUATION:
          if (params[0]<0.0) {
             gl_error( ctx, GL_INVALID_VALUE, "glLight" );
             return;
          }
-         ctx->Light.Light[l].LinearAttenuation = params[0];
-         nParams = 1;
+         l->LinearAttenuation = params[0];
          break;
       case GL_QUADRATIC_ATTENUATION:
          if (params[0]<0.0) {
             gl_error( ctx, GL_INVALID_VALUE, "glLight" );
             return;
          }
-         ctx->Light.Light[l].QuadraticAttenuation = params[0];
-         nParams = 1;
+         l->QuadraticAttenuation = params[0];
          break;
       default:
          gl_error( ctx, GL_INVALID_ENUM, "glLight" );
@@ -185,7 +177,7 @@ _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
    }
 
    if (ctx->Driver.Lightfv)
-      ctx->Driver.Lightfv( ctx, light, pname, params, nParams );
+      ctx->Driver.Lightfv( ctx, light, pname, params );
 
    ctx->NewState |= _NEW_LIGHT;
 }
@@ -612,11 +604,9 @@ void gl_update_material( GLcontext *ctx,
       GLfloat tmp[4];
       SUB_3V( tmp, src[0].Specular, mat->Specular );
       foreach (light, list) {
-	 if (light->_Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, tmp );
-	    light->_IsMatSpecular[0] = 
-	       (LEN_SQUARED_3FV(light->_MatSpecular[0]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, tmp );
+	 light->_IsMatSpecular[0] = 
+	    (LEN_SQUARED_3FV(light->_MatSpecular[0]) > 1e-16);
       }
       COPY_4FV( mat->Specular, src[0].Specular );
    }
@@ -625,11 +615,9 @@ void gl_update_material( GLcontext *ctx,
       GLfloat tmp[4];
       SUB_3V( tmp, src[1].Specular, mat->Specular );
       foreach (light, list) {
-	 if (light->_Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, tmp );
-	    light->_IsMatSpecular[1] = 
-	       (LEN_SQUARED_3FV(light->_MatSpecular[1]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, tmp );
+	 light->_IsMatSpecular[1] = 
+	    (LEN_SQUARED_3FV(light->_MatSpecular[1]) > 1e-16);
       }
       COPY_4FV( mat->Specular, src[1].Specular );
    }
@@ -771,11 +759,9 @@ void gl_update_color_material( GLcontext *ctx,
       GLfloat tmp[4];
       SUB_3V( tmp, color, mat->Specular );
       foreach (light, list) {
-	 if (light->_Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, tmp );
-	    light->_IsMatSpecular[0] = 
-	       (LEN_SQUARED_3FV(light->_MatSpecular[0]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, tmp );
+	 light->_IsMatSpecular[0] = 
+	    (LEN_SQUARED_3FV(light->_MatSpecular[0]) > 1e-16);
       }
       COPY_4FV( mat->Specular, color );
    }
@@ -785,11 +771,9 @@ void gl_update_color_material( GLcontext *ctx,
       GLfloat tmp[4];
       SUB_3V( tmp, color, mat->Specular );
       foreach (light, list) {
-	 if (light->_Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, tmp );
-	    light->_IsMatSpecular[1] = 
-	       (LEN_SQUARED_3FV(light->_MatSpecular[1]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, tmp );
+	 light->_IsMatSpecular[1] = 
+	    (LEN_SQUARED_3FV(light->_MatSpecular[1]) > 1e-16);
       }
       COPY_4FV( mat->Specular, color );
    }
@@ -1225,35 +1209,45 @@ void
 gl_update_lighting( GLcontext *ctx )
 {
    struct gl_light *light;
-
+   ctx->_TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
+   ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT;
+   ctx->_NeedNormals &= ~NEED_NORMALS_LIGHT;
    ctx->Light._Flags = 0;
+   
+   if (!ctx->Light.Enabled) 
+      return;
 
-   foreach(light, &ctx->Light.EnabledList) {
-
-      light->_Flags = 0;
+   ctx->_NeedNormals |= NEED_NORMALS_LIGHT;
 
-      if (light->EyePosition[3] != 0.0F) 
-	 light->_Flags |= LIGHT_POSITIONAL;
-      
-      if (LEN_SQUARED_3FV(light->Specular) > 1e-16) 
-	 light->_Flags |= LIGHT_SPECULAR;
-      
-      if (light->SpotCutoff != 180.0F)
-	 light->_Flags |= LIGHT_SPOT;
+   if (ctx->Light.Model.TwoSide)
+      ctx->_TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
 
+   foreach(light, &ctx->Light.EnabledList) {
       ctx->Light._Flags |= light->_Flags;
    }
 
    ctx->Light._NeedVertices = 
       ((ctx->Light._Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) ||
-       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) ||
-       (ctx->Light.Model.LocalViewer && (ctx->Light._Flags & LIGHT_SPECULAR)));
-
+       ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
+       ctx->Light.Model.LocalViewer);
+   
+   if ((ctx->Light._Flags & LIGHT_POSITIONAL) || 
+       ctx->Light.Model.LocalViewer) 
+      ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
+      
+   
+   /* XXX: This test is overkill & needs to be fixed both for software and
+    * hardware t&l drivers.  The above should be sufficient & should
+    * be tested to verify this.  
+    */
+   if (ctx->Light._NeedVertices)
+      ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
+  
 
    /* Precompute some shading values.
     */
    if (ctx->Visual.RGBAflag) {
-      GLuint sides = ((ctx->_TriangleCaps & DD_TRI_LIGHT_TWOSIDE) ? 2 : 1);
+      GLuint sides = ctx->Light.Model.TwoSide ? 2 : 1;
       GLuint side;
       for (side=0; side < sides; side++) {
 	 struct gl_material *mat = &ctx->Light.Material[side];
@@ -1272,14 +1266,10 @@ gl_update_lighting( GLcontext *ctx )
 	    const struct gl_material *mat = &ctx->Light.Material[side];
 	    SCALE_3V( light->_MatDiffuse[side], light->Diffuse, mat->Diffuse );
 	    SCALE_3V( light->_MatAmbient[side], light->Ambient, mat->Ambient );
-	    if (light->_Flags & LIGHT_SPECULAR) {
-	       SCALE_3V( light->_MatSpecular[side], light->Specular,
-			 mat->Specular);
-	       light->_IsMatSpecular[side] = 
-		  (LEN_SQUARED_3FV(light->_MatSpecular[side]) > 1e-16);
-	    } 
-	    else 
-	       light->_IsMatSpecular[side] = 0;
+	    SCALE_3V( light->_MatSpecular[side], light->Specular,
+		      mat->Specular);
+	    light->_IsMatSpecular[side] = 
+	       (LEN_SQUARED_3FV(light->_MatSpecular[side]) > 1e-16);
 	 }
       }
    } 
@@ -1290,28 +1280,34 @@ gl_update_lighting( GLcontext *ctx )
 	 light->_sli = DOT3(ci, light->Specular);
       }
    }
-}
 
+   gl_update_lighting_function(ctx);
+}
 
 
-/* Need to seriously restrict the circumstances under which these
- * calc's are performed.
+/* _NEW_MODELVIEW
+ * _NEW_LIGHT
+ * _TNL_NEW_NEED_EYE_COORDS
+ *
+ * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled.
+ * Also update on lighting space changes.
  */
 void
 gl_compute_light_positions( GLcontext *ctx )
 {
    struct gl_light *light;
-   
-   if (1 /*ctx->Light.NeedVertices && !ctx->Light.Model.LocalViewer*/) {
-      static const GLfloat eye_z[3] = { 0, 0, 1 };
-      if (ctx->_NeedEyeCoords) {
-	 COPY_3V( ctx->_EyeZDir, eye_z );
-      }
-      else {
-	 TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelView.m );
-      }
-   }
+   static const GLfloat eye_z[3] = { 0, 0, 1 };
+
+   if (!ctx->Light.Enabled)
+      return;
 
+   if (ctx->_NeedEyeCoords) {
+      COPY_3V( ctx->_EyeZDir, eye_z );
+   }
+   else {
+      TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelView.m );
+   }
+   
    foreach (light, &ctx->Light.EnabledList) {
 
       if (ctx->_NeedEyeCoords) {
@@ -1336,7 +1332,7 @@ gl_compute_light_positions( GLcontext *ctx )
       }
       
       if (light->_Flags & LIGHT_SPOT) {
-	 if (ctx->_NeedEyeNormals) {
+	 if (ctx->_NeedEyeCoords) {
 	    COPY_3V( light->_NormDirection, light->EyeDirection );
 	 }
          else {
@@ -1347,9 +1343,6 @@ gl_compute_light_positions( GLcontext *ctx )
 
 	 NORMALIZE_3FV( light->_NormDirection );
 
-
-	 /* Unlikely occurrance?
-	  */
 	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
 	    GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm, 
 					light->_NormDirection);
@@ -1370,52 +1363,51 @@ gl_compute_light_positions( GLcontext *ctx )
 }
 
 
+/* _NEW_TRANSFORM
+ * _NEW_MODELVIEW
+ * _TNL_NEW_NEED_NORMALS    
+ * _TNL_NEW_NEED_EYE_COORDS
+ *
+ * Update on (_NEW_TRANSFORM|_NEW_MODELVIEW)
+ * And also on NewLightingSpaces() callback.
+ */
 void
 gl_update_normal_transform( GLcontext *ctx )
 {
-   ctx->_vb_rescale_factor = 1.0;
+
+   if (!ctx->_NeedNormals) {
+      ctx->_NormalTransform = 0;
+      return;
+   }
 
    if (ctx->_NeedEyeCoords) {
-      if (ctx->_NeedNormals) {
-	 GLuint transform = NORM_TRANSFORM_NO_ROT;
-
-	 if (ctx->ModelView.flags & (MAT_FLAG_GENERAL |
-				     MAT_FLAG_ROTATION |
-				     MAT_FLAG_GENERAL_3D |
-				     MAT_FLAG_PERSPECTIVE)) 
-	    transform = NORM_TRANSFORM;
+      GLuint transform = NORM_TRANSFORM_NO_ROT;
+
+      if (ctx->ModelView.flags & (MAT_FLAG_GENERAL |
+				  MAT_FLAG_ROTATION |
+				  MAT_FLAG_GENERAL_3D |
+				  MAT_FLAG_PERSPECTIVE)) 
+	 transform = NORM_TRANSFORM;
 	    
-	 ctx->_vb_rescale_factor = ctx->_rescale_factor;
 	       
-	 if (ctx->Transform.Normalize) {
-	    ctx->_NormalTransform = gl_normal_tab[transform | NORM_NORMALIZE];
-	 } 
-	 else if (ctx->Transform.RescaleNormals &&
-		  ctx->_rescale_factor != 1.0) {
-	    ctx->_NormalTransform = gl_normal_tab[transform | NORM_RESCALE];
-	 }
-	 else {
-	    ctx->_NormalTransform = gl_normal_tab[transform];
-	 }
+      if (ctx->Transform.Normalize) {
+	 ctx->_NormalTransform = gl_normal_tab[transform | NORM_NORMALIZE];
+      } 
+      else if (ctx->Transform.RescaleNormals &&
+	       ctx->_ModelViewInvScale != 1.0) {
+	 ctx->_NormalTransform = gl_normal_tab[transform | NORM_RESCALE];
       }
       else {
-	 ctx->_NormalTransform = 0;
+	 ctx->_NormalTransform = gl_normal_tab[transform];
       }
    }
    else {
-      if (ctx->_NeedNormals) {
-	 ctx->_vb_rescale_factor = 1.0/ctx->_rescale_factor;
-
-	 if (ctx->Transform.Normalize) {
-	    ctx->_NormalTransform = gl_normal_tab[NORM_NORMALIZE];
-	 }
-	 else if (!ctx->Transform.RescaleNormals &&
-		  ctx->_rescale_factor != 1.0) {
-	    ctx->_NormalTransform = gl_normal_tab[NORM_RESCALE];
-	 }
-	 else {
-	    ctx->_NormalTransform = 0;
-	 }
+      if (ctx->Transform.Normalize) {
+	 ctx->_NormalTransform = gl_normal_tab[NORM_NORMALIZE];
+      }
+      else if (!ctx->Transform.RescaleNormals &&
+	       ctx->_ModelViewInvScale != 1.0) {
+	 ctx->_NormalTransform = gl_normal_tab[NORM_RESCALE];
       }
       else {
 	 ctx->_NormalTransform = 0;

src/mesa/main/matrix.c

@@ -1,4 +1,4 @@
-/* $Id: matrix.c,v 1.24 2000/11/05 18:40:58 keithw Exp $ */
+/* $Id: matrix.c,v 1.25 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -930,16 +930,6 @@ static void mat_mul_floats( GLmatrix *mat, const GLfloat *m, GLuint flags )
 }
 
 
-void gl_calculate_model_project_matrix( GLcontext *ctx )
-{
-   gl_matrix_mul( &ctx->_ModelProjectMatrix,
-		  &ctx->ProjectionMatrix,
-		  &ctx->ModelView );
-
-   gl_matrix_analyze( &ctx->_ModelProjectMatrix );
-}
-
-
 void gl_matrix_ctr( GLmatrix *m )
 {
    if ( m->m == 0 ) {

src/mesa/main/points.c

@@ -1,4 +1,4 @@
-/* $Id: points.c,v 1.20 2000/11/05 18:40:58 keithw Exp $ */
+/* $Id: points.c,v 1.21 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -89,6 +89,7 @@ _mesa_PointParameterfvEXT( GLenum pname, const GLfloat *params)
             if (tmp != ctx->Point._Attenuated) {
                ctx->_Enabled ^= ENABLE_POINT_ATTEN;
                ctx->_TriangleCaps ^= DD_POINT_ATTEN;
+	       ctx->_NeedEyeCoords ^= NEED_EYE_POINT_ATTEN;
             }
          }
          break;

src/mesa/main/rastpos.c

@@ -1,4 +1,4 @@
-/* $Id: rastpos.c,v 1.12 2000/11/05 18:40:58 keithw Exp $ */
+/* $Id: rastpos.c,v 1.13 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -68,15 +68,10 @@ static void raster_pos4f( GLcontext *ctx,
    /* raster color */
    if (ctx->Light.Enabled) 
    {
-      /*GLfloat *vert;*/
       GLfloat *norm, eyenorm[3];
       GLfloat *objnorm = ctx->Current.Normal;
 
-	  /* Not needed???
-      vert = (ctx->_NeedEyeCoords ? eye : v);
-	  */
-
-      if (ctx->_NeedEyeNormals) {
+      if (ctx->_NeedEyeCoords) {
 	 GLfloat *inv = ctx->ModelView.inv;
 	 TRANSFORM_NORMAL( eyenorm, objnorm, inv );
 	 norm = eyenorm;

src/mesa/main/state.c

@@ -1,4 +1,4 @@
-/* $Id: state.c,v 1.42 2000/11/10 18:31:04 brianp Exp $ */
+/* $Id: state.c,v 1.43 2000/11/13 20:02:56 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -747,264 +747,348 @@ void gl_print_enable_flags( const char *msg, GLuint flags )
 }
 
 
-/*
- * If ctx->NewState is non-zero then this function MUST be called before
- * rendering any primitive.  Basically, function pointers and miscellaneous
- * flags are updated to reflect the current state of the state machine.
+/* Note: This routine refers to derived texture attribute values to
+ * compute the ENABLE_TEXMAT flags, but is only called on
+ * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
+ * flags are updated by _mesa_update_textures(), below.  
+ * 
+ * If both TEXTURE and TEXTURE_MATRIX change at once, these values
+ * will be computed twice. 
  */
-void gl_update_state( GLcontext *ctx )
+static void
+_mesa_update_texture_matrices( GLcontext *ctx )
 {
    GLuint i;
 
-   if (MESA_VERBOSE & VERBOSE_STATE)
-      gl_print_state("", ctx->NewState);
+   ctx->_Enabled &= ~(ENABLE_TEXMAT0 | ENABLE_TEXMAT1 | ENABLE_TEXMAT2);
 
-   if (ctx->NewState & (_NEW_PIXEL|_NEW_COLOR_MATRIX))
-      _mesa_update_image_transfer_state(ctx);
+   for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
+      if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER) {
+	 gl_matrix_analyze( &ctx->TextureMatrix[i] );
+	 ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
 
-   if (ctx->NewState & _NEW_ARRAY)
-      gl_update_client_state( ctx );
+	 if (ctx->Texture.Unit[i]._ReallyEnabled &&
+	     ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
+	    ctx->_Enabled |= ENABLE_TEXMAT0 << i;
+      }
+   }
+}
 
-   if (ctx->NewState & _NEW_TEXTURE_MATRIX) {
-      ctx->_Enabled &= ~(ENABLE_TEXMAT0 | ENABLE_TEXMAT1 | ENABLE_TEXMAT2);
 
-      for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
-	 if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER) {
-	    gl_matrix_analyze( &ctx->TextureMatrix[i] );
-	    ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
+/* Note: This routine refers to derived texture matrix values to
+ * compute the ENABLE_TEXMAT flags, but is only called on
+ * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
+ * flags are updated by _mesa_update_texture_matrices, above.  
+ * 
+ * If both TEXTURE and TEXTURE_MATRIX change at once, these values
+ * will be computed twice.  
+ */
+static void
+_mesa_update_textures( GLcontext *ctx )
+{
+   GLuint i;
+
+   ctx->Texture._ReallyEnabled = 0;
+   ctx->_Enabled &= ~(ENABLE_TEXGEN0 | ENABLE_TEXGEN1 | ENABLE_TEXGEN2 |
+		      ENABLE_TEXMAT0 | ENABLE_TEXMAT1 | ENABLE_TEXMAT2 |
+		      ENABLE_TEX0 | ENABLE_TEX1 | ENABLE_TEX2);
 
-	    if (ctx->Texture.Unit[i].Enabled &&
-		ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
-	       ctx->_Enabled |= ENABLE_TEXMAT0 << i;
-	 }
-      }
-   }
+   gl_update_dirty_texobjs(ctx);
 
-   if (ctx->NewState & _NEW_TEXTURE) {
-      ctx->Texture._MultiTextureEnabled = GL_FALSE;
-      ctx->Texture._NeedNormals = GL_FALSE;
-      gl_update_dirty_texobjs(ctx);
-      ctx->_Enabled &= ~(ENABLE_TEXGEN0 | ENABLE_TEXGEN1 | ENABLE_TEXGEN2);
-      ctx->Texture._ReallyEnabled = 0;
+   for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
+      
+      ctx->Texture.Unit[i]._ReallyEnabled = 0;
 
-      for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
-	 if (ctx->Texture.Unit[i].Enabled) {
-	    gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
+      if (ctx->Texture.Unit[i].Enabled) {
 
-	    ctx->Texture._ReallyEnabled |=
-	       ctx->Texture.Unit[i]._ReallyEnabled << (i * 4);
+	 gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
 
-	    if (ctx->Texture.Unit[i]._GenFlags != 0) {
-	       ctx->_Enabled |= ENABLE_TEXGEN0 << i;
+	 if (ctx->Texture.Unit[i]._ReallyEnabled) {
+	    GLuint flag = ctx->Texture.Unit[i]._ReallyEnabled << (i * 4);
 
-	       if (ctx->Texture.Unit[i]._GenFlags & TEXGEN_NEED_NORMALS) {
-		  ctx->Texture._NeedNormals = GL_TRUE;
-		  ctx->Texture._NeedEyeCoords = GL_TRUE;
-	       }
+	    ctx->Texture._ReallyEnabled |= flag;
+	    ctx->_Enabled |= flag;
 
-	       if (ctx->Texture.Unit[i]._GenFlags & TEXGEN_NEED_EYE_COORD) {
-		  ctx->Texture._NeedEyeCoords = GL_TRUE;
-	       }
+	    if (ctx->Texture.Unit[i]._GenFlags) {
+	       ctx->_Enabled |= ENABLE_TEXGEN0 << i;
+	       ctx->Texture._GenFlags |= ctx->Texture.Unit[i]._GenFlags;
 	    }
 
-            if (i > 0 && ctx->Texture.Unit[i]._ReallyEnabled) {
-               ctx->Texture._MultiTextureEnabled = GL_TRUE;
-            }
+	    if (ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
+	       ctx->_Enabled |= ENABLE_TEXMAT0 << i;
 	 }
-         else {
-            ctx->Texture.Unit[i]._ReallyEnabled = 0;
-         }
       }
-      ctx->_Enabled = ((ctx->_Enabled & ~ENABLE_TEX_ANY) | 
-		       ctx->Texture._ReallyEnabled);
-      ctx->_NeedNormals = (ctx->Light.Enabled || ctx->Texture._NeedNormals);
    }
 
+   ctx->_NeedNormals &= ~NEED_NORMALS_TEXGEN;
+   ctx->_NeedEyeCoords &= ~NEED_EYE_TEXGEN;
 
-   if (ctx->NewState & (_NEW_BUFFERS|_NEW_SCISSOR)) {
-      /* update scissor region */
-      ctx->DrawBuffer->Xmin = 0;
-      ctx->DrawBuffer->Ymin = 0;
-      ctx->DrawBuffer->Xmax = ctx->DrawBuffer->Width;
-      ctx->DrawBuffer->Ymax = ctx->DrawBuffer->Height;
-      if (ctx->Scissor.Enabled) {
-         if (ctx->Scissor.X > ctx->DrawBuffer->Xmin) {
-            ctx->DrawBuffer->Xmin = ctx->Scissor.X;
-         }
-         if (ctx->Scissor.Y > ctx->DrawBuffer->Ymin) {
-            ctx->DrawBuffer->Ymin = ctx->Scissor.Y;
-         }
-         if (ctx->Scissor.X + ctx->Scissor.Width < ctx->DrawBuffer->Xmax) {
-            ctx->DrawBuffer->Xmax = ctx->Scissor.X + ctx->Scissor.Width;
-         }
-         if (ctx->Scissor.Y + ctx->Scissor.Height < ctx->DrawBuffer->Ymax) {
-            ctx->DrawBuffer->Ymax = ctx->Scissor.Y + ctx->Scissor.Height;
-         }
-      }
+   if (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS) {
+      ctx->_NeedNormals |= NEED_NORMALS_TEXGEN;
+      ctx->_NeedEyeCoords |= NEED_EYE_TEXGEN;
+   }
+   
+   if (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) {
+      ctx->_NeedEyeCoords |= NEED_EYE_TEXGEN;
    }
+}
 
-   if (ctx->NewState & _NEW_LIGHT) {
-      ctx->_TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
-      if (ctx->Light.Enabled) {
-         if (ctx->Light.Model.TwoSide)
-            ctx->_TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
-         gl_update_lighting(ctx);
+static void
+_mesa_update_polygon( GLcontext *ctx )
+{
+   ctx->_TriangleCaps &= ~DD_TRI_CULL_FRONT_BACK;
+
+   /* Setup CullBits bitmask */
+   if (ctx->Polygon.CullFlag) {
+      switch(ctx->Polygon.CullFaceMode) {
+      case GL_BACK:
+	 ctx->Polygon._CullBits = 1;
+	 break;
+      case GL_FRONT:
+	 ctx->Polygon._CullBits = 2;
+	 break;
+      default:
+      case GL_FRONT_AND_BACK:
+	 ctx->Polygon._CullBits = 0;
+	 ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
+	 break;
       }
    }
+   else {
+      ctx->Polygon._CullBits = 3;
+   }
 
-   if (ctx->NewState & (_NEW_POLYGON | _NEW_LIGHT)) {
-
-
-      if (ctx->NewState & _NEW_POLYGON) {
-	 ctx->_TriangleCaps &= ~DD_TRI_CULL_FRONT_BACK;
-
-	 /* Setup CullBits bitmask */
-	 if (ctx->Polygon.CullFlag) {
-	    ctx->_backface_sign = 1;
-	    switch(ctx->Polygon.CullFaceMode) {
-	    case GL_BACK:
-	       if(ctx->Polygon.FrontFace==GL_CCW)
-		  ctx->_backface_sign = -1;
-	       ctx->Polygon._CullBits = 1;
-	       break;
-	    case GL_FRONT:
-	       if(ctx->Polygon.FrontFace!=GL_CCW)
-		  ctx->_backface_sign = -1;
-	       ctx->Polygon._CullBits = 2;
-	       break;
-	    default:
-	    case GL_FRONT_AND_BACK:
-	       ctx->_backface_sign = 0;
-	       ctx->Polygon._CullBits = 0;
-	       ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-	       break;
-	    }
-	 }
-	 else {
-	    ctx->Polygon._CullBits = 3;
-	    ctx->_backface_sign = 0;
-	 }
+   /* Any Polygon offsets enabled? */
+   ctx->_TriangleCaps &= ~DD_TRI_OFFSET;
 
-	 /* Any Polygon offsets enabled? */
-	 ctx->_TriangleCaps &= ~DD_TRI_OFFSET;
+   if (ctx->Polygon.OffsetPoint ||
+       ctx->Polygon.OffsetLine ||
+       ctx->Polygon.OffsetFill)
+      ctx->_TriangleCaps |= DD_TRI_OFFSET;
+}
 
-	 if (ctx->Polygon.OffsetPoint ||
-	     ctx->Polygon.OffsetLine ||
-	     ctx->Polygon.OffsetFill)
-	    ctx->_TriangleCaps |= DD_TRI_OFFSET;
-      }
+static void 
+_mesa_calculate_model_project_matrix( GLcontext *ctx )
+{
+   if (!ctx->_NeedEyeCoords) {
+      gl_matrix_mul( &ctx->_ModelProjectMatrix,
+		     &ctx->ProjectionMatrix,
+		     &ctx->ModelView );
+
+      gl_matrix_analyze( &ctx->_ModelProjectMatrix );
    }
+}
 
-   if (ctx->NewState & (_NEW_LIGHT|
-			_NEW_TEXTURE|
-			_NEW_FOG|
-			_NEW_POLYGON))
-      gl_update_clipmask(ctx);
+static void
+_mesa_update_modelview_scale( GLcontext *ctx )
+{
+   ctx->_ModelViewInvScale = 1.0F;
+   if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
+			       MAT_FLAG_GENERAL_SCALE |
+			       MAT_FLAG_GENERAL_3D |
+			       MAT_FLAG_GENERAL) ) {
+      const GLfloat *m = ctx->ModelView.inv;
+      GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10];
+      if (f < 1e-12) f = 1.0;
+      if (ctx->_NeedEyeCoords)
+	 ctx->_ModelViewInvScale = 1.0/GL_SQRT(f);
+      else
+	 ctx->_ModelViewInvScale = GL_SQRT(f);
+   }
+}
 
-   if (ctx->NewState & ctx->Driver.UpdateStateNotify)
+
+/* Bring uptodate any state that relies on _NeedEyeCoords.  
+ */
+static void
+_mesa_update_tnl_spaces( GLcontext *ctx, GLuint oldneedeyecoords )
+{   
+   /* Check if the truth-value interpretations of the bitfields have
+    * changed: 
+    */
+   if ((oldneedeyecoords == 0) != (ctx->_NeedEyeCoords == 0))
    {
-      /*
-       * Here the driver sets up all the ctx->Driver function pointers to
-       * it's specific, private functions.
+      /* Recalculate all state that depends on _NeedEyeCoords.
        */
-      ctx->Driver.UpdateState(ctx);
-      gl_set_render_vb_function(ctx); /* fix me */
+      _mesa_update_modelview_scale(ctx);
+      _mesa_calculate_model_project_matrix(ctx);
+      gl_update_normal_transform( ctx ); 
+      gl_compute_light_positions( ctx );
+
+      if (ctx->Driver.LightingSpaceChange)
+	 ctx->Driver.LightingSpaceChange( ctx );
    }
+   else 
+   {
+      GLuint new_state = ctx->NewState;
 
-   /* Should only be calc'd when !need_eye_coords and not culling.
-    */
-   if (ctx->NewState & (_NEW_MODELVIEW|_NEW_PROJECTION)) {
-      if (ctx->NewState & _NEW_MODELVIEW) {
-	 gl_matrix_analyze( &ctx->ModelView );
-	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
+      /* Recalculate that same state if and only if it has been
+       * invalidated by other statechanges.
+       */
+      if (new_state & _NEW_MODELVIEW) 
+	 _mesa_update_modelview_scale(ctx);
+
+      if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION)) 
+	 _mesa_calculate_model_project_matrix(ctx);
+	    
+      if (new_state & _TNL_NEW_NORMAL_TRANSFORM)
+	 gl_update_normal_transform( ctx ); /* references _ModelViewInvScale */
+	     
+      if (new_state & (_NEW_LIGHT|_NEW_MODELVIEW))
+	 gl_compute_light_positions( ctx );
+   }
+}
+
+
+static void
+_mesa_update_drawbuffer( GLcontext *ctx )
+{
+   ctx->DrawBuffer->_Xmin = 0;
+   ctx->DrawBuffer->_Ymin = 0;
+   ctx->DrawBuffer->_Xmax = ctx->DrawBuffer->Width;
+   ctx->DrawBuffer->_Ymax = ctx->DrawBuffer->Height;
+   if (ctx->Scissor.Enabled) {
+      if (ctx->Scissor.X > ctx->DrawBuffer->_Xmin) {
+	 ctx->DrawBuffer->_Xmin = ctx->Scissor.X;
+      }
+      if (ctx->Scissor.Y > ctx->DrawBuffer->_Ymin) {
+	 ctx->DrawBuffer->_Ymin = ctx->Scissor.Y;
+      }
+      if (ctx->Scissor.X + ctx->Scissor.Width < ctx->DrawBuffer->_Xmax) {
+	 ctx->DrawBuffer->_Xmax = ctx->Scissor.X + ctx->Scissor.Width;
       }
+      if (ctx->Scissor.Y + ctx->Scissor.Height < ctx->DrawBuffer->_Ymax) {
+	 ctx->DrawBuffer->_Ymax = ctx->Scissor.Y + ctx->Scissor.Height;
+      }
+   }
+}
 
-      if (ctx->NewState & _NEW_PROJECTION) {
-	 gl_matrix_analyze( &ctx->ProjectionMatrix );
-	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
 
-	 if (ctx->Transform._AnyClip) {
-	    gl_update_userclip( ctx );
+/* NOTE: This routine references Tranform attribute values to compute
+ * userclip positions in clip space, but is only called on
+ * _NEW_PROJECTION.  The _mesa_ClipPlane() function keeps these values
+ * uptodate across changes to the Transform attributes.
+ */
+static void
+_mesa_update_projection( GLcontext *ctx )
+{
+   gl_matrix_analyze( &ctx->ProjectionMatrix );
+      
+   /* Recompute clip plane positions in clipspace.  This is also done
+    * in _mesa_ClipPlane().
+    */
+   if (ctx->Transform._AnyClip) {
+      GLuint p;
+      for (p = 0 ; p < MAX_CLIP_PLANES ; p++) {
+	 if (ctx->Transform.ClipEnabled[p]) {
+	    gl_transform_vector( ctx->Transform._ClipUserPlane[p],
+				 ctx->Transform.EyeUserPlane[p],
+				 ctx->ProjectionMatrix.inv );
 	 }
       }
-
-      gl_calculate_model_project_matrix( ctx );
    }
+}
+
+
+
+
+/*
+ * If ctx->NewState is non-zero then this function MUST be called before
+ * rendering any primitive.  Basically, function pointers and miscellaneous
+ * flags are updated to reflect the current state of the state machine.
+ *
+ * Special care is taken with the derived value _NeedEyeCoords.  These
+ * is a bitflag which is updated with information from a number of
+ * attribute groups (MODELVIEW, LIGHT, TEXTURE).  A lot of derived
+ * state references this value, and must be treated with care to
+ * ensure that updates are done correctly.  All state dependent on
+ * _NeedEyeCoords is calculated from within _mesa_update_tnl_spaces(),
+ * and from nowhere else.  
+ */
+void gl_update_state( GLcontext *ctx )
+{
+   GLuint new_state = ctx->NewState;
+   GLuint oldneedeyecoords = ctx->_NeedEyeCoords;
+
+   if (MESA_VERBOSE & VERBOSE_STATE)
+      gl_print_state("", new_state);
+
+   if (new_state & _NEW_MODELVIEW) 
+      gl_matrix_analyze( &ctx->ModelView );
+
+   if (new_state & _NEW_PROJECTION) 
+      _mesa_update_projection( ctx );
 
-   if (ctx->NewState & _NEW_COLOR_MATRIX) {
+   if (new_state & _NEW_TEXTURE_MATRIX) 
+      _mesa_update_texture_matrices( ctx );
+
+   if (new_state & _NEW_COLOR_MATRIX) 
       gl_matrix_analyze( &ctx->ColorMatrix );
-   }
+   
+   /* References ColorMatrix.type (derived above).
+    */
+   if (new_state & (_NEW_PIXEL|_NEW_COLOR_MATRIX))
+      _mesa_update_image_transfer_state(ctx);
+
+   if (new_state & _NEW_ARRAY)
+      gl_update_client_state( ctx );
 
-   /* Figure out whether we can light in object space or not.  If we
-    * can, find the current positions of the lights in object space
+   /* Contributes to NeedEyeCoords, NeedNormals.
     */
-   if ((ctx->_Enabled & (ENABLE_POINT_ATTEN | ENABLE_LIGHT | ENABLE_FOG |
-			ENABLE_TEXGEN0 | ENABLE_TEXGEN1 | ENABLE_TEXGEN2)) &&
-       (ctx->NewState & (_NEW_LIGHT | 
-			 _NEW_TEXTURE |
-                         _NEW_FOG |
-			 _NEW_TRANSFORM | 
-			 _NEW_MODELVIEW | 
-			 _NEW_PROJECTION |
-			 _NEW_POINT |
-			 _NEW_RENDERMODE |
-			 _NEW_TRANSFORM)))
-   {
-      GLboolean oldcoord, oldnorm;
-
-      oldcoord = ctx->_NeedEyeCoords;
-      oldnorm = ctx->_NeedEyeNormals;
-
-      ctx->_NeedNormals = (ctx->Light.Enabled || ctx->Texture._NeedNormals);
-      ctx->_NeedEyeCoords = (ctx->Fog.Enabled || ctx->Point._Attenuated);
-      ctx->_NeedEyeNormals = GL_FALSE;
-
-      if (ctx->Light.Enabled) {
-	 if ((ctx->Light._Flags & LIGHT_POSITIONAL) ||
-             ctx->Light._NeedVertices ||
-             !TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING)) {
-            /* Need length for attenuation or need angle for spotlights
-             * or non-uniform scale matrix
-             */
-            ctx->_NeedEyeCoords = GL_TRUE;
-	 }
-	 ctx->_NeedEyeNormals = ctx->_NeedEyeCoords;
-      }
-      if (ctx->Texture._ReallyEnabled || ctx->RenderMode==GL_FEEDBACK) {
-	 if (ctx->Texture._NeedEyeCoords) ctx->_NeedEyeCoords = GL_TRUE;
-	 if (ctx->Texture._NeedNormals)
-	    ctx->_NeedNormals = ctx->_NeedEyeNormals = GL_TRUE;
-      }
+   if (new_state & _NEW_TEXTURE) 
+      _mesa_update_textures( ctx );
 
-      if (ctx->_NeedEyeCoords)
-	 ctx->_vb_proj_matrix = &ctx->ProjectionMatrix;
-      else
-	 ctx->_vb_proj_matrix = &ctx->_ModelProjectMatrix;
+   if (new_state & (_NEW_BUFFERS|_NEW_SCISSOR)) 
+      _mesa_update_drawbuffer( ctx );
 
-      if (ctx->Light.Enabled) {
-	 gl_update_lighting_function(ctx);
+   if (new_state & _NEW_POLYGON) 
+      _mesa_update_polygon( ctx );
 
-	 if ( (ctx->NewState & _NEW_LIGHT) ||
-	      ((ctx->NewState & (_NEW_MODELVIEW|_NEW_PROJECTION)) &&
-	       !ctx->_NeedEyeCoords) ||
-	      oldcoord != ctx->_NeedEyeCoords ||
-	      oldnorm != ctx->_NeedEyeNormals) {
-	    gl_compute_light_positions(ctx);
-	 }
+   /* Contributes to NeedEyeCoords, NeedNormals.
+    */
+   if (new_state & _NEW_LIGHT) 
+      gl_update_lighting( ctx );
 
-	 ctx->_rescale_factor = 1.0F;
-	 if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
-				     MAT_FLAG_GENERAL_SCALE |
-				     MAT_FLAG_GENERAL_3D |
-				     MAT_FLAG_GENERAL) ) {
-	    const GLfloat *m = ctx->ModelView.inv;
-	    const GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10];
-	    if (f > 1e-12 && (f - 1.0) * (f - 1.0) > 1e-12)
-	       ctx->_rescale_factor = 1.0 / GL_SQRT(f);
-	 }
-      }
+   if (new_state & (_NEW_LIGHT|_NEW_TEXTURE|_NEW_FOG|
+		    _DD_NEW_TRI_LIGHT_TWOSIDE |
+		    _DD_NEW_SEPERATE_SPECULAR |
+		    _DD_NEW_TRI_UNFILLED ))
+      gl_update_clipmask(ctx);
+
+   /* We can light in object space if the modelview matrix preserves
+    * lengths and relative angles.
+    */
+   if (new_state & (_NEW_MODELVIEW|_NEW_LIGHT)) {
+      ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT_MODELVIEW;
+      if (ctx->Light.Enabled &&
+	  !TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
+	    ctx->_NeedEyeCoords |= NEED_EYE_LIGHT_MODELVIEW;
+   }
 
-      gl_update_normal_transform( ctx );
+   /* ctx->_NeedEyeCoords and ctx->_NeedEyeNormals are now uptodate.
+    *
+    * If the truth value of either has changed, update for the new
+    * lighting space and recompute the positions of lights and the
+    * normal transform.
+    * 
+    * If the lighting space hasn't changed, may still need to recompute
+    * light positions & normal transforms for other reasons.  
+    */
+   if (new_state & (_NEW_MODELVIEW |
+		    _NEW_PROJECTION |
+		    _TNL_NEW_NORMAL_TRANSFORM |
+		    _NEW_LIGHT |
+		    _TNL_NEW_NEED_EYE_COORDS)) 
+      _mesa_update_tnl_spaces( ctx, oldneedeyecoords );
+
+   if (new_state & ctx->Driver.UpdateStateNotify)
+   {
+      /*
+       * Here the driver sets up all the ctx->Driver function pointers to
+       * it's specific, private functions.
+       */
+      ctx->Driver.UpdateState(ctx);
+      gl_set_render_vb_function(ctx); /* XXX: remove this mechanism */
    }
 
    gl_update_pipelines(ctx);

src/mesa/swrast/s_aaline.c

@@ -1,4 +1,4 @@
-/* $Id: s_aaline.c,v 1.1 2000/11/05 23:15:16 brianp Exp $ */
+/* $Id: s_aaline.c,v 1.2 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -489,7 +489,7 @@ _swrast_choose_aa_line_function(GLcontext *ctx)
    if (ctx->Visual.RGBAflag) {
       /* RGBA */
       if (ctx->Texture._ReallyEnabled) {
-         if (ctx->Texture._MultiTextureEnabled
+         if (swrast->_MultiTextureEnabled
              || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR
              || ctx->Fog.ColorSumEnabled)
             /* Multitextured! */

src/mesa/swrast/s_aatriangle.c

@@ -1,4 +1,4 @@
-/* $Id: s_aatriangle.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_aatriangle.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -400,13 +400,14 @@ spec_multitex_aa_tri(GLcontext *ctx,
 void
 _mesa_set_aa_triangle_function(GLcontext *ctx)
 {
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    ASSERT(ctx->Polygon.SmoothFlag);
 
    if (ctx->Texture._ReallyEnabled) {
       if (ctx->Light.Enabled &&
           (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
 	   ctx->Fog.ColorSumEnabled)) {
-         if (ctx->Texture._MultiTextureEnabled) {
+         if (swrast->_MultiTextureEnabled) {
             SWRAST_CONTEXT(ctx)->Triangle = spec_multitex_aa_tri;
          }
          else {
@@ -414,7 +415,7 @@ _mesa_set_aa_triangle_function(GLcontext *ctx)
          }
       }
       else {
-         if (ctx->Texture._MultiTextureEnabled) {
+         if (swrast->_MultiTextureEnabled) {
             SWRAST_CONTEXT(ctx)->Triangle = multitex_aa_tri;
          }
          else {

src/mesa/swrast/s_aatritemp.h

@@ -1,4 +1,4 @@
-/* $Id: s_aatritemp.h,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_aatritemp.h,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -86,7 +86,7 @@
    GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH];
    GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
 #endif
-   GLfloat bf = ctx->_backface_sign;
+   GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign;
 
    /* determine bottom to top order of vertices */
    {

src/mesa/swrast/s_accum.c

@@ -1,4 +1,4 @@
-/* $Id: s_accum.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_accum.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -68,6 +68,7 @@
 void
 _mesa_alloc_accum_buffer( GLcontext *ctx )
 {
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GLint n;
 
    if (ctx->DrawBuffer->Accum) {
@@ -83,11 +84,11 @@ _mesa_alloc_accum_buffer( GLcontext *ctx )
       gl_error( ctx, GL_OUT_OF_MEMORY, "glAccum" );
    }
 #ifdef USE_OPTIMIZED_ACCUM
-   ctx->IntegerAccumMode = GL_TRUE;
+   swrast->_IntegerAccumMode = GL_TRUE;
 #else
-   ctx->IntegerAccumMode = GL_FALSE;
+   swrast->_IntegerAccumMode = GL_FALSE;
 #endif
-   ctx->IntegerAccumScaler = 0.0;
+   swrast->_IntegerAccumScaler = 0.0;
 }
 
 
@@ -102,20 +103,21 @@ _mesa_alloc_accum_buffer( GLcontext *ctx )
  */
 static void rescale_accum( GLcontext *ctx )
 {
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4;
    const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
-   const GLfloat s = ctx->IntegerAccumScaler * (32767.0 / fChanMax);
+   const GLfloat s = swrast->_IntegerAccumScaler * (32767.0 / fChanMax);
    GLaccum *accum = ctx->DrawBuffer->Accum;
    GLuint i;
 
-   assert(ctx->IntegerAccumMode);
+   assert(swrast->_IntegerAccumMode);
    assert(accum);
 
    for (i = 0; i < n; i++) {
       accum[i] = (GLaccum) (accum[i] * s);
    }
 
-   ctx->IntegerAccumMode = GL_FALSE;
+   swrast->_IntegerAccumMode = GL_FALSE;
 }
 
 
@@ -129,6 +131,7 @@ static void rescale_accum( GLcontext *ctx )
 void
 _mesa_clear_accum_buffer( GLcontext *ctx )
 {
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GLuint buffersize;
    GLfloat acc_scale;
 
@@ -169,12 +172,12 @@ _mesa_clear_accum_buffer( GLcontext *ctx )
 	 b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale);
 	 a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale);
          /* size of region to clear */
-         width = 4 * (ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin);
-         height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+         width = 4 * (ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin);
+         height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
          /* ptr to first element to clear */
          row = ctx->DrawBuffer->Accum
-               + 4 * (ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
-                      + ctx->DrawBuffer->Xmin);
+               + 4 * (ctx->DrawBuffer->_Ymin * ctx->DrawBuffer->Width
+                      + ctx->DrawBuffer->_Xmin);
          for (j=0;j<height;j++) {
             for (i=0;i<width;i+=4) {
                row[i+0] = r;
@@ -217,14 +220,14 @@ _mesa_clear_accum_buffer( GLcontext *ctx )
       if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 &&
           ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) {
 #ifdef USE_OPTIMIZED_ACCUM
-         ctx->IntegerAccumMode = GL_TRUE;
+         swrast->_IntegerAccumMode = GL_TRUE;
 #else
-         ctx->IntegerAccumMode = GL_FALSE;
+         swrast->_IntegerAccumMode = GL_FALSE;
 #endif
-         ctx->IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */
+         swrast->_IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */
       }
       else {
-         ctx->IntegerAccumMode = GL_FALSE;
+         swrast->_IntegerAccumMode = GL_FALSE;
       }
    }
 }
@@ -236,6 +239,7 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
 	       GLint width, GLint height )
 
 {
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
    GLuint width4;
    GLfloat acc_scale;
    GLchan rgba[MAX_WIDTH][4];
@@ -273,7 +277,7 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
 	    const GLaccum intVal = (GLaccum) (value * acc_scale);
 	    GLuint j;
             /* Leave optimized accum buffer mode */
-            if (ctx->IntegerAccumMode)
+            if (swrast->_IntegerAccumMode)
                rescale_accum(ctx);
 	    for (j = 0; j < height; j++) {
 	       GLaccum * acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
@@ -290,7 +294,7 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
          if (value != 1.0F) {
 	    GLuint j;
             /* Leave optimized accum buffer mode */
-            if (ctx->IntegerAccumMode)
+            if (swrast->_IntegerAccumMode)
                rescale_accum(ctx);
 	    for (j = 0; j < height; j++) {
 	       GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
@@ -311,19 +315,19 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
                                        ctx->Pixel.DriverReadBuffer );
 
          /* May have to leave optimized accum buffer mode */
-         if (ctx->IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
-            ctx->IntegerAccumScaler = value;
-         if (ctx->IntegerAccumMode && value != ctx->IntegerAccumScaler)
+         if (swrast->_IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
+            swrast->_IntegerAccumScaler = value;
+         if (swrast->_IntegerAccumMode && value != swrast->_IntegerAccumScaler)
             rescale_accum(ctx);
             
          RENDER_START(ctx);
 
-         if (ctx->IntegerAccumMode) {
+         if (swrast->_IntegerAccumMode) {
             /* simply add integer color values into accum buffer */
             GLuint j;
             GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
             for (j = 0; j < height; j++) {
                
                GLuint i, i4;
@@ -371,24 +375,24 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
          /* This is a change to go into optimized accum buffer mode */
          if (value > 0.0 && value <= 1.0) {
 #ifdef USE_OPTIMIZED_ACCUM
-            ctx->IntegerAccumMode = GL_TRUE;
+            swrast->_IntegerAccumMode = GL_TRUE;
 #else
-            ctx->IntegerAccumMode = GL_FALSE;
+            swrast->_IntegerAccumMode = GL_FALSE;
 #endif
-            ctx->IntegerAccumScaler = value;
+            swrast->_IntegerAccumScaler = value;
          }
          else {
-            ctx->IntegerAccumMode = GL_FALSE;
-            ctx->IntegerAccumScaler = 0.0;
+            swrast->_IntegerAccumMode = GL_FALSE;
+            swrast->_IntegerAccumScaler = 0.0;
          }
 
          RENDER_START(ctx);
-         if (ctx->IntegerAccumMode) {
+         if (swrast->_IntegerAccumMode) {
             /* just copy values into accum buffer */
             GLuint j;
             GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
             for (j = 0; j < height; j++) {
                GLuint i, i4;
                gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
@@ -431,15 +435,15 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
 
       case GL_RETURN:
          /* May have to leave optimized accum buffer mode */
-         if (ctx->IntegerAccumMode && value != 1.0)
+         if (swrast->_IntegerAccumMode && value != 1.0)
             rescale_accum(ctx);
 
          RENDER_START(ctx);
-         if (ctx->IntegerAccumMode && ctx->IntegerAccumScaler > 0) {
+         if (swrast->_IntegerAccumMode && swrast->_IntegerAccumScaler > 0) {
             /* build lookup table to avoid many floating point multiplies */
             static GLchan multTable[32768];
             static GLfloat prevMult = 0.0;
-            const GLfloat mult = ctx->IntegerAccumScaler;
+            const GLfloat mult = swrast->_IntegerAccumScaler;
             const GLint max = MIN2((GLint) (256 / mult), 32767);
             GLuint j;
             if (mult != prevMult) {
@@ -448,8 +452,8 @@ _swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
                prevMult = mult;
             }
 
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
             for (j = 0; j < height; j++) {
                const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
                GLuint i, i4;

src/mesa/swrast/s_alpha.c

@@ -1,4 +1,4 @@
-/* $Id: s_alpha.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+/* $Id: s_alpha.c,v 1.2 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -60,9 +60,8 @@ _mesa_alpha_test( const GLcontext *ctx,
 	 }
 	 return 1;
       case GL_LEQUAL:
-         for (i=0;i<n;i++) {
+         for (i=0;i<n;i++) 
 	    mask[i] &= (rgba[i][ACOMP] <= ref);
-	 }
 	 return 1;
       case GL_GEQUAL:
          for (i=0;i<n;i++) {

src/mesa/swrast/s_alphabuf.c

@@ -161,11 +161,11 @@ _mesa_clear_alpha_buffers( GLcontext *ctx )
          if (ctx->Scissor.Enabled) {
             /* clear scissor region */
             GLint j;
-            GLint rowLen = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-            GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
+            GLint rowLen = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin + 1;
+            GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin + 1;
             GLchan *aptr = buffer
-                          + ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
-                          + ctx->DrawBuffer->Xmin;
+                          + ctx->DrawBuffer->_Ymin * ctx->DrawBuffer->Width
+                          + ctx->DrawBuffer->_Xmin;
             for (j = 0; j < rows; j++) {
 #if CHAN_BITS == 8
                MEMSET( aptr, aclear, rowLen );

src/mesa/swrast/s_buffers.c

@@ -1,4 +1,4 @@
-/* $Id: s_buffers.c,v 1.1 2000/10/31 18:00:04 keithw Exp $ */
+/* $Id: s_buffers.c,v 1.2 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -44,10 +44,10 @@
 static void
 clear_color_buffer_with_masking( GLcontext *ctx )
 {
-   const GLint x = ctx->DrawBuffer->Xmin;
-   const GLint y = ctx->DrawBuffer->Ymin;
-   const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
-   const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 
    if (ctx->Visual.RGBAflag) {
       /* RGBA mode */
@@ -94,10 +94,10 @@ clear_color_buffer_with_masking( GLcontext *ctx )
 static void
 clear_color_buffer(GLcontext *ctx)
 {
-   const GLint x = ctx->DrawBuffer->Xmin;
-   const GLint y = ctx->DrawBuffer->Ymin;
-   const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
-   const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 
    if (ctx->Visual.RGBAflag) {
       /* RGBA mode */

src/mesa/swrast/s_context.c

@@ -1,4 +1,4 @@
-/* $Id: s_context.c,v 1.3 2000/11/10 17:45:16 brianp Exp $ */
+/* $Id: s_context.c,v 1.4 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -114,6 +114,44 @@ _swrast_update_rasterflags( GLcontext *ctx )
 }
 
 
+static void
+_swrast_update_polygon( GLcontext *ctx )
+{
+   GLfloat backface_sign = 1;
+
+   if (ctx->Polygon.CullFlag) {
+      backface_sign = 1;
+      switch(ctx->Polygon.CullFaceMode) {
+      case GL_BACK:
+	 if(ctx->Polygon.FrontFace==GL_CCW)
+	    backface_sign = -1;
+	 break;
+      case GL_FRONT:
+	 if(ctx->Polygon.FrontFace!=GL_CCW)
+	    backface_sign = -1;
+	 break;
+      default:
+      case GL_FRONT_AND_BACK:
+	 backface_sign = 0;
+	 break;
+      }
+   }
+   else {
+      backface_sign = 0;
+   }
+
+   SWRAST_CONTEXT(ctx)->_backface_sign = backface_sign;
+}
+
+
+static void
+_swrast_update_hint( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);   
+   swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
+			      (ctx->Hint.Fog == GL_NICEST && 
+			       swrast->AllowPixelFog));
+}
 
 #define _SWRAST_NEW_TRIANGLE (_NEW_RENDERMODE|		\
                               _NEW_POLYGON|		\
@@ -282,7 +320,17 @@ _swrast_validate_derived( GLcontext *ctx )
    if (swrast->NewState) 
    {
       if (swrast->NewState & _SWRAST_NEW_RASTERMASK) 
-	 _swrast_update_rasterflags( ctx );
+ 	 _swrast_update_rasterflags( ctx );
+
+      if (swrast->NewState & _NEW_TEXTURE)
+	 swrast->_MultiTextureEnabled = (ctx->Texture._ReallyEnabled & 
+					 ~ENABLE_TEX0);
+
+      if (swrast->NewState & _NEW_POLYGON)
+	 _swrast_update_polygon( ctx );
+
+      if (swrast->NewState & _NEW_HINT)
+	 _swrast_update_hint( ctx );
 
       swrast->NewState = 0;
       swrast->StateChanges = 0;
@@ -332,6 +380,20 @@ _swrast_get_stipple_counter_ref( GLcontext *ctx )
    return &SWRAST_CONTEXT(ctx)->StippleCounter;
 }
 
+void 
+_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )
+{
+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+   SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
+}
+
+void 
+_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )
+{
+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+   SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
+}
+
 
 GLboolean
 _swrast_CreateContext( GLcontext *ctx )
@@ -366,6 +428,14 @@ _swrast_CreateContext( GLcontext *ctx )
    swrast->InvalidateState = _swrast_sleep;
    swrast->BlendFunc = _swrast_validate_blend_func;
 
+   swrast->AllowVertexFog = GL_TRUE;
+   swrast->AllowPixelFog = GL_TRUE;
+
+   /* Optimized Accum buffer */
+   swrast->_IntegerAccumMode = GL_TRUE;
+   swrast->_IntegerAccumScaler = 0.0;
+
+
    for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
       swrast->TextureSample[i] = _swrast_validate_texture_sample;
    

src/mesa/swrast/s_context.h

@@ -93,16 +93,34 @@ typedef void (*swrast_point_func)( GLcontext *ctx, SWvertex *);
 
 typedef struct
 {
-   GLuint NewState;
-   GLuint StateChanges;
+   /* Configuration mechanisms to make software rasterizer match
+    * characteristics of the hardware rasterizer (if present): 
+    */
+   GLboolean AllowVertexFog;
+   GLboolean AllowPixelFog;
 
+   /* Derived values, invalidated on statechanges, updated from
+    * _swrast_validate_derived():
+    */
    GLuint _RasterMask;
+   GLboolean _MultiTextureEnabled;
    GLuint _MinMagThresh[MAX_TEXTURE_UNITS];
+   GLfloat _backface_sign;
+   GLboolean _PreferPixelFog;
+
+   /* Accum buffer temporaries.  
+    */
+   GLboolean _IntegerAccumMode;	/* Storing unscaled integers? */
+   GLfloat _IntegerAccumScaler;	/* Implicit scale factor */
 
+   
+   /* Working values:
+    */
    struct pixel_buffer* PB;
    GLuint StippleCounter;    /* Line stipple counter */
-
-
+   GLuint NewState;
+   GLuint StateChanges;
+   
    /* Mechanism to allow driver (like X11) to register further
     * software rasterization routines.
     */

src/mesa/swrast/s_depth.c

@@ -1,4 +1,4 @@
-/* $Id: s_depth.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_depth.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -1538,10 +1538,10 @@ _mesa_clear_depth_buffer( GLcontext *ctx )
       /* only clear scissor region */
       if (ctx->Visual.DepthBits <= 16) {
          const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual.DepthMax);
-         const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+         const GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
          const GLint width = ctx->DrawBuffer->Width;
          GLushort *dRow = (GLushort *) ctx->DrawBuffer->DepthBuffer
-            + ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
+            + ctx->DrawBuffer->_Ymin * width + ctx->DrawBuffer->_Xmin;
          GLint i, j;
          for (i = 0; i < rows; i++) {
             for (j = 0; j < width; j++) {
@@ -1552,10 +1552,10 @@ _mesa_clear_depth_buffer( GLcontext *ctx )
       }
       else {
          const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual.DepthMax);
-         const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin;
+         const GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
          const GLint width = ctx->DrawBuffer->Width;
          GLuint *dRow = (GLuint *) ctx->DrawBuffer->DepthBuffer
-            + ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
+            + ctx->DrawBuffer->_Ymin * width + ctx->DrawBuffer->_Xmin;
          GLint i, j;
          for (i = 0; i < rows; i++) {
             for (j = 0; j < width; j++) {

src/mesa/swrast/s_drawpix.c

@@ -1,4 +1,4 @@
-/* $Id: s_drawpix.c,v 1.3 2000/11/10 17:45:16 brianp Exp $ */
+/* $Id: s_drawpix.c,v 1.4 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -61,27 +61,27 @@ _mesa_clip_pixelrect(const GLcontext *ctx,
    const GLframebuffer *buffer = ctx->DrawBuffer;
 
    /* left clipping */
-   if (*destX < buffer->Xmin) {
-      *skipPixels += (buffer->Xmin - *destX);
-      *width -= (buffer->Xmin - *destX);
-      *destX = buffer->Xmin;
+   if (*destX < buffer->_Xmin) {
+      *skipPixels += (buffer->_Xmin - *destX);
+      *width -= (buffer->_Xmin - *destX);
+      *destX = buffer->_Xmin;
    }
    /* right clipping */
-   if (*destX + *width > buffer->Xmax)
-      *width -= (*destX + *width - buffer->Xmax);
+   if (*destX + *width > buffer->_Xmax)
+      *width -= (*destX + *width - buffer->_Xmax);
 
    if (*width <= 0)
       return GL_FALSE;
 
    /* bottom clipping */
-   if (*destY < buffer->Ymin) {
-      *skipRows += (buffer->Ymin - *destY);
-      *height -= (buffer->Ymin - *destY);
-      *destY = buffer->Ymin;
+   if (*destY < buffer->_Ymin) {
+      *skipRows += (buffer->_Ymin - *destY);
+      *height -= (buffer->_Ymin - *destY);
+      *destY = buffer->_Ymin;
    }
    /* top clipping */
-   if (*destY + *height > buffer->Ymax)
-      *height -= (*destY + *height - buffer->Ymax);
+   if (*destY + *height > buffer->_Ymax)
+      *height -= (*destY + *height - buffer->_Ymax);
 
    if (*height <= 0)
       return GL_TRUE;
@@ -139,48 +139,48 @@ fast_draw_pixels(GLcontext *ctx, GLint x, GLint y,
        */
       if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
          /* horizontal clipping */
-         if (destX < ctx->DrawBuffer->Xmin) {
-            skipPixels += (ctx->DrawBuffer->Xmin - destX);
-            drawWidth  -= (ctx->DrawBuffer->Xmin - destX);
-            destX = ctx->DrawBuffer->Xmin;
+         if (destX < ctx->DrawBuffer->_Xmin) {
+            skipPixels += (ctx->DrawBuffer->_Xmin - destX);
+            drawWidth  -= (ctx->DrawBuffer->_Xmin - destX);
+            destX = ctx->DrawBuffer->_Xmin;
          }
-         if (destX + drawWidth > ctx->DrawBuffer->Xmax)
-            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax);
+         if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
+            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
          if (drawWidth <= 0)
             return GL_TRUE;
 
          /* vertical clipping */
-         if (destY < ctx->DrawBuffer->Ymin) {
-            skipRows   += (ctx->DrawBuffer->Ymin - destY);
-            drawHeight -= (ctx->DrawBuffer->Ymin - destY);
-            destY = ctx->DrawBuffer->Ymin;
+         if (destY < ctx->DrawBuffer->_Ymin) {
+            skipRows   += (ctx->DrawBuffer->_Ymin - destY);
+            drawHeight -= (ctx->DrawBuffer->_Ymin - destY);
+            destY = ctx->DrawBuffer->_Ymin;
          }
-         if (destY + drawHeight > ctx->DrawBuffer->Ymax)
-            drawHeight -= (destY + drawHeight - ctx->DrawBuffer->Ymax);
+         if (destY + drawHeight > ctx->DrawBuffer->_Ymax)
+            drawHeight -= (destY + drawHeight - ctx->DrawBuffer->_Ymax);
          if (drawHeight <= 0)
             return GL_TRUE;
       }
       else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
          /* upside-down image */
          /* horizontal clipping */
-         if (destX < ctx->DrawBuffer->Xmin) {
-            skipPixels += (ctx->DrawBuffer->Xmin - destX);
-            drawWidth  -= (ctx->DrawBuffer->Xmin - destX);
-            destX = ctx->DrawBuffer->Xmin;
+         if (destX < ctx->DrawBuffer->_Xmin) {
+            skipPixels += (ctx->DrawBuffer->_Xmin - destX);
+            drawWidth  -= (ctx->DrawBuffer->_Xmin - destX);
+            destX = ctx->DrawBuffer->_Xmin;
          }
-         if (destX + drawWidth > ctx->DrawBuffer->Xmax)
-            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax);
+         if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
+            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
          if (drawWidth <= 0)
             return GL_TRUE;
 
          /* vertical clipping */
-         if (destY > ctx->DrawBuffer->Ymax) {
-            skipRows   += (destY - ctx->DrawBuffer->Ymax);
-            drawHeight -= (destY - ctx->DrawBuffer->Ymax);
-            destY = ctx->DrawBuffer->Ymax;
+         if (destY > ctx->DrawBuffer->_Ymax) {
+            skipRows   += (destY - ctx->DrawBuffer->_Ymax);
+            drawHeight -= (destY - ctx->DrawBuffer->_Ymax);
+            destY = ctx->DrawBuffer->_Ymax;
          }
-         if (destY - drawHeight < ctx->DrawBuffer->Ymin)
-            drawHeight -= (ctx->DrawBuffer->Ymin - (destY - drawHeight));
+         if (destY - drawHeight < ctx->DrawBuffer->_Ymin)
+            drawHeight -= (ctx->DrawBuffer->_Ymin - (destY - drawHeight));
          if (drawHeight <= 0)
             return GL_TRUE;
       }

src/mesa/swrast/s_feedback.c

@@ -1,4 +1,4 @@
-/* $Id: s_feedback.c,v 1.1 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_feedback.c,v 1.2 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -46,7 +46,7 @@
 
 
 
-static void feedback_vertex( GLcontext *ctx, SWvertex *v )
+static void feedback_vertex( GLcontext *ctx, SWvertex *v, SWvertex *pv )
 {
    GLfloat win[4];
    GLfloat color[4];
@@ -59,10 +59,10 @@ static void feedback_vertex( GLcontext *ctx, SWvertex *v )
    win[2] = v->win[2] / ctx->Visual.DepthMaxF;
    win[3] = 1.0 / v->win[3];
 
-   color[0] = CHAN_TO_FLOAT(v->color[0]);
-   color[1] = CHAN_TO_FLOAT(v->color[1]);
-   color[2] = CHAN_TO_FLOAT(v->color[2]);
-   color[3] = CHAN_TO_FLOAT(v->color[3]);
+   color[0] = CHAN_TO_FLOAT(pv->color[0]);
+   color[1] = CHAN_TO_FLOAT(pv->color[1]);
+   color[2] = CHAN_TO_FLOAT(pv->color[2]);
+   color[3] = CHAN_TO_FLOAT(pv->color[3]);
 
    if (v->texcoord[texUnit][3] != 1.0 &&
        v->texcoord[texUnit][3] != 0.0) {
@@ -92,9 +92,15 @@ void gl_feedback_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1,
       FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN );
       FEEDBACK_TOKEN( ctx, (GLfloat) 3 );        /* three vertices */
       
-      feedback_vertex( ctx, v0 );
-      feedback_vertex( ctx, v1 );
-      feedback_vertex( ctx, v2 );
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+	 feedback_vertex( ctx, v0, v0 );
+	 feedback_vertex( ctx, v1, v1 );
+	 feedback_vertex( ctx, v2, v2 );
+      } else {
+	 feedback_vertex( ctx, v0, v0 );
+	 feedback_vertex( ctx, v1, v0 );
+	 feedback_vertex( ctx, v2, v0 );
+      }
    }
 }
 
@@ -109,8 +115,13 @@ void gl_feedback_line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 )
 
    FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
 
-   feedback_vertex( ctx, v0 );
-   feedback_vertex( ctx, v1 );
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      feedback_vertex( ctx, v0, v0 );
+      feedback_vertex( ctx, v1, v1 );
+   } else {
+      feedback_vertex( ctx, v0, v0 );
+      feedback_vertex( ctx, v1, v0 );
+   }
 
    swrast->StippleCounter++;
 }
@@ -119,7 +130,7 @@ void gl_feedback_line( GLcontext *ctx, SWvertex *v0, SWvertex *v1 )
 void gl_feedback_point( GLcontext *ctx, SWvertex *v )
 {
    FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN );
-   feedback_vertex( ctx, v );
+   feedback_vertex( ctx, v, v );
 }
 
 
@@ -128,6 +139,7 @@ void gl_select_triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1,
 {
    if (gl_cull_triangle( ctx, v0, v1, v2 )) {
       const GLfloat zs = 1.0F / ctx->Visual.DepthMaxF;
+
       gl_update_hitflag( ctx, v0->win[2] * zs );
       gl_update_hitflag( ctx, v1->win[2] * zs );
       gl_update_hitflag( ctx, v2->win[2] * zs );

src/mesa/swrast/s_lines.c

@@ -1,4 +1,4 @@
-/* $Id: s_lines.c,v 1.4 2000/11/10 17:45:16 brianp Exp $ */
+/* $Id: s_lines.c,v 1.5 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -979,7 +979,7 @@ _swrast_choose_line( GLcontext *ctx )
          ASSERT(swrast->Triangle);
       }
       else if (ctx->Texture._ReallyEnabled) {
-         if (ctx->Texture._MultiTextureEnabled
+         if (swrast->_MultiTextureEnabled
              || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR
  	     || ctx->Fog.ColorSumEnabled) {
             /* multi-texture and/or separate specular color */

src/mesa/swrast/s_points.c

@@ -1,4 +1,4 @@
-/* $Id: s_points.c,v 1.3 2000/11/10 17:45:16 brianp Exp $ */
+/* $Id: s_points.c,v 1.4 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -362,7 +362,8 @@ multitextured_rgba_point( GLcontext *ctx, SWvertex *vert )
 static void
 antialiased_rgba_point( GLcontext *ctx, SWvertex *vert )
 {
-   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *PB = swrast->PB;
    const GLfloat radius = ctx->Point.Size * 0.5F;
    const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
    const GLfloat rmax = radius + 0.7071F;
@@ -421,7 +422,7 @@ antialiased_rgba_point( GLcontext *ctx, SWvertex *vert )
 		  /* coverage is in [0,256] */
 		  alpha = (alpha * coverage) >> 8;
 	       }
-	       if (ctx->Texture._MultiTextureEnabled) {
+	       if (swrast->_MultiTextureEnabled) {
 		  PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, fog,
 					   red, green, blue, 
 					   alpha, texcoord );
@@ -614,7 +615,8 @@ dist_atten_general_rgba_point( GLcontext *ctx, SWvertex *vert )
 static void
 dist_atten_textured_rgba_point( GLcontext *ctx, SWvertex *vert )
 {
-   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *PB = swrast->PB;
    const GLfloat psize = ctx->Point.Size;
    GLfloat dist = attenuation_distance( ctx, vert->eye );
 
@@ -683,7 +685,7 @@ dist_atten_textured_rgba_point( GLcontext *ctx, SWvertex *vert )
 
    for (iy = y0; iy <= y1; iy++) {
       for (ix = x0; ix <= x1; ix++) {
-	 if (ctx->Texture._MultiTextureEnabled) {
+	 if (swrast->_MultiTextureEnabled) {
 	    PB_WRITE_MULTITEX_PIXEL( PB, ix, iy, z, fog,
 				     red, green, blue, alpha,
 				     texcoord );
@@ -706,7 +708,8 @@ dist_atten_textured_rgba_point( GLcontext *ctx, SWvertex *vert )
 static void
 dist_atten_antialiased_rgba_point( GLcontext *ctx, SWvertex *vert )
 {
-   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *PB = swrast->PB;
    const GLfloat psize = ctx->Point.Size;
    GLfloat dist = attenuation_distance( ctx, vert->eye );
 
@@ -775,7 +778,7 @@ dist_atten_antialiased_rgba_point( GLcontext *ctx, SWvertex *vert )
 		  alpha = (alpha * coverage) >> 8;
 	       }
 	       alpha = (GLint) (alpha * alphaf);
-	       if (ctx->Texture._MultiTextureEnabled) {
+	       if (swrast->_MultiTextureEnabled) {
 		  PB_WRITE_MULTITEX_PIXEL( PB, x, y, z, fog,
 					   red, green, blue, alpha,
 					   texcoord );
@@ -906,7 +909,7 @@ _swrast_choose_point( GLcontext *ctx )
             swrast->Point = antialiased_rgba_point;
          }
          else if (ctx->Texture._ReallyEnabled) {
-            if (ctx->Texture._MultiTextureEnabled ||
+            if (swrast->_MultiTextureEnabled ||
                 ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR ||
 		ctx->Fog.ColorSumEnabled) {
 	       swrast->Point = multitextured_rgba_point;

src/mesa/swrast/s_readpix.c

@@ -1,4 +1,4 @@
-/* $Id: s_readpix.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_readpix.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -520,24 +520,24 @@ read_fast_rgba_pixels( GLcontext *ctx,
          rowLength = width;
 
       /* horizontal clipping */
-      if (srcX < ctx->ReadBuffer->Xmin) {
-         skipPixels += (ctx->ReadBuffer->Xmin - srcX);
-         readWidth  -= (ctx->ReadBuffer->Xmin - srcX);
-         srcX = ctx->ReadBuffer->Xmin;
+      if (srcX < ctx->ReadBuffer->_Xmin) {
+         skipPixels += (ctx->ReadBuffer->_Xmin - srcX);
+         readWidth  -= (ctx->ReadBuffer->_Xmin - srcX);
+         srcX = ctx->ReadBuffer->_Xmin;
       }
-      if (srcX + readWidth > ctx->ReadBuffer->Xmax)
-         readWidth -= (srcX + readWidth - ctx->ReadBuffer->Xmax);
+      if (srcX + readWidth > ctx->ReadBuffer->_Xmax)
+         readWidth -= (srcX + readWidth - ctx->ReadBuffer->_Xmax);
       if (readWidth <= 0)
          return GL_TRUE;
 
       /* vertical clipping */
-      if (srcY < ctx->ReadBuffer->Ymin) {
-         skipRows   += (ctx->ReadBuffer->Ymin - srcY);
-         readHeight -= (ctx->ReadBuffer->Ymin - srcY);
-         srcY = ctx->ReadBuffer->Ymin;
+      if (srcY < ctx->ReadBuffer->_Ymin) {
+         skipRows   += (ctx->ReadBuffer->_Ymin - srcY);
+         readHeight -= (ctx->ReadBuffer->_Ymin - srcY);
+         srcY = ctx->ReadBuffer->_Ymin;
       }
-      if (srcY + readHeight > ctx->ReadBuffer->Ymax)
-         readHeight -= (srcY + readHeight - ctx->ReadBuffer->Ymax);
+      if (srcY + readHeight > ctx->ReadBuffer->_Ymax)
+         readHeight -= (srcY + readHeight - ctx->ReadBuffer->_Ymax);
       if (readHeight <= 0)
          return GL_TRUE;
 

src/mesa/swrast/s_span.c

@@ -1,4 +1,4 @@
-/* $Id: s_span.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_span.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -206,7 +206,7 @@ void gl_write_index_span( GLcontext *ctx,
 
    /* Per-pixel fog */
    if (ctx->Fog.Enabled) {
-      if (fog && ctx->Hint.Fog != GL_NICEST)
+      if (fog && !swrast->_PreferPixelFog)
 	 _mesa_fog_ci_pixels( ctx, n, fog, index );
       else
 	 _mesa_depth_fog_ci_pixels( ctx, n, z, index );
@@ -323,7 +323,7 @@ void gl_write_monoindex_span( GLcontext *ctx,
       }
 
       if (ctx->Fog.Enabled) {
- 	 if (fog && ctx->Hint.Fog != GL_NICEST)
+ 	 if (fog && !swrast->_PreferPixelFog)
  	    _mesa_fog_ci_pixels( ctx, n, fog, indexes );
  	 else
  	    _mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
@@ -476,7 +476,7 @@ void gl_write_rgba_span( GLcontext *ctx,
 
    /* Per-pixel fog */
    if (ctx->Fog.Enabled) {
-      if (fog && ctx->Hint.Fog != GL_NICEST) 
+      if (fog && !swrast->_PreferPixelFog) 
 	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
       else
 	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
@@ -660,7 +660,7 @@ void gl_write_monocolor_span( GLcontext *ctx,
 
       /* Per-pixel fog */
       if (ctx->Fog.Enabled) {
-	 if (fog && ctx->Hint.Fog != GL_NICEST)
+	 if (fog && !swrast->_PreferPixelFog)
 	    _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
 	 else
 	    _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
@@ -796,13 +796,14 @@ void gl_write_texture_span( GLcontext *ctx,
    gl_texture_pixels( ctx, 0, n, s, t, u, lambda, rgba, rgba );
 
    /* Add base and specular colors */
-   if (spec && ctx->Light.Enabled
-       && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+   if (spec && 
+       (ctx->Fog.ColorSumEnabled ||
+	(ctx->Light.Enabled && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
       add_colors( n, rgba, spec );   /* rgba = rgba + spec */
 
    /* Per-pixel fog */
    if (ctx->Fog.Enabled) {
-      if (fog && ctx->Hint.Fog != GL_NICEST)
+      if (fog && !swrast->_PreferPixelFog)
 	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
       else
 	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
@@ -932,13 +933,15 @@ gl_write_multitexture_span( GLcontext *ctx,
       gl_texture_pixels( ctx, i, n, s[i], t[i], u[i], lambda[i], rgbaIn, rgba );
 
    /* Add base and specular colors */
-   if (spec && ctx->Light.Enabled
-       && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+   if (spec && 
+       (ctx->Fog.ColorSumEnabled ||
+	(ctx->Light.Enabled && 
+	 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
       add_colors( n, rgba, spec );   /* rgba = rgba + spec */
 
    /* Per-pixel fog */
    if (ctx->Fog.Enabled) {
-      if (fog && ctx->Hint.Fog != GL_NICEST)
+      if (fog && !swrast->_PreferPixelFog)
 	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
       else
 	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );

src/mesa/swrast/s_stencil.c

@@ -1,4 +1,4 @@
-/* $Id: s_stencil.c,v 1.2 2000/11/05 18:24:40 keithw Exp $ */
+/* $Id: s_stencil.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -1137,15 +1137,15 @@ clear_software_stencil_buffer( GLcontext *ctx )
 
    if (ctx->Scissor.Enabled) {
       /* clear scissor region only */
-      const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+      const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
       if (ctx->Stencil.WriteMask != STENCIL_MAX) {
          /* must apply mask to the clear */
          GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
             const GLstencil mask = ctx->Stencil.WriteMask;
             const GLstencil invMask = ~mask;
             const GLstencil clearVal = (ctx->Stencil.Clear & mask);
-            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
+            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
             GLint i;
             for (i = 0; i < width; i++) {
                stencil[i] = (stencil[i] & invMask) | clearVal;
@@ -1155,8 +1155,8 @@ clear_software_stencil_buffer( GLcontext *ctx )
       else {
          /* no masking */
          GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
-            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
+            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
 #if STENCIL_BITS==8
             MEMSET( stencil, ctx->Stencil.Clear, width * sizeof(GLstencil) );
 #else
@@ -1217,12 +1217,12 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
 
    if (ctx->Scissor.Enabled) {
       /* clear scissor region only */
-      const GLint x = ctx->DrawBuffer->Xmin;
-      const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin;
+      const GLint x = ctx->DrawBuffer->_Xmin;
+      const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
       if (ctx->Stencil.WriteMask != STENCIL_MAX) {
          /* must apply mask to the clear */
          GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
             const GLstencil mask = ctx->Stencil.WriteMask;
             const GLstencil invMask = ~mask;
             const GLstencil clearVal = (ctx->Stencil.Clear & mask);
@@ -1242,7 +1242,7 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
          for (i = 0; i < width; i++) {
             stencil[i] = ctx->Stencil.Clear;
          }
-         for (y = ctx->DrawBuffer->Ymin; y < ctx->DrawBuffer->Ymax; y++) {
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
             (*ctx->Driver.WriteStencilSpan)(ctx, x, y, width, stencil, NULL);
          }
       }
@@ -1256,7 +1256,7 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
          const GLstencil clearVal = (ctx->Stencil.Clear & mask);
          const GLint width = ctx->DrawBuffer->Width;
          const GLint height = ctx->DrawBuffer->Height;
-         const GLint x = ctx->DrawBuffer->Xmin;
+         const GLint x = ctx->DrawBuffer->_Xmin;
          GLint y;
          for (y = 0; y < height; y++) {
             GLstencil stencil[MAX_WIDTH];
@@ -1272,7 +1272,7 @@ clear_hardware_stencil_buffer( GLcontext *ctx )
          /* clear whole buffer without masking */
          const GLint width = ctx->DrawBuffer->Width;
          const GLint height = ctx->DrawBuffer->Width;
-         const GLint x = ctx->DrawBuffer->Xmin;
+         const GLint x = ctx->DrawBuffer->_Xmin;
          GLstencil stencil[MAX_WIDTH];
          GLint y, i;
          for (i = 0; i < width; i++) {

src/mesa/swrast/s_triangle.c

@@ -1,4 +1,4 @@
-/* $Id: s_triangle.c,v 1.2 2000/11/05 18:24:41 keithw Exp $ */
+/* $Id: s_triangle.c,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -58,7 +58,7 @@ GLboolean gl_cull_triangle( GLcontext *ctx,
    GLfloat fy = v2->win[1] - v0->win[1];
    GLfloat c = ex*fy-ey*fx;
 
-   if (c * ctx->_backface_sign > 0)
+   if (c * SWRAST_CONTEXT(ctx)->_backface_sign > 0)
       return 0;
    
    return 1;
@@ -2378,7 +2378,7 @@ _swrast_choose_triangle( GLcontext *ctx )
                needLambda = GL_TRUE;
             else
                needLambda = GL_FALSE;
-            if (ctx->Texture._MultiTextureEnabled) {
+            if (swrast->_MultiTextureEnabled) {
                swrast->Triangle = lambda_multitextured_triangle;
 	       dputs("lambda_multitextured_triangle");
             }

src/mesa/swrast/s_tritemp.h

@@ -1,4 +1,4 @@
-/* $Id: s_tritemp.h,v 1.2 2000/11/05 18:24:41 keithw Exp $ */
+/* $Id: s_tritemp.h,v 1.3 2000/11/13 20:02:57 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -96,7 +96,7 @@
    EdgeT eMaj, eTop, eBot;
    GLfloat oneOverArea;
    SWvertex *vMin, *vMid, *vMax;  /* Y(vMin)<=Y(vMid)<=Y(vMax) */
-   float bf = ctx->_backface_sign;
+   float bf = SWRAST_CONTEXT(ctx)->_backface_sign;
 
    /* find the order of the 3 vertices along the Y axis */
    {
@@ -713,8 +713,10 @@
                   dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
 #  endif
                }
-               ffog = FloatToFixed(vLower->fog) * 256 + dfogdx * adjx + dfogdy * adjy + FIXED_HALF;
-               fdfogOuter = SignedFloatToFixed(dfogdy + dxOuter * dfogdx);
+	       {
+		  ffog = FloatToFixed(vLower->fog) * 256 + dfogdx * adjx + dfogdy * adjy + FIXED_HALF;
+		  fdfogOuter = SignedFloatToFixed(dfogdy + dxOuter * dfogdx);
+	       }
 #endif
 #ifdef INTERP_RGB
                fr = (GLfixed)(IntToFixed(vLower->color[0])
@@ -980,7 +982,7 @@
                   zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowOuter);
 #  endif
                   fz += fdzOuter;
-                  ffog += fdfogOuter;
+                  ffog += fdfogOuter; 
 #endif
 #ifdef INTERP_RGB
                   fr += fdrOuter;   fg += fdgOuter;   fb += fdbOuter;

src/mesa/swrast/swrast.h

@@ -150,5 +150,12 @@ _swrast_flush( GLcontext *ctx );
 extern void
 _swrast_InvalidateState( GLcontext *ctx, GLuint new_state );
 
+/* Configure software rasterizer to match hardware rasterizer characteristics:
+ */
+extern void
+_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value );
+
+extern void
+_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value );
 
 #endif

src/mesa/swrast_setup/ss_context.c

@@ -1,4 +1,4 @@
-/* $Id: ss_context.c,v 1.2 2000/11/10 17:45:16 brianp Exp $ */
+/* $Id: ss_context.c,v 1.3 2000/11/13 20:02:58 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -107,10 +107,9 @@ static void
 _swsetup_invalidate_state( GLcontext *ctx, GLuint new_state )
 {
    SScontext *swsetup = SWSETUP_CONTEXT(ctx);
-
+   
    swsetup->NewState |= new_state;
 
-   
    if (new_state & _SWSETUP_NEW_RENDERINDEX) {
       swsetup->Triangle = _swsetup_validate_triangle;
       swsetup->Line = _swsetup_validate_line;

src/mesa/swrast_setup/ss_triangle.c

@@ -36,7 +36,8 @@
 #define SS_OFFSET_BIT	    0x2	
 #define SS_TWOSIDE_BIT	    0x4	
 #define SS_UNFILLED_BIT	    0x10	
-#define SS_MAX_TRIFUNC      0x20
+#define SS_COPY_EXTRAS	    0x20 /* optimization */
+#define SS_MAX_TRIFUNC      0x40
 
 static triangle_func tri_tab[SS_MAX_TRIFUNC];
 static line_func     line_tab[SS_MAX_TRIFUNC];
@@ -112,6 +113,70 @@ static quad_func     quad_tab[SS_MAX_TRIFUNC];
 #define TAG(x) x##_flat_offset_twoside_unfilled
 #include "ss_tritmp.h"
 
+#define IND (0|SS_COPY_EXTRAS)
+#define TAG(x) x##_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_offset_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_OFFSET_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_offset_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_twoside_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_TWOSIDE_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_twoside_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_offset_twoside_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_offset_twoside_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_offset_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_OFFSET_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_offset_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_twoside_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_twoside_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_offset_twoside_unfilled_spec
+#include "ss_tritmp.h"
+
+#define IND (SS_FLAT_BIT|SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_COPY_EXTRAS)
+#define TAG(x) x##_flat_offset_twoside_unfilled_spec
+#include "ss_tritmp.h"
+
 
 void _swsetup_trifuncs_init( GLcontext *ctx )
 {
@@ -133,6 +198,23 @@ void _swsetup_trifuncs_init( GLcontext *ctx )
    init_flat_twoside_unfilled();
    init_offset_twoside_unfilled();
    init_flat_offset_twoside_unfilled();
+
+   init_spec();
+   init_flat_spec();
+   init_offset_spec();
+   init_flat_offset_spec();
+   init_twoside_spec();
+   init_flat_twoside_spec();
+   init_offset_twoside_spec();
+   init_flat_offset_twoside_spec();
+   init_unfilled_spec();
+   init_flat_unfilled_spec();
+   init_offset_unfilled_spec();
+   init_flat_offset_unfilled_spec();
+   init_twoside_unfilled_spec();
+   init_flat_twoside_unfilled_spec();
+   init_offset_twoside_unfilled_spec();
+   init_flat_offset_twoside_unfilled_spec();
 }
 
 
@@ -153,6 +235,11 @@ void _swsetup_choose_trifuncs( GLcontext *ctx )
    if (ctx->Polygon._Unfilled) 
       ind |= SS_UNFILLED_BIT;
 
+   if ((ctx->_TriangleCaps & DD_SEPERATE_SPECULAR) ||
+       ctx->RenderMode == GL_SELECT ||
+       !ctx->Visual.RGBAflag)
+      ind |= SS_COPY_EXTRAS;
+
    swsetup->Triangle = tri_tab[ind];
    swsetup->Line = line_tab[ind];
    swsetup->Points = points_tab[ind];

src/mesa/swrast_setup/ss_tritmp.h

@@ -45,16 +45,24 @@ static void TAG(triangle)(GLcontext *ctx,
 
    if (IND & (SS_TWOSIDE_BIT | SS_FLAT_BIT)) {
       SS_COLOR(c[0], v[0]->color);
-      SS_COLOR(c[1], v[1]->color);
-      SS_COLOR(c[2], v[2]->color);
       
-      SS_SPEC(s[0], v[0]->specular);
-      SS_SPEC(s[1], v[1]->specular);
-      SS_SPEC(s[2], v[2]->specular);
+      if (IND & SS_TWOSIDE_BIT) {
+	 SS_COLOR(c[1], v[1]->color);
+	 SS_COLOR(c[2], v[2]->color);
+      }
+      
+      if (IND & SS_COPY_EXTRAS) {
+	 SS_SPEC(s[0], v[0]->specular);
+	 SS_IND(i[0], v[0]->index);
+
+	 if (IND & SS_TWOSIDE_BIT) {
+	    SS_SPEC(s[1], v[1]->specular);
+	    SS_IND(i[1], v[1]->index);
 
-      SS_IND(i[0], v[0]->index);
-      SS_IND(i[1], v[1]->index);
-      SS_IND(i[2], v[2]->index);
+	    SS_SPEC(s[2], v[2]->specular);
+	    SS_IND(i[2], v[2]->index);
+	 }
+      }
    }
 
    if (IND & (SS_TWOSIDE_BIT | SS_OFFSET_BIT | SS_UNFILLED_BIT))
@@ -82,25 +90,29 @@ static void TAG(triangle)(GLcontext *ctx,
 	       SS_COLOR(v[1]->color, vbcolor[pv]);
 	       SS_COLOR(v[2]->color, vbcolor[pv]);
 
-	       SS_SPEC(v[0]->specular, vbspec[pv]);
-	       SS_SPEC(v[1]->specular, vbspec[pv]);
-	       SS_SPEC(v[2]->specular, vbspec[pv]);
-
-	       SS_IND(v[0]->index, vbindex[pv]);
-	       SS_IND(v[1]->index, vbindex[pv]);
-	       SS_IND(v[2]->index, vbindex[pv]);
+	       if (IND & SS_COPY_EXTRAS) {
+		  SS_SPEC(v[0]->specular, vbspec[pv]);
+		  SS_SPEC(v[1]->specular, vbspec[pv]);
+		  SS_SPEC(v[2]->specular, vbspec[pv]);
+		  
+		  SS_IND(v[0]->index, vbindex[pv]);
+		  SS_IND(v[1]->index, vbindex[pv]);
+		  SS_IND(v[2]->index, vbindex[pv]);
+	       }
 	    } else {
 	       SS_COLOR(v[0]->color, vbcolor[e0]);
 	       SS_COLOR(v[1]->color, vbcolor[e1]);
 	       SS_COLOR(v[2]->color, vbcolor[e2]);
 
-	       SS_SPEC(v[0]->specular, vbspec[e0]);
-	       SS_SPEC(v[1]->specular, vbspec[e1]);
-	       SS_SPEC(v[2]->specular, vbspec[e2]);
+	       if (IND & SS_COPY_EXTRAS) {
+		  SS_SPEC(v[0]->specular, vbspec[e0]);
+		  SS_SPEC(v[1]->specular, vbspec[e1]);
+		  SS_SPEC(v[2]->specular, vbspec[e2]);
 
-	       SS_IND(v[0]->index, vbindex[e0]);
-	       SS_IND(v[1]->index, vbindex[e1]);
-	       SS_IND(v[2]->index, vbindex[e2]);
+		  SS_IND(v[0]->index, vbindex[e0]);
+		  SS_IND(v[1]->index, vbindex[e1]);
+		  SS_IND(v[2]->index, vbindex[e2]);
+	       }
 	    }
 	 }   
       }
@@ -125,23 +137,18 @@ static void TAG(triangle)(GLcontext *ctx,
 	 }
       }
    }
-   else if(IND & SS_FLAT_BIT)
+   else if (IND & SS_FLAT_BIT)
    {
       GLubyte *color = VB->Color[0]->data[pv];
       GLubyte *spec = VB->SecondaryColor[0]->data[pv];
       GLuint index = VB->Index[0]->data[pv];
 
       SS_COLOR(v[0]->color, color);
-      SS_COLOR(v[1]->color, color);
-      SS_COLOR(v[2]->color, color);
       
-      SS_SPEC(v[0]->specular, spec);
-      SS_SPEC(v[1]->specular, spec);
-      SS_SPEC(v[2]->specular, spec);
-
-      SS_IND(v[0]->index, index);
-      SS_IND(v[1]->index, index);
-      SS_IND(v[2]->index, index);
+      if (IND & SS_COPY_EXTRAS) {
+	 SS_SPEC(v[0]->specular, spec);
+	 SS_IND(v[0]->index, index);
+      }
    }
 
    if (mode == GL_POINT) {
@@ -181,16 +188,24 @@ static void TAG(triangle)(GLcontext *ctx,
 
    if (IND & (SS_FLAT_BIT | SS_TWOSIDE_BIT)) {
       SS_COLOR(v[0]->color, c[0]);
-      SS_COLOR(v[1]->color, c[1]);
-      SS_COLOR(v[2]->color, c[2]);
-      
-      SS_SPEC(v[0]->specular, s[0]);
-      SS_SPEC(v[1]->specular, s[1]);
-      SS_SPEC(v[2]->specular, s[2]);
 
-      SS_IND(v[0]->index, i[0]);
-      SS_IND(v[1]->index, i[1]);
-      SS_IND(v[2]->index, i[2]);
+      if (IND & SS_TWOSIDE_BIT) {
+	 SS_COLOR(v[1]->color, c[1]);
+	 SS_COLOR(v[2]->color, c[2]);
+      }
+
+      if (IND & SS_COPY_EXTRAS) {
+	 SS_SPEC(v[0]->specular, s[0]);
+	 SS_IND(v[0]->index, i[0]);
+
+	 if (IND & SS_TWOSIDE_BIT) {
+	    SS_SPEC(v[1]->specular, s[1]);
+	    SS_IND(v[1]->index, i[1]);
+
+	    SS_SPEC(v[2]->specular, s[2]);
+	    SS_IND(v[2]->index, i[2]);
+	 }
+      }
    } 
 }
 
@@ -223,35 +238,26 @@ static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv )
       GLuint index = VB->Index[0]->data[pv];
 
       SS_COLOR(c[0], vert0->color);
-      SS_COLOR(c[1], vert1->color);
-      
-      SS_SPEC(s[0], vert0->specular);
-      SS_SPEC(s[1], vert1->specular);
-
-      SS_IND(i[0], vert0->index);
-      SS_IND(i[1], vert1->index);
-
       SS_COLOR(vert0->color, color);
-      SS_COLOR(vert1->color, color);
-      
-      SS_SPEC(vert0->specular, spec);
-      SS_SPEC(vert1->specular, spec);
 
-      SS_IND(vert0->index, index);
-      SS_IND(vert1->index, index);
+      if (IND & SS_COPY_EXTRAS) {
+	 SS_SPEC(s[0], vert0->specular);
+	 SS_SPEC(vert0->specular, spec);
+	 
+	 SS_IND(i[0], vert0->index);
+	 SS_IND(vert0->index, index);
+      }
    }
 
    _swrast_Line( ctx, vert0, vert1 );
 
    if (IND & SS_FLAT_BIT) {
       SS_COLOR(vert0->color, c[0]);
-      SS_COLOR(vert1->color, c[1]);
       
-      SS_SPEC(vert0->specular, s[0]);
-      SS_SPEC(vert1->specular, s[1]);
-
-      SS_IND(vert0->index, i[0]);
-      SS_IND(vert1->index, i[1]);
+      if (IND & SS_COPY_EXTRAS) {
+	 SS_SPEC(vert0->specular, s[0]);
+	 SS_IND(vert0->index, i[0]);
+      }
    }
 }
 

src/mesa/swrast_setup/ss_vb.c

@@ -165,16 +165,16 @@ _swsetup_choose_rastersetup_func(GLcontext *ctx)
          if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
              ctx->Fog.ColorSumEnabled)
             funcindex |= SPEC;
-
-         if (ctx->Point._Attenuated)
-            funcindex |= EYE;
-
-	 if (ctx->Fog.Enabled)
-	    funcindex |= FOG;
       }
       else {
          funcindex = INDEX;
       }
+
+      if (ctx->Point._Attenuated)
+	 funcindex |= EYE;
+
+      if (ctx->Fog.Enabled)
+	 funcindex |= FOG;
    }
    else {
       /* feedback or section */