Be more consistant with paths in #includes. Eventually, eliminate a bunch of -I...

[mesa.git] / src / mesa / shader / slang / slang_typeinfo.c

diff --git a/src/mesa/shader/slang/slang_typeinfo.c b/src/mesa/shader/slang/slang_typeinfo.c
index fef5575631b7379f11b4562ed2ab5008499b6f25..8a1c3abf4807df21510511cf62f0af37fa05e808 100644 (file)
--- a/src/mesa/shader/slang/slang_typeinfo.c
+++ b/src/mesa/shader/slang/slang_typeinfo.c
@@ -28,11 +28,12 @@
  * \author Michal Krol
  */
 
-#include "imports.h"
+#include "main/imports.h"
+#include "shader/prog_instruction.h"
 #include "slang_typeinfo.h"
 #include "slang_compile.h"
 #include "slang_log.h"
-#include "prog_instruction.h"
+#include "slang_mem.h"
 
 
 /**
@@ -178,11 +179,11 @@ slang_type_specifier_dtr(slang_type_specifier * self)
 {
    if (self->_struct != NULL) {
       slang_struct_destruct(self->_struct);
-      slang_alloc_free(self->_struct);
+      _slang_free(self->_struct);
    }
    if (self->_array != NULL) {
       slang_type_specifier_dtr(self->_array);
-      slang_alloc_free(self->_array);
+      _slang_free(self->_array);
    }
 }
 
@@ -195,13 +196,13 @@ slang_type_specifier_copy(slang_type_specifier * x,
    slang_type_specifier_ctr(&z);
    z.type = y->type;
    if (z.type == SLANG_SPEC_STRUCT) {
-      z._struct = (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
+      z._struct = (slang_struct *) _slang_alloc(sizeof(slang_struct));
       if (z._struct == NULL) {
          slang_type_specifier_dtr(&z);
          return GL_FALSE;
       }
       if (!slang_struct_construct(z._struct)) {
-         slang_alloc_free(z._struct);
+         _slang_free(z._struct);
          slang_type_specifier_dtr(&z);
          return GL_FALSE;
       }
@@ -211,9 +212,8 @@ slang_type_specifier_copy(slang_type_specifier * x,
       }
    }
    else if (z.type == SLANG_SPEC_ARRAY) {
-      z._array =
-         (slang_type_specifier *)
-         slang_alloc_malloc(sizeof(slang_type_specifier));
+      z._array = (slang_type_specifier *)
+         _slang_alloc(sizeof(slang_type_specifier));
       if (z._array == NULL) {
          slang_type_specifier_dtr(&z);
          return GL_FALSE;
@@ -596,11 +596,11 @@ _slang_typeof_operation_(slang_operation * op,
                /* struct initializer */
                ti->spec.type = SLANG_SPEC_STRUCT;
                ti->spec._struct =
-                  (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
+                  (slang_struct *) _slang_alloc(sizeof(slang_struct));
                if (ti->spec._struct == NULL)
                   return GL_FALSE;
                if (!slang_struct_construct(ti->spec._struct)) {
-                  slang_alloc_free(ti->spec._struct);
+                  _slang_free(ti->spec._struct);
                   ti->spec._struct = NULL;
                   return GL_FALSE;
                }
@@ -815,6 +815,12 @@ _slang_type_is_matrix(slang_type_specifier_type ty)
    case SLANG_SPEC_MAT2:
    case SLANG_SPEC_MAT3:
    case SLANG_SPEC_MAT4:
+   case SLANG_SPEC_MAT23:
+   case SLANG_SPEC_MAT32:
+   case SLANG_SPEC_MAT24:
+   case SLANG_SPEC_MAT42:
+   case SLANG_SPEC_MAT34:
+   case SLANG_SPEC_MAT43:
       return GL_TRUE;
    default:
       return GL_FALSE;
@@ -847,7 +853,8 @@ _slang_type_is_vector(slang_type_specifier_type ty)
 
 
 /**
- * Given a vector type, return the type of the vector's elements
+ * Given a vector type, return the type of the vector's elements.
+ * For a matrix, return the type of the columns.
  */
 slang_type_specifier_type
 _slang_type_base(slang_type_specifier_type ty)
@@ -874,6 +881,18 @@ _slang_type_base(slang_type_specifier_type ty)
       return SLANG_SPEC_VEC3;
    case SLANG_SPEC_MAT4:
       return SLANG_SPEC_VEC4;
+   case SLANG_SPEC_MAT23:
+      return SLANG_SPEC_VEC3;
+   case SLANG_SPEC_MAT32:
+      return SLANG_SPEC_VEC2;
+   case SLANG_SPEC_MAT24:
+      return SLANG_SPEC_VEC4;
+   case SLANG_SPEC_MAT42:
+      return SLANG_SPEC_VEC2;
+   case SLANG_SPEC_MAT34:
+      return SLANG_SPEC_VEC4;
+   case SLANG_SPEC_MAT43:
+      return SLANG_SPEC_VEC3;
    default:
       return SLANG_SPEC_VOID;
    }
