From de8172673e23bad1186553b91a7c22e65d93692a Mon Sep 17 00:00:00 2001
From: Brian <brian@yutani.localnet.net>
Date: Thu, 8 Mar 2007 09:38:35 -0700
Subject: 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.
---
 src/mesa/shader/slang/library/slang_core.gc | 54 +++++++++++++++--------------
 1 file changed, 28 insertions(+), 26 deletions(-)

(limited to 'src/mesa/shader/slang/library/slang_core.gc')

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
@@ -1868,71 +1868,64 @@ mat4 __operator / (const mat4 m, const float b)
 //// matrix / vector products
 
 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
-- 
cgit v1.2.3