mesa: rework matrix statevar enums to remove excessive branching in fetch_state

Instead of having $matrix and $modifier as separate enums, combine them
to 1 enum $matrix_$modifier.

Reviewed-by: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6946>

src/compiler/glsl/builtin_variables.cpp

@@ -192,56 +192,40 @@ static const struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements
    {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW},
 };
 
-#define MATRIX(name, statevar, modifier)				\
+#define MATRIX(name, statevar)				\
    static const struct gl_builtin_uniform_element name ## _elements[] = { \
-      { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\
+      { NULL, { statevar, 0, 0, 0, 0}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\
+      { NULL, { statevar, 0, 1, 1, 0}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\
+      { NULL, { statevar, 0, 2, 2, 0}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\
+      { NULL, { statevar, 0, 3, 3, 0}, SWIZZLE_XYZW },		\
    }
 
-MATRIX(gl_ModelViewMatrix,
+MATRIX(gl_ModelViewMatrix, STATE_MODELVIEW_MATRIX_TRANSPOSE);
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
+MATRIX(gl_ModelViewMatrixInverse, STATE_MODELVIEW_MATRIX_INVTRANS);
-MATRIX(gl_ModelViewMatrixInverse,
+MATRIX(gl_ModelViewMatrixTranspose, STATE_MODELVIEW_MATRIX);
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
+MATRIX(gl_ModelViewMatrixInverseTranspose, STATE_MODELVIEW_MATRIX_INVERSE);
-MATRIX(gl_ModelViewMatrixTranspose,
-       STATE_MODELVIEW_MATRIX, 0);
-MATRIX(gl_ModelViewMatrixInverseTranspose,
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
 
-MATRIX(gl_ProjectionMatrix,
+MATRIX(gl_ProjectionMatrix, STATE_PROJECTION_MATRIX_TRANSPOSE);
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
+MATRIX(gl_ProjectionMatrixInverse, STATE_PROJECTION_MATRIX_INVTRANS);
-MATRIX(gl_ProjectionMatrixInverse,
+MATRIX(gl_ProjectionMatrixTranspose, STATE_PROJECTION_MATRIX);
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
+MATRIX(gl_ProjectionMatrixInverseTranspose, STATE_PROJECTION_MATRIX_INVERSE);
-MATRIX(gl_ProjectionMatrixTranspose,
-       STATE_PROJECTION_MATRIX, 0);
-MATRIX(gl_ProjectionMatrixInverseTranspose,
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
 
-MATRIX(gl_ModelViewProjectionMatrix,
+MATRIX(gl_ModelViewProjectionMatrix, STATE_MVP_MATRIX_TRANSPOSE);
-       STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
+MATRIX(gl_ModelViewProjectionMatrixInverse, STATE_MVP_MATRIX_INVTRANS);
-MATRIX(gl_ModelViewProjectionMatrixInverse,
+MATRIX(gl_ModelViewProjectionMatrixTranspose, STATE_MVP_MATRIX);
-       STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
+MATRIX(gl_ModelViewProjectionMatrixInverseTranspose, STATE_MVP_MATRIX_INVERSE);
-MATRIX(gl_ModelViewProjectionMatrixTranspose,
-       STATE_MVP_MATRIX, 0);
-MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
-       STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
 
-MATRIX(gl_TextureMatrix,
+MATRIX(gl_TextureMatrix, STATE_TEXTURE_MATRIX_TRANSPOSE);
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
+MATRIX(gl_TextureMatrixInverse, STATE_TEXTURE_MATRIX_INVTRANS);
-MATRIX(gl_TextureMatrixInverse,
+MATRIX(gl_TextureMatrixTranspose, STATE_TEXTURE_MATRIX);
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
+MATRIX(gl_TextureMatrixInverseTranspose, STATE_TEXTURE_MATRIX_INVERSE);
-MATRIX(gl_TextureMatrixTranspose,
-       STATE_TEXTURE_MATRIX, 0);
-MATRIX(gl_TextureMatrixInverseTranspose,
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
 
 static const struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
+   { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 0, 0, 0},
      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
+   { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 1, 1, 0},
      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
+   { NULL, { STATE_MODELVIEW_MATRIX_INVERSE, 0, 2, 2, 0},
      MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
 };
 

src/mesa/main/ffvertex_prog.c

@@ -722,8 +722,8 @@ static struct ureg get_eye_position( struct tnl_program *p )
 	 emit_matrix_transform_vec4(p, p->eye_position, modelview, pos);
       }
       else {
-	 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
+	 register_matrix_param5( p, STATE_MODELVIEW_MATRIX_TRANSPOSE, 0, 0, 3,
-				 STATE_MATRIX_TRANSPOSE, modelview );
+				 0, modelview );
 
 	 emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
       }
@@ -782,8 +782,8 @@ static struct ureg get_transformed_normal( struct tnl_program *p )
       struct ureg transformed_normal = reserve_temp(p);
 
       if (p->state->need_eye_coords) {
-         register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 2,
+         register_matrix_param5( p, STATE_MODELVIEW_MATRIX_INVTRANS, 0, 0, 2,
-                                 STATE_MATRIX_INVTRANS, mvinv );
+                                 0, mvinv );
 
          /* Transform to eye space:
           */
@@ -827,8 +827,8 @@ static void build_hpos( struct tnl_program *p )
       emit_matrix_transform_vec4( p, hpos, mvp, pos );
    }
    else {
-      register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
+      register_matrix_param5( p, STATE_MVP_MATRIX_TRANSPOSE, 0, 0, 3,
-			      STATE_MATRIX_TRANSPOSE, mvp );
+			      0, mvp );
       emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
    }
 }
@@ -1490,8 +1490,8 @@ static void build_texture_transform( struct tnl_program *p )
 	       emit_matrix_transform_vec4( p, out, texmat, in );
 	    }
 	    else {
-	       register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
+	       register_matrix_param5( p, STATE_TEXTURE_MATRIX_TRANSPOSE, i, 0, 3,
-				       STATE_MATRIX_TRANSPOSE, texmat );
+				       0, texmat );
 	       emit_transpose_matrix_transform_vec4( p, out, texmat, in );
 	    }
 	 }

src/mesa/program/prog_statevars.c

@@ -45,6 +45,31 @@
 
 #define ONE_DIV_SQRT_LN2 (1.201122408786449815)
 
+static ALWAYS_INLINE void
+copy_matrix(float *value, const float *m, unsigned firstRow, unsigned lastRow)
+{
+   unsigned i, row;
+
+   assert(firstRow < 4);
+   assert(lastRow < 4);
+
+   for (i = 0, row = firstRow; row <= lastRow; row++) {
+      value[i++] = m[row + 0];
+      value[i++] = m[row + 4];
+      value[i++] = m[row + 8];
+      value[i++] = m[row + 12];
+   }
+}
+
+static ALWAYS_INLINE void
+copy_matrix_transposed(float *value, const float *m, unsigned firstRow, unsigned lastRow)
+{
+   assert(firstRow < 4);
+   assert(lastRow < 4);
+
+   memcpy(value, &m[firstRow * 4],
+          (lastRow - firstRow + 1) * 4 * sizeof(GLfloat));
+}
 
 /**
  * Use the list of tokens in the state[] array to find global GL state
@@ -284,77 +309,136 @@ fetch_state(struct gl_context *ctx, const gl_state_index16 state[],
       value[2] = ctx->Point.Params[2];
       value[3] = 1.0F;
       return;
-   case STATE_MODELVIEW_MATRIX:
+   /* state[0] = modelview, projection, texture, etc. */
-   case STATE_PROJECTION_MATRIX:
+   /* state[1] = which texture matrix or program matrix */
-   case STATE_MVP_MATRIX:
+   /* state[2] = first row to fetch */
-   case STATE_TEXTURE_MATRIX:
+   /* state[3] = last row to fetch */
-   case STATE_PROGRAM_MATRIX:
+   case STATE_MODELVIEW_MATRIX: {
-      {
+      const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top;
-         /* state[0] = modelview, projection, texture, etc. */
+      copy_matrix(value, matrix->m, state[2], state[3]);
-         /* state[1] = which texture matrix or program matrix */
-         /* state[2] = first row to fetch */
-         /* state[3] = last row to fetch */
-         /* state[4] = transpose, inverse or invtrans */
-         const GLmatrix *matrix;
-         const gl_state_index mat = state[0];
-         const GLuint index = (GLuint) state[1];
-         const GLuint firstRow = (GLuint) state[2];
-         const GLuint lastRow = (GLuint) state[3];
-         const gl_state_index modifier = state[4];
-         const GLfloat *m;
-         GLuint row, i;
-         assert(firstRow < 4);
-         assert(lastRow < 4);
-         if (mat == STATE_MODELVIEW_MATRIX) {
-            matrix = ctx->ModelviewMatrixStack.Top;
-         }
-         else if (mat == STATE_PROJECTION_MATRIX) {
-            matrix = ctx->ProjectionMatrixStack.Top;
-         }
-         else if (mat == STATE_MVP_MATRIX) {
-            matrix = &ctx->_ModelProjectMatrix;
-         }
-         else if (mat == STATE_TEXTURE_MATRIX) {
-            assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
-            matrix = ctx->TextureMatrixStack[index].Top;
-         }
-         else if (mat == STATE_PROGRAM_MATRIX) {
-            assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
-            matrix = ctx->ProgramMatrixStack[index].Top;
-         }
-         else {
-            unreachable("Bad matrix name in fetch_state()");
-            return;
-         }
-         if (modifier == STATE_MATRIX_INVERSE ||
-             modifier == STATE_MATRIX_INVTRANS) {
-            /* Be sure inverse is up to date:
-	     */
-	    _math_matrix_analyse( (GLmatrix*) matrix );
-            m = matrix->inv;
-         }
-         else {
-            m = matrix->m;
-         }
-         if (modifier == STATE_MATRIX_TRANSPOSE ||
-             modifier == STATE_MATRIX_INVTRANS) {
-            for (i = 0, row = firstRow; row <= lastRow; row++) {
-               value[i++] = m[row * 4 + 0];
-               value[i++] = m[row * 4 + 1];
-               value[i++] = m[row * 4 + 2];
-               value[i++] = m[row * 4 + 3];
-            }
-         }
-         else {
-            for (i = 0, row = firstRow; row <= lastRow; row++) {
-               value[i++] = m[row + 0];
-               value[i++] = m[row + 4];
-               value[i++] = m[row + 8];
-               value[i++] = m[row + 12];
-            }
-         }
-      }
       return;
+   }
+   case STATE_MODELVIEW_MATRIX_INVERSE: {
+      const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_MODELVIEW_MATRIX_TRANSPOSE: {
+      const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top;
+      copy_matrix_transposed(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_MODELVIEW_MATRIX_INVTRANS: {
+      const GLmatrix *matrix = ctx->ModelviewMatrixStack.Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix_transposed(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_PROJECTION_MATRIX: {
+      const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top;
+      copy_matrix(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_PROJECTION_MATRIX_INVERSE: {
+      const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_PROJECTION_MATRIX_TRANSPOSE: {
+      const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top;
+      copy_matrix_transposed(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_PROJECTION_MATRIX_INVTRANS: {
+      const GLmatrix *matrix = ctx->ProjectionMatrixStack.Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix_transposed(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_MVP_MATRIX: {
+      const GLmatrix *matrix = &ctx->_ModelProjectMatrix;
+      copy_matrix(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_MVP_MATRIX_INVERSE: {
+      const GLmatrix *matrix = &ctx->_ModelProjectMatrix;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_MVP_MATRIX_TRANSPOSE: {
+      const GLmatrix *matrix = &ctx->_ModelProjectMatrix;
+      copy_matrix_transposed(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_MVP_MATRIX_INVTRANS: {
+      const GLmatrix *matrix = &ctx->_ModelProjectMatrix;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix_transposed(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_TEXTURE_MATRIX: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
+      const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top;
+      copy_matrix(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_TEXTURE_MATRIX_INVERSE: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
+      const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_TEXTURE_MATRIX_TRANSPOSE: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
+      const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top;
+      copy_matrix_transposed(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_TEXTURE_MATRIX_INVTRANS: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->TextureMatrixStack));
+      const GLmatrix *matrix = ctx->TextureMatrixStack[index].Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix_transposed(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_PROGRAM_MATRIX: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
+      const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top;
+      copy_matrix(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_PROGRAM_MATRIX_INVERSE: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
+      const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix(value, matrix->inv, state[2], state[3]);
+      return;
+   }
+   case STATE_PROGRAM_MATRIX_TRANSPOSE: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
+      const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top;
+      copy_matrix_transposed(value, matrix->m, state[2], state[3]);
+      return;
+   }
+   case STATE_PROGRAM_MATRIX_INVTRANS: {
+      const GLuint index = (GLuint) state[1];
+      assert(index < ARRAY_SIZE(ctx->ProgramMatrixStack));
+      const GLmatrix *matrix = ctx->ProgramMatrixStack[index].Top;
+      _math_matrix_analyse((GLmatrix*)matrix); /* Be sure inverse is up to date: */
+      copy_matrix_transposed(value, matrix->inv, state[2], state[3]);
+      return;
+   }
    case STATE_NUM_SAMPLES:
       val[0].i = MAX2(1, _mesa_geometric_samples(ctx->DrawBuffer));
       return;
@@ -685,14 +769,29 @@ _mesa_program_state_flags(const gl_state_index16 state[STATE_LENGTH])
       return _NEW_POINT;
 
    case STATE_MODELVIEW_MATRIX:
+   case STATE_MODELVIEW_MATRIX_INVERSE:
+   case STATE_MODELVIEW_MATRIX_TRANSPOSE:
+   case STATE_MODELVIEW_MATRIX_INVTRANS:
       return _NEW_MODELVIEW;
    case STATE_PROJECTION_MATRIX:
+   case STATE_PROJECTION_MATRIX_INVERSE:
+   case STATE_PROJECTION_MATRIX_TRANSPOSE:
+   case STATE_PROJECTION_MATRIX_INVTRANS:
       return _NEW_PROJECTION;
    case STATE_MVP_MATRIX:
+   case STATE_MVP_MATRIX_INVERSE:
+   case STATE_MVP_MATRIX_TRANSPOSE:
+   case STATE_MVP_MATRIX_INVTRANS:
       return _NEW_MODELVIEW | _NEW_PROJECTION;
    case STATE_TEXTURE_MATRIX:
+   case STATE_TEXTURE_MATRIX_INVERSE:
+   case STATE_TEXTURE_MATRIX_TRANSPOSE:
+   case STATE_TEXTURE_MATRIX_INVTRANS:
       return _NEW_TEXTURE_MATRIX;
    case STATE_PROGRAM_MATRIX:
+   case STATE_PROGRAM_MATRIX_INVERSE:
+   case STATE_PROGRAM_MATRIX_TRANSPOSE:
+   case STATE_PROGRAM_MATRIX_INVTRANS:
       return _NEW_TRACK_MATRIX;
 
    case STATE_NUM_SAMPLES:
@@ -812,26 +911,63 @@ append_token(char *dst, gl_state_index k)
    case STATE_MODELVIEW_MATRIX:
       append(dst, "matrix.modelview");
       break;
+   case STATE_MODELVIEW_MATRIX_INVERSE:
+      append(dst, "matrix.modelview.inverse");
+      break;
+   case STATE_MODELVIEW_MATRIX_TRANSPOSE:
+      append(dst, "matrix.modelview.transpose");
+      break;
+   case STATE_MODELVIEW_MATRIX_INVTRANS:
+      append(dst, "matrix.modelview.invtrans");
+      break;
    case STATE_PROJECTION_MATRIX:
       append(dst, "matrix.projection");
       break;
+   case STATE_PROJECTION_MATRIX_INVERSE:
+      append(dst, "matrix.projection.inverse");
+      break;
+   case STATE_PROJECTION_MATRIX_TRANSPOSE:
+      append(dst, "matrix.projection.transpose");
+      break;
+   case STATE_PROJECTION_MATRIX_INVTRANS:
+      append(dst, "matrix.projection.invtrans");
+      break;
    case STATE_MVP_MATRIX:
       append(dst, "matrix.mvp");
       break;
+   case STATE_MVP_MATRIX_INVERSE:
+      append(dst, "matrix.mvp.inverse");
+      break;
+   case STATE_MVP_MATRIX_TRANSPOSE:
+      append(dst, "matrix.mvp.transpose");
+      break;
+   case STATE_MVP_MATRIX_INVTRANS:
+      append(dst, "matrix.mvp.invtrans");
+      break;
    case STATE_TEXTURE_MATRIX:
       append(dst, "matrix.texture");
       break;
+   case STATE_TEXTURE_MATRIX_INVERSE:
+      append(dst, "matrix.texture.inverse");
+      break;
+   case STATE_TEXTURE_MATRIX_TRANSPOSE:
+      append(dst, "matrix.texture.transpose");
+      break;
+   case STATE_TEXTURE_MATRIX_INVTRANS:
+      append(dst, "matrix.texture.invtrans");
+      break;
    case STATE_PROGRAM_MATRIX:
       append(dst, "matrix.program");
       break;
-   case STATE_MATRIX_INVERSE:
+   case STATE_PROGRAM_MATRIX_INVERSE:
-      append(dst, ".inverse");
+      append(dst, "matrix.program.inverse");
       break;
-   case STATE_MATRIX_TRANSPOSE:
+   case STATE_PROGRAM_MATRIX_TRANSPOSE:
-      append(dst, ".transpose");
+      append(dst, "matrix.program.transpose");
+      break;
+   case STATE_PROGRAM_MATRIX_INVTRANS:
+      append(dst, "matrix.program.invtrans");
       break;
-   case STATE_MATRIX_INVTRANS:
-      append(dst, ".invtrans");
       break;
    case STATE_AMBIENT:
       append(dst, ".ambient");
@@ -1032,10 +1168,25 @@ _mesa_program_state_string(const gl_state_index16 state[STATE_LENGTH])
       append(str, ".plane");
       break;
    case STATE_MODELVIEW_MATRIX:
+   case STATE_MODELVIEW_MATRIX_INVERSE:
+   case STATE_MODELVIEW_MATRIX_TRANSPOSE:
+   case STATE_MODELVIEW_MATRIX_INVTRANS:
    case STATE_PROJECTION_MATRIX:
+   case STATE_PROJECTION_MATRIX_INVERSE:
+   case STATE_PROJECTION_MATRIX_TRANSPOSE:
+   case STATE_PROJECTION_MATRIX_INVTRANS:
    case STATE_MVP_MATRIX:
+   case STATE_MVP_MATRIX_INVERSE:
+   case STATE_MVP_MATRIX_TRANSPOSE:
+   case STATE_MVP_MATRIX_INVTRANS:
    case STATE_TEXTURE_MATRIX:
+   case STATE_TEXTURE_MATRIX_INVERSE:
+   case STATE_TEXTURE_MATRIX_TRANSPOSE:
+   case STATE_TEXTURE_MATRIX_INVTRANS:
    case STATE_PROGRAM_MATRIX:
+   case STATE_PROGRAM_MATRIX_INVERSE:
+   case STATE_PROGRAM_MATRIX_TRANSPOSE:
+   case STATE_PROGRAM_MATRIX_INVTRANS:
       {
          /* state[0] = modelview, projection, texture, etc. */
          /* state[1] = which texture matrix or program matrix */
@@ -1046,13 +1197,10 @@ _mesa_program_state_string(const gl_state_index16 state[STATE_LENGTH])
          const GLuint index = (GLuint) state[1];
          const GLuint firstRow = (GLuint) state[2];
          const GLuint lastRow = (GLuint) state[3];
-         const gl_state_index modifier = state[4];
          if (index ||
-             mat == STATE_TEXTURE_MATRIX ||
+             (mat >= STATE_TEXTURE_MATRIX &&
-             mat == STATE_PROGRAM_MATRIX)
+              mat <= STATE_PROGRAM_MATRIX_INVTRANS))
             append_index(str, index);
-         if (modifier)
-            append_token(str, modifier);
          if (firstRow == lastRow)
             sprintf(tmp, ".row[%d]", firstRow);
          else

src/mesa/program/prog_statevars.h

@@ -67,13 +67,29 @@ typedef enum gl_state_index_ {
    STATE_POINT_ATTENUATION,
 
    STATE_MODELVIEW_MATRIX,
+   STATE_MODELVIEW_MATRIX_INVERSE,
+   STATE_MODELVIEW_MATRIX_TRANSPOSE,
+   STATE_MODELVIEW_MATRIX_INVTRANS,
+
    STATE_PROJECTION_MATRIX,
+   STATE_PROJECTION_MATRIX_INVERSE,
+   STATE_PROJECTION_MATRIX_TRANSPOSE,
+   STATE_PROJECTION_MATRIX_INVTRANS,
+
    STATE_MVP_MATRIX,
+   STATE_MVP_MATRIX_INVERSE,
+   STATE_MVP_MATRIX_TRANSPOSE,
+   STATE_MVP_MATRIX_INVTRANS,
+
    STATE_TEXTURE_MATRIX,
+   STATE_TEXTURE_MATRIX_INVERSE,
+   STATE_TEXTURE_MATRIX_TRANSPOSE,
+   STATE_TEXTURE_MATRIX_INVTRANS,
+
    STATE_PROGRAM_MATRIX,
-   STATE_MATRIX_INVERSE,
+   STATE_PROGRAM_MATRIX_INVERSE,
-   STATE_MATRIX_TRANSPOSE,
+   STATE_PROGRAM_MATRIX_TRANSPOSE,
-   STATE_MATRIX_INVTRANS,
+   STATE_PROGRAM_MATRIX_INVTRANS,
 
    STATE_AMBIENT,
    STATE_DIFFUSE,

src/mesa/program/program_parse.y

@@ -42,6 +42,13 @@
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
+enum {
+   STATE_MATRIX_NO_MODIFIER,
+   STATE_MATRIX_INVERSE,
+   STATE_MATRIX_TRANSPOSE,
+   STATE_MATRIX_INVTRANS,
+};
+
 extern void *yy_scan_string(char *);
 extern void yy_delete_buffer(void *);
 
@@ -1456,21 +1463,19 @@ statePointProperty: SIZE_TOK
 
 stateMatrixRow: stateMatrixItem ROW '[' stateMatrixRowNum ']'
 	{
-	   $$[0] = $1[0];
+	   $$[0] = $1[0] + $1[2];
 	   $$[1] = $1[1];
 	   $$[2] = $4;
 	   $$[3] = $4;
-	   $$[4] = $1[2];
 	}
 	;
 
 stateMatrixRows: stateMatrixItem optMatrixRows
 	{
-	   $$[0] = $1[0];
+	   $$[0] = $1[0] + $1[2];
 	   $$[1] = $1[1];
 	   $$[2] = $2[2];
 	   $$[3] = $2[3];
-	   $$[4] = $1[2];
 	}
 	;
 
@@ -1507,7 +1512,7 @@ stateMatrixItem: MATRIX stateMatrixName stateOptMatModifier
 
 stateOptMatModifier:
 	{
-	   $$ = 0;
+	   $$ = STATE_MATRIX_NO_MODIFIER;
 	}
 	| stateMatModifier
 	{
@@ -2338,11 +2343,8 @@ initialize_symbol_from_state(struct gl_program *prog,
    /* If we are adding a STATE_MATRIX that has multiple rows, we need to
     * unroll it and call add_state_reference() for each row
     */
-   if ((state_tokens[0] == STATE_MODELVIEW_MATRIX ||
+   if (state_tokens[0] >= STATE_MODELVIEW_MATRIX &&
-	state_tokens[0] == STATE_PROJECTION_MATRIX ||
+       state_tokens[0] <= STATE_PROGRAM_MATRIX_INVTRANS
-	state_tokens[0] == STATE_MVP_MATRIX ||
-	state_tokens[0] == STATE_TEXTURE_MATRIX ||
-	state_tokens[0] == STATE_PROGRAM_MATRIX)
        && (state_tokens[2] != state_tokens[3])) {
       int row;
       const int first_row = state_tokens[2];

src/mesa/program/programopt.c

@@ -126,10 +126,10 @@ insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog)
     * XXX we should check if these state vars are already declared.
     */
    static const gl_state_index16 mvpState[4][STATE_LENGTH] = {
-      { STATE_MVP_MATRIX, 0, 0, 0, STATE_MATRIX_TRANSPOSE },
+      { STATE_MVP_MATRIX_TRANSPOSE, 0, 0, 0, 0 },
-      { STATE_MVP_MATRIX, 0, 1, 1, STATE_MATRIX_TRANSPOSE },
+      { STATE_MVP_MATRIX_TRANSPOSE, 0, 1, 1, 0 },
-      { STATE_MVP_MATRIX, 0, 2, 2, STATE_MATRIX_TRANSPOSE },
+      { STATE_MVP_MATRIX_TRANSPOSE, 0, 2, 2, 0 },
-      { STATE_MVP_MATRIX, 0, 3, 3, STATE_MATRIX_TRANSPOSE },
+      { STATE_MVP_MATRIX_TRANSPOSE, 0, 3, 3, 0 },
    };
    GLint mvpRef[4];
 

src/mesa/state_tracker/st_nir_lower_builtin.c

@@ -110,10 +110,25 @@ get_variable(lower_builtin_state *state, nir_deref_path *path,
       /* we need to fixup the array index slot: */
       switch (tokens[0]) {
       case STATE_MODELVIEW_MATRIX:
+      case STATE_MODELVIEW_MATRIX_INVERSE:
+      case STATE_MODELVIEW_MATRIX_TRANSPOSE:
+      case STATE_MODELVIEW_MATRIX_INVTRANS:
       case STATE_PROJECTION_MATRIX:
+      case STATE_PROJECTION_MATRIX_INVERSE:
+      case STATE_PROJECTION_MATRIX_TRANSPOSE:
+      case STATE_PROJECTION_MATRIX_INVTRANS:
       case STATE_MVP_MATRIX:
+      case STATE_MVP_MATRIX_INVERSE:
+      case STATE_MVP_MATRIX_TRANSPOSE:
+      case STATE_MVP_MATRIX_INVTRANS:
       case STATE_TEXTURE_MATRIX:
+      case STATE_TEXTURE_MATRIX_INVERSE:
+      case STATE_TEXTURE_MATRIX_TRANSPOSE:
+      case STATE_TEXTURE_MATRIX_INVTRANS:
       case STATE_PROGRAM_MATRIX:
+      case STATE_PROGRAM_MATRIX_INVERSE:
+      case STATE_PROGRAM_MATRIX_TRANSPOSE:
+      case STATE_PROGRAM_MATRIX_INVTRANS:
       case STATE_LIGHT:
       case STATE_LIGHTPROD:
       case STATE_TEXGEN: