Rework matrix-related code.

GLSL matrices are stored in column-major order while GL_ARB_vertex/fragment_program
use row-major.  So, need to use STATE_MATRIX_TRANSPOSE for built-in matrices.
Unfortunately, this means that the expression M * V isn't very efficient since we
need to extract the rows out of M.  And that's the typical expression for vertex
transformation:  gl_ModelViewProjectionMatrix * gl_Position.
Solve this inefficiency by looking for M*V expressions and replacing them
with V*Transpose(M).
Also, add support for GLSL 1.20's MatrixTranspose, Inverse and InverseTranspose
matrices.

1 files changed, 28 insertions, 26 deletions

diff --git a/src/mesa/shader/slang/library/slang_core.gc b/src/mesa/shader/slang/library/slang_core.gc
index 25afccf13f..964c63fde6 100644
--- a/src/mesa/shader/slang/library/slang_core.gc
+++ b/src/mesa/shader/slang/library/slang_core.gc
@@ -1869,70 +1869,63 @@ mat4 __operator / (const mat4 m, const float b)
 
 vec2 __operator * (const mat2 m, const vec2 v)
 {
-   __retVal.x = dot(m[0], v);
-   __retVal.y = dot(m[1], v);
-}
-
-vec2 __operator * (const vec2 v, const mat2 m)
-{
    vec2 r0, r1;
    r0.x = m[0].x;
    r0.y = m[1].x;
    r1.x = m[0].y;
    r1.y = m[1].y;
-   __retVal.x = dot(v, r0);
-   __retVal.y = dot(v, r1);
+   __retVal.x = dot(r0, v);
+   __retVal.y = dot(r1, v);
 }
 
-vec3 __operator * (const mat3 m, const vec3 v)
+vec2 __operator * (const vec2 v, const mat2 m)
 {
-   __retVal.x = dot(m[0], v);
-   __retVal.y = dot(m[1], v);
-   __retVal.z = dot(m[2], v);
+   __retVal.x = dot(v, m[0]);
+   __retVal.y = dot(v, m[1]);
 }
 
-vec3 __operator * (const vec3 v, const mat3 m)
+vec3 __operator * (const mat3 m, const vec3 v)
 {
    {
       vec3 r0;
       r0.x = m[0].x;
       r0.y = m[1].x;
       r0.z = m[2].x;
-      __asm vec3_dot __retVal.x, v, r0;
+      __asm vec3_dot __retVal.x, r0, v;
    }
    {
       vec3 r1;
       r1.x = m[0].y;
       r1.y = m[1].y;
       r1.z = m[2].y;
-      __asm vec3_dot __retVal.y, v, r1;
+      __asm vec3_dot __retVal.y, r1, v;
    }
    {
       vec3 r2;
       r2.x = m[0].z;
       r2.y = m[1].z;
       r2.z = m[2].z;
-      __asm vec3_dot __retVal.z, v, r2;
+      __asm vec3_dot __retVal.z, r2, v;
    }
 }
 
-vec4 __operator * (const mat4 m, const vec4 v)
+vec3 __operator * (const vec3 v, const mat3 m)
 {
-   __retVal.x = dot(m[0], v);
-   __retVal.y = dot(m[1], v);
-   __retVal.z = dot(m[2], v);
-   __retVal.w = dot(m[3], v);
+   __retVal.x = dot(v, m[0]);
+   __retVal.y = dot(v, m[1]);
+   __retVal.z = dot(v, m[2]);
 }
 
-vec4 __operator * (const vec4 v, const mat4 m)
+vec4 __operator * (const mat4 m, const vec4 v)
 {
+   // extract rows, then do dot product
    {
       vec4 r0;
       r0.x = m[0].x;
       r0.y = m[1].x;
       r0.z = m[2].x;
       r0.w = m[3].x;
-      __asm vec4_dot __retVal.x, v, r0;
+      __asm vec4_dot __retVal.x, r0, v;
    }
    {
       vec4 r1;
@@ -1940,7 +1933,7 @@ vec4 __operator * (const vec4 v, const mat4 m)
       r1.y = m[1].y;
       r1.z = m[2].y;
       r1.w = m[3].y;
-      __asm vec4_dot __retVal.y, v, r1;
+      __asm vec4_dot __retVal.y, r1, v;
    }
    {
       vec4 r2;
@@ -1948,7 +1941,7 @@ vec4 __operator * (const vec4 v, const mat4 m)
       r2.y = m[1].z;
       r2.z = m[2].z;
       r2.w = m[3].z;
-      __asm vec4_dot __retVal.z, v, r2;
+      __asm vec4_dot __retVal.z, r2, v;
    }
    {
       vec4 r3;
@@ -1956,10 +1949,19 @@ vec4 __operator * (const vec4 v, const mat4 m)
       r3.y = m[1].w;
       r3.z = m[2].w;
       r3.w = m[3].w;
-      __asm vec4_dot __retVal.w, v, r3;
+      __asm vec4_dot __retVal.w, r3, v;
    }
 }
 
+vec4 __operator * (const vec4 v, const mat4 m)
+{
+   //mm
+   __retVal.x = dot(v, m[0]);
+   __retVal.y = dot(v, m[1]);
+   __retVal.z = dot(v, m[2]);
+   __retVal.w = dot(v, m[3]);
+}
+
 
 
 //// mat2 assignment operators