[cogl/wip/rib/cogl-1.12: 88/101] Don't use the transpose argument of glUniformMatrix*

[Robert Bragg <rbragg src gnome org>]

commit fb0b6fa21ee51ce89cd04f83b9eb5095f497dd8b
Author: Neil Roberts <neil linux intel com>
Date:   Wed Jun 20 14:23:50 2012 +0100

    Don't use the transpose argument of glUniformMatrix*
    
    According to the GLES1/2 spec, the transpose argument of
    glUniformMatrix* should always be FALSE. Cogl directly exposes the
    transposedness of the uniform value in
    cogl_pipeline_set_uniform_matrix and we were previously passing this
    value on to GL. This patch makes it instead just always transpose the
    matrix in Cogl itself when copying the value to the CoglBoxedValue. It
    doesn't seem like there could be much advantage to letting GL
    transpose the uniform value and at least Mesa just does a very similar
    loop to handle the transpose.
    
    Mesa has started being more pedantic about this which was making
    test_pipeline_uniforms fail.
    
    http://cgit.freedesktop.org/mesa/mesa/commit/?id=60e8a4944081b42127b3
    
    Reviewed-by: Robert Bragg <robert linux intel com>
    
    (cherry picked from commit f42ee670ff663d03073d6b1038b21a0aa1b3ec2b)

 cogl/cogl-boxed-value.c |   49 +++++++++++++++++++++++++++++++++++++++-------
 cogl/cogl-boxed-value.h |    1 -
 2 files changed, 41 insertions(+), 9 deletions(-)
---
diff --git a/cogl/cogl-boxed-value.c b/cogl/cogl-boxed-value.c
index bc2b8a3..59ff3b6 100644
--- a/cogl/cogl-boxed-value.c
+++ b/cogl/cogl-boxed-value.c
@@ -80,8 +80,7 @@ _cogl_boxed_value_equal (const CoglBoxedValue *bva,
 
     case COGL_BOXED_MATRIX:
       if (bva->size != bvb->size ||
-          bva->count != bvb->count ||
-          bva->transpose != bvb->transpose)
+          bva->count != bvb->count)
         return FALSE;
 
       if (bva->count == 1)
@@ -105,6 +104,24 @@ _cogl_boxed_value_equal (const CoglBoxedValue *bva,
 }
 
 static void
+_cogl_boxed_value_tranpose (float *dst,
+                            int size,
+                            const float *src)
+{
+  int y, x;
+
+  /* If the value is transposed we'll just transpose it now as it
+   * is copied into the boxed value instead of passing TRUE to
+   * glUniformMatrix because that is not supported on GLES and it
+   * doesn't seem like the GL driver would be able to do anything
+   * much smarter than this anyway */
+
+  for (y = 0; y < size; y++)
+    for (x = 0; x < size; x++)
+      *(dst++) = src[y + x * size];
+}
+
+static void
 _cogl_boxed_value_set_x (CoglBoxedValue *bv,
                          int size,
                          int count,
@@ -118,7 +135,12 @@ _cogl_boxed_value_set_x (CoglBoxedValue *bv,
       if (bv->count > 1)
         g_free (bv->v.array);
 
-      memcpy (bv->v.float_value, value, value_size);
+      if (transpose)
+        _cogl_boxed_value_tranpose (bv->v.float_value,
+                                    size,
+                                    value);
+      else
+        memcpy (bv->v.float_value, value, value_size);
     }
   else
     {
@@ -135,13 +157,24 @@ _cogl_boxed_value_set_x (CoglBoxedValue *bv,
       else
         bv->v.array = g_malloc (count * value_size);
 
-      memcpy (bv->v.array, value, count * value_size);
+      if (transpose)
+        {
+          int value_num;
+
+          for (value_num = 0; value_num < count; value_num++)
+            _cogl_boxed_value_tranpose (bv->v.float_array +
+                                        value_num * size * size,
+                                        size,
+                                        (const float *) value +
+                                        value_num * size * size);
+        }
+      else
+        memcpy (bv->v.array, value, count * value_size);
     }
 
   bv->type = type;
   bv->size = size;
   bv->count = count;
-  bv->transpose = transpose;
 }
 
 void
@@ -319,15 +352,15 @@ _cogl_boxed_value_set_uniform (CoglContext *ctx,
           {
           case 2:
             GE( ctx, glUniformMatrix2fv (location, value->count,
-                                         value->transpose, ptr) );
+                                         FALSE, ptr) );
             break;
           case 3:
             GE( ctx, glUniformMatrix3fv (location, value->count,
-                                         value->transpose, ptr) );
+                                         FALSE, ptr) );
             break;
           case 4:
             GE( ctx, glUniformMatrix4fv (location, value->count,
-                                         value->transpose, ptr) );
+                                         FALSE, ptr) );
             break;
           }
       }
diff --git a/cogl/cogl-boxed-value.h b/cogl/cogl-boxed-value.h
index 67b9aae..608115a 100644
--- a/cogl/cogl-boxed-value.h
+++ b/cogl/cogl-boxed-value.h
@@ -39,7 +39,6 @@ typedef struct _CoglBoxedValue
 {
   CoglBoxedType type;
   int size, count;
-  CoglBool transpose;
 
   union {
     float float_value[4];