@@ -881,7 +900,8 @@ _slang_type_base(slang_type_specifier_type ty)
 
 
 /**
- * Return the dimensionality of a vector or matrix type.
+ * Return the dimensionality of a vector, or for a matrix, return number
+ * of columns.
  */
 GLuint
 _slang_type_dim(slang_type_specifier_type ty)
@@ -906,7 +926,97 @@ _slang_type_dim(slang_type_specifier_type ty)
    case SLANG_SPEC_BVEC4:
    case SLANG_SPEC_MAT4:
       return 4;
+
+   case SLANG_SPEC_MAT23:
+      return 2;
+   case SLANG_SPEC_MAT32:
+      return 3;
+   case SLANG_SPEC_MAT24:
+      return 2;
+   case SLANG_SPEC_MAT42:
+      return 4;
+   case SLANG_SPEC_MAT34:
+      return 3;
+   case SLANG_SPEC_MAT43:
+      return 4;
+
    default:
       return 0;
    }
 }
+
+
+/**
+ * Return the GL_* type that corresponds to a SLANG_SPEC_* type.
+ */
+GLenum
+_slang_gltype_from_specifier(const slang_type_specifier *type)
+{
+   switch (type->type) {
+   case SLANG_SPEC_BOOL:
+      return GL_BOOL;
+   case SLANG_SPEC_BVEC2:
+      return GL_BOOL_VEC2;
+   case SLANG_SPEC_BVEC3:
+      return GL_BOOL_VEC3;
+   case SLANG_SPEC_BVEC4:
+      return GL_BOOL_VEC4;
+   case SLANG_SPEC_INT:
+      return GL_INT;
+   case SLANG_SPEC_IVEC2:
+      return GL_INT_VEC2;
+   case SLANG_SPEC_IVEC3:
+      return GL_INT_VEC3;
+   case SLANG_SPEC_IVEC4:
+      return GL_INT_VEC4;
+   case SLANG_SPEC_FLOAT:
+      return GL_FLOAT;
+   case SLANG_SPEC_VEC2:
+      return GL_FLOAT_VEC2;
+   case SLANG_SPEC_VEC3:
+      return GL_FLOAT_VEC3;
+   case SLANG_SPEC_VEC4:
+      return GL_FLOAT_VEC4;
+   case SLANG_SPEC_MAT2:
+      return GL_FLOAT_MAT2;
+   case SLANG_SPEC_MAT3:
+      return GL_FLOAT_MAT3;
+   case SLANG_SPEC_MAT4:
+      return GL_FLOAT_MAT4;
+   case SLANG_SPEC_MAT23:
+      return GL_FLOAT_MAT2x3;
+   case SLANG_SPEC_MAT32:
+      return GL_FLOAT_MAT3x2;
+   case SLANG_SPEC_MAT24:
+      return GL_FLOAT_MAT2x4;
+   case SLANG_SPEC_MAT42:
+      return GL_FLOAT_MAT4x2;
+   case SLANG_SPEC_MAT34:
+      return GL_FLOAT_MAT3x4;
+   case SLANG_SPEC_MAT43:
+      return GL_FLOAT_MAT4x3;
+   case SLANG_SPEC_SAMPLER1D:
+      return GL_SAMPLER_1D;
+   case SLANG_SPEC_SAMPLER2D:
+      return GL_SAMPLER_2D;
+   case SLANG_SPEC_SAMPLER3D:
+      return GL_SAMPLER_3D;
+   case SLANG_SPEC_SAMPLERCUBE:
+      return GL_SAMPLER_CUBE;
+   case SLANG_SPEC_SAMPLER1DSHADOW:
+      return GL_SAMPLER_1D_SHADOW;
+   case SLANG_SPEC_SAMPLER2DSHADOW:
+      return GL_SAMPLER_2D_SHADOW;
+   case SLANG_SPEC_SAMPLER2DRECT:
+      return GL_SAMPLER_2D_RECT_ARB;
+   case SLANG_SPEC_SAMPLER2DRECTSHADOW:
+      return GL_SAMPLER_2D_RECT_SHADOW_ARB;
+   case SLANG_SPEC_ARRAY:
+      return _slang_gltype_from_specifier(type->_array);
+   case SLANG_SPEC_STRUCT:
+      /* fall-through */
+   default:
+      return GL_NONE;
+   }
+}
+