Enable multitexturing, fog, texture environment modes. Details:mach64-0-0-2-branch

- Multitexturing tested and working with Quake3 demo and UT.
To get this to work, the vertex setup functions in mach64_vb.c
pre-multiply the texture coordinates by the homogenous coord.
This is how the utah-glx driver does it.  There may still be some
blending/compositing bugs here and there.

- Enables fog only if alpha blending is off (RagePRO can't do both).
A fog enable is silently ignored when alpha blending is on, and enabling
alpha blending disables fog.  There's probably a better way to fallback.
Tested and working with Nate Robins' fog tutorial and the Mesa fog demo.

- Sets texture environment modes.  I'm not sure this bit is totally
correct, but the texenv Mesa demo seems to be working right.  Note that
I've set GL_BLEND to use software fallback.

- The stuff in here on color masks is probably not necessary, as it's
still done with software fallback.  I just cleaned it up a bit as there
was some vestigal r128 code there.

5 files changed, 251 insertions, 34 deletions

diff --git a/xc/lib/GL/mesa/src/drv/mach64/mach64_state.c b/xc/lib/GL/mesa/src/drv/mach64/mach64_state.c
index 46dcba93e..b99a37301 100644
--- a/xc/lib/GL/mesa/src/drv/mach64/mach64_state.c
+++ b/xc/lib/GL/mesa/src/drv/mach64/mach64_state.c
@@ -152,6 +152,7 @@ static void mach64UpdateAlphaMode( GLcontext *ctx )
 	 break;
       }
 
