Add utility function to get the name of a shader target

[mesa.git] / glsl_types.h

diff --git a/glsl_types.h b/glsl_types.h
index 64c6cef669ef6fad36390d7e5c5adf20cde996ee..33b1c98158d08aad30a4b6a155689c98a06a4e84 100644 (file)
--- a/glsl_types.h
+++ b/glsl_types.h
@@ -27,6 +27,7 @@
 #define GLSL_TYPES_H
 
 #include <cstring>
+#include <cassert>
 
 #define GLSL_TYPE_UINT          0
 #define GLSL_TYPE_INT           1
@@ -39,8 +40,6 @@
 #define GLSL_TYPE_VOID          8
 #define GLSL_TYPE_ERROR         9
 
-#define is_error_type(t) ((t)->base_type == GLSL_TYPE_ERROR)
-
 enum glsl_sampler_dim {
    GLSL_SAMPLER_DIM_1D = 0,
    GLSL_SAMPLER_DIM_2D,
@@ -62,8 +61,16 @@ struct glsl_type {
                                * and \c GLSL_TYPE_UINT are valid.
                                */
 
-   unsigned vector_elements:3; /**< 0, 2, 3, or 4 vector elements. */
-   unsigned matrix_columns:3;  /**< 0, 2, 3, or 4 matrix columns. */
+   /**
+    * \name Vector and matrix element counts
+    *
+    * For scalars, each of these values will be 1.  For non-numeric types
+    * these will be 0.
+    */
+   /*@{*/
+   unsigned vector_elements:3; /**< 1, 2, 3, or 4 vector elements. */
+   unsigned matrix_columns:3;  /**< 1, 2, 3, or 4 matrix columns. */
+   /*@}*/
 
    /**
     * Name of the data type
@@ -116,6 +123,9 @@ struct glsl_type {
       name(name),
       length(0)
    {
+      /* Neither dimension is zero or both dimensions are zero.
+       */
+      assert((vector_elements == 0) == (matrix_columns == 0));
       memset(& fields, 0, sizeof(fields));
    }
 
@@ -153,18 +163,47 @@ struct glsl_type {
     */
    const glsl_type *get_base_type() const;
 
+   /**
+    * Query the type of elements in an array
+    *
+    * \return
+    * Pointer to the type of elements in the array for array types, or \c NULL
+    * for non-array types.
+    */
+   const glsl_type *element_type() const
+   {
+      return is_array() ? fields.array : NULL;
+   }
+
    /**
     * Get the instance of a built-in scalar, vector, or matrix type
     */
    static const glsl_type *get_instance(unsigned base_type, unsigned rows,
                                        unsigned columns);
 
+   /**
+    * Get the instance of an array type
+    */
+   static const glsl_type *get_array_instance(const glsl_type *base,
+                                             unsigned elements);
+
+   class ir_function *generate_constructor_prototype(class glsl_symbol_table *)
+      const;
+
+   /**
+    * Query the total number of scalars that make up a scalar, vector or matrix
+    */
+   unsigned components() const
+   {
+      return vector_elements * matrix_columns;
+   }
+
    /**
     * Query whether or not a type is a scalar (non-vector and non-matrix).
     */
    bool is_scalar() const
    {
-      return (vector_elements == 0)
+      return (vector_elements == 1)
         && (base_type >= GLSL_TYPE_UINT)
         && (base_type <= GLSL_TYPE_BOOL);
    }
@@ -174,8 +213,8 @@ struct glsl_type {
     */
    bool is_vector() const
    {
-      return (vector_elements > 0)
-        && (matrix_columns == 0)
+      return (vector_elements > 1)
+        && (matrix_columns == 1)
         && (base_type >= GLSL_TYPE_UINT)
         && (base_type <= GLSL_TYPE_BOOL);
    }
@@ -186,7 +225,7 @@ struct glsl_type {
    bool is_matrix() const
    {
       /* GLSL only has float matrices. */
-      return (matrix_columns > 0) && (base_type == GLSL_TYPE_FLOAT);
+      return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT);
    }
 
    /**
@@ -205,6 +244,14 @@ struct glsl_type {
       return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT);
    }
 
+   /**
+    * Query whether or not a type is a float type
+    */
+   bool is_float() const
+   {
+      return base_type == GLSL_TYPE_FLOAT;
+   }
+
    /**
     * Query whether or not a type is a non-array boolean type
     */
@@ -221,6 +268,14 @@ struct glsl_type {
       return base_type == GLSL_TYPE_SAMPLER;
    }
 
+   /**
+    * Query whether or not a type is an array
+    */
+   bool is_array() const
+   {
+      return base_type == GLSL_TYPE_ARRAY;
+   }
+
    /**
     * Query whether or not a type is the void type singleton.
     */
@@ -265,7 +320,26 @@ struct glsl_type {
         : error_type;
    }
 
+   /**
+    * Query the number of elements in an array type
+    *
+    * \return
+    * The number of elements in the array for array types or -1 for non-array
+    * types.  If the number of elements in the array has not yet been declared,
+    * zero is returned.
+    */
+   int array_size() const
+   {
+      return is_array() ? length : -1;
+   }
+
 private:
+   /**
+    * Constructor for array types
+    */
+   glsl_type(const glsl_type *array, unsigned length);
+
+
    /**
     * \name Pointers to various private type singletons
     */
@@ -280,6 +354,12 @@ private:
    static const glsl_type *const mat4x3_type;
    static const glsl_type *const mat4_type;
    /*@}*/
+
+   /** Hash table containing the known array types. */
+   static struct hash_table *array_types;
+
+   static int array_key_compare(const void *a, const void *b);
+   static unsigned array_key_hash(const void *key);
 };
 
 struct glsl_struct_field {