+      s &= ~MACH64_ALPHA_FOG_EN_FOG; /* Can't fog and blend at the same time */
       s |=  MACH64_ALPHA_FOG_EN_ALPHA;
    } else {
       s &= ~MACH64_ALPHA_FOG_EN_ALPHA;
@@ -295,29 +296,48 @@ static void mach64DDClearDepth( GLcontext *ctx, GLclampd d )
 static void mach64UpdateFogAttrib( GLcontext *ctx )
 {
    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
-#if 0
-   CARD32 t = mmesa->setup.tex_cntl_c;
+
+   CARD32 s = mmesa->setup.scale_3d_cntl;
    GLubyte c[4];
    CARD32 col;
 
+   /* Can't fog if blending is on */
+   if ( ctx->Color.BlendEnabled )
+      return;
+
    if ( ctx->FogMode == FOG_FRAGMENT ) {
-      t |=  MACH64_FOG_ENABLE;
+      s |= MACH64_ALPHA_FOG_EN_FOG;
+      s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
+	     MACH64_ALPHA_BLEND_DST_MASK |
+	     MACH64_ALPHA_BLEND_SAT);
+      /* From Utah-glx: "fog color is now dest and fog factor is alpha, so
+       * use GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA"
+       */
+      s |= (MACH64_ALPHA_BLEND_SRC_SRCALPHA | 
+	    MACH64_ALPHA_BLEND_DST_INVSRCALPHA);
+      /* From Utah-glx: "can't use texture alpha when fogging" */
+      s &= ~MACH64_TEX_MAP_AEN;
    } else {
-      t &= ~MACH64_FOG_ENABLE;
+      s &= ~(MACH64_ALPHA_BLEND_SRC_MASK |
+	     MACH64_ALPHA_BLEND_DST_MASK |
+	     MACH64_ALPHA_BLEND_SAT);
+      s |= (MACH64_ALPHA_BLEND_SRC_ONE | 
+	    MACH64_ALPHA_BLEND_DST_ZERO);
+      s &= ~MACH64_ALPHA_FOG_EN_FOG;
    }
 
    FLOAT_RGBA_TO_UBYTE_RGBA( c, ctx->Fog.Color );
    col = mach64PackColor( 4, c[0], c[1], c[2], c[3] );
 
-   if ( mmesa->setup.fog_color_c != col ) {
-      mmesa->setup.fog_color_c = col;
-      mmesa->dirty |= MACH64_UPLOAD_CONTEXT;
+   if ( mmesa->setup.dp_fog_clr != col ) {
+      mmesa->setup.dp_fog_clr = col;
+      mmesa->dirty |= MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_DP_FOG_CLR;
    }
-   if ( mmesa->setup.tex_cntl_c != t ) {
-      mmesa->setup.tex_cntl_c = t;
-      mmesa->dirty |= MACH64_UPLOAD_CONTEXT;
+   if ( mmesa->setup.scale_3d_cntl != s ) {
+      mmesa->setup.scale_3d_cntl = s;
+      mmesa->dirty |= MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_SCALE_3D_CNTL;
    }
-#endif
+
 }
 
 static void mach64DDFogfv( GLcontext *ctx, GLenum pname, const GLfloat *param )
@@ -479,18 +499,19 @@ static void mach64UpdateMasks( GLcontext *ctx )
 {
    mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
 
-#if 0
-   GLuint mask = mach64PackColor( mmesa->BufferSize,
+   if ( !ctx->Color.BlendEnabled ) {
+      GLuint mask = mach64PackColor( mmesa->mach64Screen->cpp,
 				  ctx->Color.ColorMask[RCOMP],
 				  ctx->Color.ColorMask[GCOMP],
 				  ctx->Color.ColorMask[BCOMP],
 				  ctx->Color.ColorMask[ACOMP] );
 
-   if ( mmesa->setup.plane_3d_mask_c != mask ) {
-      mmesa->setup.plane_3d_mask_c = mask;
-      mmesa->dirty |= MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_MASKS;
+      if ( mmesa->setup.dp_write_mask != mask ) {
+	 mmesa->setup.dp_write_mask = mask;
+	 mmesa->dirty |= MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_DP_WRITE_MASK;
    }
-#endif
+   }
+
 }
 
 static GLboolean mach64DDColorMask( GLcontext *ctx,
@@ -502,7 +523,8 @@ static GLboolean mach64DDColorMask( GLcontext *ctx,
    FLUSH_BATCH( mmesa );
    mmesa->new_state |= MACH64_NEW_MASKS;
 
-   return GL_TRUE;
+   return GL_FALSE; /* This forces the software paths to do colormasking. */
+                    /* This function will return void when we use Mesa 3.5 */
 }
 
 
@@ -733,12 +755,12 @@ static void mach64DDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
       FLUSH_BATCH( mmesa );
       mmesa->new_state |= MACH64_NEW_RENDER;
       break;
-
+#endif
    case GL_FOG:
       FLUSH_BATCH( mmesa );
       mmesa->new_state |= MACH64_NEW_FOG;
       break;
-
+#if 0
    case GL_INDEX_LOGIC_OP:
    case GL_COLOR_LOGIC_OP:
       FLUSH_BATCH( mmesa );
@@ -754,14 +776,13 @@ static void mach64DDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
       mmesa->scissor = state;
       mmesa->new_state |= MACH64_NEW_CLIP;
       break;
-
+#endif
    case GL_TEXTURE_1D:
    case GL_TEXTURE_2D:
    case GL_TEXTURE_3D:
       FLUSH_BATCH( mmesa );
       mmesa->new_state |= MACH64_NEW_TEXTURE;
       break;
-#endif
 
    default:
       return;
@@ -894,10 +915,10 @@ void mach64DDUpdateHWState( GLcontext *ctx )
 #if 0
       if ( new_state & MACH64_NEW_CULL )
 	 mach64UpdateCull( ctx );
-
+#endif
       if ( new_state & MACH64_NEW_MASKS )
 	 mach64UpdateMasks( ctx );
-
+#if 0
       if ( new_state & MACH64_NEW_RENDER )
 	 mach64UpdateRenderAttrib( ctx );
 #endif
@@ -1091,7 +1112,9 @@ void mach64DDInitState( mach64ContextPtr mmesa )
 			    MACH64_COMP_BLEND_NEAREST |
 			    MACH64_COMP_FILTER_NEAREST |
 			    /* MACH64_TEXTURE_TILING | */
-			    /* MACH64_TEX_ST_DIRECT | */
+#ifdef MACH64_PREMULT_TEXCOORDS
+			    MACH64_TEX_ST_DIRECT | 
+#endif
 			    MACH64_TEX_SRC_LOCAL |
 			    MACH64_TEX_UNCOMPRESSED |
 			    MACH64_TEX_CACHE_FLUSH |
diff --git a/xc/lib/GL/mesa/src/drv/mach64/mach64_tex.c b/xc/lib/GL/mesa/src/drv/mach64/mach64_tex.c
index d4574193e..b1ce9dd50 100644
--- a/xc/lib/GL/mesa/src/drv/mach64/mach64_tex.c
+++ b/xc/lib/GL/mesa/src/drv/mach64/mach64_tex.c
@@ -861,6 +861,7 @@ static void mach64UpdateTextureStage( GLcontext *ctx, int unit )
    struct gl_texture_object *tObj;
    mach64TextureObjectPtr t;
    GLuint enabled;
+   GLuint s = mmesa->setup.scale_3d_cntl;
 
    if ( MACH64_DEBUG & DEBUG_VERBOSE_API ) {
       fprintf( stderr, "%s( %p, %d )\n",
@@ -885,6 +886,101 @@ static void mach64UpdateTextureStage( GLcontext *ctx, int unit )
    /* We definately have a valid texture now */
    t = tObj->DriverData;
 
+   if ( unit == 0 ) {
+      s &= ~MACH64_TEX_LIGHT_FCN_MASK;
+
+      /* Set the texture environment state 
+       * Need to verify these are working correctly, but the
+       * texenv Mesa demo seems to work.
+       */
+      switch ( ctx->Texture.Unit[source].EnvMode ) {
+      case GL_REPLACE:
+	 switch ( tObj->Image[0]->Format ) {
+	 case GL_ALPHA:
+	    s |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	    break;
+	 default:
+	    s |= MACH64_TEX_LIGHT_FCN_REPLACE;
+	    break;
+	 }
+	 break;
+      case GL_MODULATE:
+	 s |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	 break;
+      case GL_DECAL:
+	 switch ( tObj->Image[0]->Format ) {
+	 case GL_RGBA: 
+	    s |= MACH64_TEX_LIGHT_FCN_ALPHA_DECAL;
+	    break;
+	 case GL_RGB:
+	    s |= MACH64_TEX_LIGHT_FCN_REPLACE;
+	    break;
+	 default: /* undefined */
+	    s |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	    break;
+	 }
+	 break;
+      case GL_BLEND:
+	 switch ( tObj->Image[0]->Format ) {
+	 case GL_ALPHA:
+	    s |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	    break;
+	 default:
+	    /* Most blending modes not supported by RagePRO, use software */
+	    mmesa->Fallback |= MACH64_FALLBACK_TEXTURE;
+	    mmesa->setup.scale_3d_cntl |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	    break;
+	 }
+      default:
+	 s |= MACH64_TEX_LIGHT_FCN_MODULATE;
+	 break;
+      }
+
+      if ( mmesa->setup.scale_3d_cntl != s ) {
+	 mmesa->setup.scale_3d_cntl = s;
+	 mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
+      }
+
+   } else {
+      /* blend = 0, modulate = 1 - initialize to blend */
+      mmesa->setup.tex_cntl &= ~MACH64_COMP_COMBINE_MODULATE;
+      /* Set the texture composite function for multitexturing*/
+      switch ( ctx->Texture.Unit[source].EnvMode ) {
+      case GL_BLEND:
+	 switch ( tObj->Image[0]->Format ) {
+	 case GL_ALPHA:
+	    mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_MODULATE;
+	    break;
+	 default:
+	    mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_BLEND;
+	    break;
+	 }
+	 break;
+      case GL_MODULATE:
+	 mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_MODULATE;
+	 break;
+      case GL_REPLACE:
+	 switch ( tObj->Image[0]->Format ) {
+	 case GL_ALPHA:
+	    mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_MODULATE;
+	    break;
+	 default: /* not supported by RagePRO */
+	    mmesa->Fallback |= MACH64_FALLBACK_TEXTURE;
+	    mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_MODULATE;
+	    break;
+	 }
+	 break;
+      case GL_DECAL:
+      default: /* not supported by RagePRO */
+	 mmesa->Fallback |= MACH64_FALLBACK_TEXTURE;
+	 mmesa->setup.tex_cntl |= MACH64_COMP_COMBINE_MODULATE;
+	 break;
+      }
+   }
+
+   /* This code is from r128, but I'm leaving it here for now as
+    * a reference.
+    */
 #if 0
    if ( unit == 0 ) {
       combine = INPUT_INTERP;
@@ -1189,11 +1285,6 @@ static void mach64UpdateTextureObject( GLcontext *ctx, int unit )
 	 s |= MACH64_TEX_MAP_AEN;
       }
 
-      if ( mmesa->setup.scale_3d_cntl != s ) {
-	 mmesa->setup.scale_3d_cntl = s;
-	 mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
-      }
-
       mmesa->setup.tex_cntl &= ~(MACH64_TEXTURE_CLAMP_S |
 				 MACH64_TEXTURE_CLAMP_T |
 				 MACH64_SECONDARY_STW);
@@ -1209,6 +1300,10 @@ static void mach64UpdateTextureObject( GLcontext *ctx, int unit )
 				      (t->maxLog2    << 4) |
 				      (t->heightLog2 << 8));
    } else {
+      
+      /* Enable texture mapping mode */
+      s &= ~MACH64_TEXTURE_DISABLE;
+
       d &= ~MACH64_COMPOSITE_PIX_WIDTH_MASK;
       d |= (t->textureFormat << 4);
 
@@ -1218,6 +1313,17 @@ static void mach64UpdateTextureObject( GLcontext *ctx, int unit )
       mmesa->setup.tex_cntl |= (MACH64_TEXTURE_COMPOSITE |
 				MACH64_SECONDARY_STW);
 
+      if ( t->BilinearMin ) {
+	 s |= MACH64_COMP_BLEND_BILINEAR;
+      } else {
+	 s &= ~MACH64_COMP_BLEND_BILINEAR;
+      }
+      if ( t->BilinearMag ) {
+	 s |=  MACH64_COMP_FILTER_BILINEAR;
+      } else {
+	 s &= ~MACH64_COMP_FILTER_BILINEAR;
+      }
+      
       if ( t->hasAlpha ) {
 	 mmesa->setup.tex_cntl |= MACH64_COMP_ALPHA;
       }
@@ -1233,6 +1339,11 @@ static void mach64UpdateTextureObject( GLcontext *ctx, int unit )
 				      (t->heightLog2 << 24));
    }
 
+   if ( mmesa->setup.scale_3d_cntl != s ) {
+      mmesa->setup.scale_3d_cntl = s;
+      mmesa->dirty |= MACH64_UPLOAD_SCALE_3D_CNTL;
+   }
+
    if ( mmesa->setup.dp_pix_width != d ) {
       mmesa->setup.dp_pix_width = d;
       mmesa->dirty |= MACH64_UPLOAD_DP_PIX_WIDTH;
diff --git a/xc/lib/GL/mesa/src/drv/mach64/mach64_tris.h b/xc/lib/GL/mesa/src/drv/mach64/mach64_tris.h
index 92e4c3b35..d0398bfa1 100644
--- a/xc/lib/GL/mesa/src/drv/mach64/mach64_tris.h
+++ b/xc/lib/GL/mesa/src/drv/mach64/mach64_tris.h
@@ -97,6 +97,12 @@ static __inline void mach64_draw_triangle( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_1_ARGB, v0->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_1_X_Y, (xx[0] << 16) | (yy[0] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_S, v0->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_T, v0->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_W, v0->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_VERTEX_2_S, v1->ui[6] );
    MACH64_WRITE( MACH64_VERTEX_2_T, v1->ui[7] );
    MACH64_WRITE( MACH64_VERTEX_2_W, v1->ui[3] );
@@ -105,6 +111,12 @@ static __inline void mach64_draw_triangle( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_2_ARGB, v1->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_2_X_Y, (xx[1] << 16) | (yy[1] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_S, v1->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_T, v1->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_W, v1->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_VERTEX_3_S, v2->ui[6] );
    MACH64_WRITE( MACH64_VERTEX_3_T, v2->ui[7] );
    MACH64_WRITE( MACH64_VERTEX_3_W, v2->ui[3] );
@@ -113,6 +125,12 @@ static __inline void mach64_draw_triangle( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_3_ARGB, v2->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_3_X_Y, (xx[2] << 16) | (yy[2] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_S, v2->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_T, v2->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_W, v2->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_ONE_OVER_AREA_UC, *(GLuint *)&ooa );
 
    UNLOCK_HARDWARE( mmesa );
@@ -168,6 +186,12 @@ static __inline void mach64_draw_quad( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_1_ARGB, v0->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_1_X_Y, (xx[0] << 16) | (yy[0] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_S, v0->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_T, v0->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_W, v0->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_VERTEX_2_S, v1->ui[6] );
    MACH64_WRITE( MACH64_VERTEX_2_T, v1->ui[7] );
    MACH64_WRITE( MACH64_VERTEX_2_W, v1->ui[3] );
@@ -176,6 +200,12 @@ static __inline void mach64_draw_quad( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_2_ARGB, v1->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_2_X_Y, (xx[1] << 16) | (yy[1] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_S, v1->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_T, v1->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_2_SECONDARY_W, v1->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_VERTEX_3_S, v3->ui[6] );
    MACH64_WRITE( MACH64_VERTEX_3_T, v3->ui[7] );
    MACH64_WRITE( MACH64_VERTEX_3_W, v3->ui[3] );
@@ -184,6 +214,12 @@ static __inline void mach64_draw_quad( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_3_ARGB, v3->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_3_X_Y, (xx[2] << 16) | (yy[2] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_S, v3->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_T, v3->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_3_SECONDARY_W, v3->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_ONE_OVER_AREA_UC, *(GLuint *)&ooa );
 
    xx[0] = (GLint)(v2->v.x * 4);
@@ -201,6 +237,12 @@ static __inline void mach64_draw_quad( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_VERTEX_1_ARGB, v2->ui[4] );
    MACH64_WRITE( MACH64_VERTEX_1_X_Y, (xx[0] << 16) | (yy[0] & 0xffff) );
 
+   if (mmesa->multitex) {
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_S, v2->ui[8] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_T, v2->ui[9] );
+      MACH64_WRITE( MACH64_VERTEX_1_SECONDARY_W, v2->ui[10] );
+   }
+
    MACH64_WRITE( MACH64_ONE_OVER_AREA_UC, *(GLuint *)&ooa );
 
    UNLOCK_HARDWARE( mmesa );
@@ -211,7 +253,6 @@ static __inline void mach64_draw_line( mach64ContextPtr mmesa,
 				       mach64Vertex *tmp1,
 				       float width )
 {
-#if 1
    GLcontext *ctx = mmesa->glCtx;
    GLint vertsize = mmesa->vertsize;
 #if 0
@@ -329,14 +370,12 @@ static __inline void mach64_draw_line( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_ONE_OVER_AREA_UC, *(GLuint *)&ooa );
 
    UNLOCK_HARDWARE( mmesa );
-#endif
 }
 
 static __inline void mach64_draw_point( mach64ContextPtr mmesa,
 					mach64Vertex *tmp,
 					float sz )
 {
-#if 1
    GLcontext *ctx = mmesa->glCtx;
    GLint vertsize = mmesa->vertsize;
 #if 0
@@ -417,7 +456,6 @@ static __inline void mach64_draw_point( mach64ContextPtr mmesa,
    MACH64_WRITE( MACH64_ONE_OVER_AREA_UC, *(GLuint *)&ooa );
 
    UNLOCK_HARDWARE( mmesa );
-#endif
 }
 
 #endif
diff --git a/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.c b/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.c
index b979ffe0f..4310d8b48 100644
--- a/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.c
+++ b/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.c
@@ -37,6 +37,7 @@
 #include "mem.h"
 #include "stages.h"
 
+#ifndef MACH64_PREMULT_TEXCOORDS
 #define TEX0								\
 do {									\
    v->v.tu0 = tc0[i][0];						\
@@ -48,6 +49,7 @@ do {									\
    v->v.tu1 = tc1[i][0];						\
    v->v.tv1 = tc1[i][1];						\
 } while (0)
+#endif /* MACH64_PREMULT_TEXCOORDS */
 
 #define SPC								\
 do {									\
@@ -72,6 +74,43 @@ do {									\
    v->v.color.alpha = col[3];						\
 } while (0)
 
+#ifdef MACH64_PREMULT_TEXCOORDS
+#define TEX0								\
+do {									\
+   GLfloat *win = VB->Win.data[i];					\
+   v->v.tu0 = tc0[i][0];						\
+   v->v.tv0 = tc0[i][1];						\
+   v->v.rhw = win[3];		                	      		\
+   v->v.tu0 *= v->v.rhw;                                                \
+   v->v.tv0 *= v->v.rhw;                                                \
+   if ( VB->TexCoordPtr[0]->size == 4 )                                 \
+      v->v.rhw *= tc0[i][3];                                            \
+} while (0)
+
+#define TEX1								\
+do {									\
+   GLfloat *win = VB->Win.data[i];					\
+   v->v.tu1 = tc1[i][0];						\
+   v->v.tv1 = tc1[i][1];						\
+   v->v.rhw2 = win[3];                                                  \
+   v->v.tu1 *= v->v.rhw2;                                               \
+   v->v.tv1 *= v->v.rhw2;                                               \
+   if ( VB->TexCoordPtr[1]->size == 4 )                                 \
+      v->v.rhw2 *= tc1[i][3];                                           \
+} while (0)
+
+#define COORD								\
+do {									\
+   GLfloat *win = VB->Win.data[i];					\
+   v->v.x =   win[0] + xoffset;						\
+   v->v.y = - win[1] + yoffset;						\
+   v->v.z =   win[2];							\
+} while (0)
+
+#define TEX0_4
+
+#else
+
 #define TEX0_4								\
 do {									\
    if (VB->TexCoordPtr[0]->size == 4) {					\
@@ -95,6 +134,8 @@ do {									\
    v->v.rhw = win[3];							\
 } while (0)
 
+#endif /* MACH64_PREMULT_TEXCOORDS */
+
 #define NOP
 
 /* Setup the mach64 vertex buffer entries */
diff --git a/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.h b/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.h
index cbe53de35..6523e8af9 100644
--- a/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.h
+++ b/xc/lib/GL/mesa/src/drv/mach64/mach64_vb.h
@@ -34,6 +34,9 @@
 
 #ifdef GLX_DIRECT_RENDERING
 
+/* premultiply texture coordinates by homogenous coordinate */
+#define MACH64_PREMULT_TEXCOORDS
+
 /* This is endian-specific.  PPC will need to change this.
  */
 typedef struct {
@@ -58,6 +61,7 @@ typedef struct {
    mach64_color_t specular;	/* Specular color (alpha is fog) */
    GLfloat tu0, tv0;		/* Texture 0 coordinates */
    GLfloat tu1, tv1;		/* Texture 1 coordinates */
+   GLfloat rhw2;		/* Reciprocal homogeneous w2 */
 } mach64_vertex;
 
 /* The fastpath code still expects a 16-float stride vertex.