Removing vertex attrib indices

src/gpu/gl/GrGLShaderVar.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderVar_DEFINED
 #define GrGLShaderVar_DEFINED
 
 #include "GrGLContext.h"
 #include "GrGLSL.h"
-#include "SkString.h"
+#include "GrShaderVar.h"
 
 #define USE_UNIFORM_FLOAT_ARRAYS true
 
 /**
  * Represents a variable in a shader
  */
-class GrGLShaderVar {
+class GrGLShaderVar : public GrShaderVar {
 public:
 
     /**
-     * Early versions of GLSL have Varying and Attribute; those are later
-     * deprecated, but we still need to know whether a Varying variable
-     * should be treated as In or Out.
-     */
-    enum TypeModifier {
-        kNone_TypeModifier,
-        kOut_TypeModifier,
-        kIn_TypeModifier,
-        kInOut_TypeModifier,
-        kUniform_TypeModifier,
-        kAttribute_TypeModifier,
-        kVaryingIn_TypeModifier,
-        kVaryingOut_TypeModifier
-    };
-
-    enum Precision {
-        kLow_Precision,         // lowp
-        kMedium_Precision,      // mediump
-        kHigh_Precision,        // highp
-        kDefault_Precision,     // Default for the current context. We make
-                                // fragment shaders default to mediump on ES2
-                                // because highp support is not guaranteed (and
-                                // we haven't been motivated to test for it).
-                                // Otherwise, highp.
-    };
-
-    /**
      * See GL_ARB_fragment_coord_conventions.
      */
     enum Origin {
         kDefault_Origin,        // when set to kDefault the origin field is ignored.
         kUpperLeft_Origin,      // only used to declare vec4 in gl_FragCoord.
     };
 
     /**
      * Defaults to a float with no precision specifier
      */
-    GrGLShaderVar() {
-        fType = kFloat_GrSLType;
-        fTypeModifier = kNone_TypeModifier;
-        fCount = kNonArray;
-        fPrecision = kDefault_Precision;
+    GrGLShaderVar()
+        : GrShaderVar()
+        , fOrigin(kDefault_Origin)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
+    }
+
+    GrGLShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
+                  Precision precision = kDefault_Precision)
+        : GrShaderVar(name, type, arrayCount, precision)
+        , fOrigin(kDefault_Origin)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != type);
         fOrigin = kDefault_Origin;
         fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
     }
 
-    GrGLShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
-                  Precision precision = kDefault_Precision) {
+    GrGLShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
+                  int arrayCount = kNonArray, Precision precision = kDefault_Precision)
+        : GrShaderVar(name, type, typeModifier, arrayCount, precision)
+        , fOrigin(kDefault_Origin)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
-        fType = type;
-        fTypeModifier = kNone_TypeModifier;
-        fCount = arrayCount;
-        fPrecision = precision;
-        fOrigin = kDefault_Origin;
-        fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
-        fName = name;
+    }
+
+    GrGLShaderVar(const GrShaderVar& var)
+        : GrShaderVar(var)
+        , fOrigin(kDefault_Origin)
+        , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
+        SkASSERT(kVoid_GrSLType != var.getType());
     }
 
     GrGLShaderVar(const GrGLShaderVar& var)
-        : fType(var.fType)
-        , fTypeModifier(var.fTypeModifier)
-        , fName(var.fName)
-        , fCount(var.fCount)
-        , fPrecision(var.fPrecision)
+        : GrShaderVar(var.c_str(), var.getType(), var.getTypeModifier(),
+                      var.getArrayCount(), var.getPrecision())
         , fOrigin(var.fOrigin)
         , fUseUniformFloatArrays(var.fUseUniformFloatArrays) {
-        SkASSERT(kVoid_GrSLType != var.fType);
+        SkASSERT(kVoid_GrSLType != var.getType());
     }
 
     /**
      * Values for array count that have special meaning. We allow 1-sized arrays.
      */
     enum {
         kNonArray     =  0, // not an array
         kUnsizedArray = -1, // an unsized array (declared with [])
     };
 
     /**
      * Sets as a non-array.
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const SkString& name,
              Precision precision = kDefault_Precision,
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
-        fType = type;
-        fTypeModifier = typeModifier;
-        fName = name;
-        fCount = kNonArray;
-        fPrecision = precision;
+        INHERITED::set(type, typeModifier, name, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
     }
 
     /**
      * Sets as a non-array.
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const char* name,
              Precision precision = kDefault_Precision,
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
-        fType = type;
-        fTypeModifier = typeModifier;
-        fName = name;
-        fCount = kNonArray;
-        fPrecision = precision;
+        INHERITED::set(type, typeModifier, name, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
     }
 
     /**
      * Set all var options
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const SkString& name,
              int count,
              Precision precision = kDefault_Precision,
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
-        fType = type;
-        fTypeModifier = typeModifier;
-        fName = name;
-        fCount = count;
-        fPrecision = precision;
+        INHERITED::set(type, typeModifier, name, count, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
     }
 
     /**
      * Set all var options
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const char* name,
              int count,
              Precision precision = kDefault_Precision,
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
-        fType = type;
-        fTypeModifier = typeModifier;
-        fName = name;
-        fCount = count;
-        fPrecision = precision;
+        INHERITED::set(type, typeModifier, name, count, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
     }
 
     /**
-     * Is the var an array.
-     */
-    bool isArray() const { return kNonArray != fCount; }
-    /**
-     * Is this an unsized array, (i.e. declared with []).
-     */
-    bool isUnsizedArray() const { return kUnsizedArray == fCount; }
-    /**
-     * Get the array length of the var.
-     */
-    int getArrayCount() const { return fCount; }
-    /**
-     * Set the array length of the var
-     */
-    void setArrayCount(int count) { fCount = count; }
-    /**
-     * Set to be a non-array.
-     */
-    void setNonArray() { fCount = kNonArray; }
-    /**
-     * Set to be an unsized array.
-     */
-    void setUnsizedArray() { fCount = kUnsizedArray; }
-
-    /**
-     * Access the var name as a writable string
-     */
-    SkString* accessName() { return &fName; }
-    /**
-     * Set the var name
-     */
-    void setName(const SkString& n) { fName = n; }
-    void setName(const char* n) { fName = n; }
-
-    /**
-     * Get the var name.
-     */
-    const SkString& getName() const { return fName; }
-
-    /**
-     * Shortcut for this->getName().c_str();
-     */
-    const char* c_str() const { return this->getName().c_str(); }
-
-    /**
-     * Get the type of the var
-     */
-    GrSLType getType() const { return fType; }
-    /**
-     * Set the type of the var
-     */
-    void setType(GrSLType type) { fType = type; }
-
-    TypeModifier getTypeModifier() const { return fTypeModifier; }
-    void setTypeModifier(TypeModifier type) { fTypeModifier = type; }
-
-    /**
-     * Get the precision of the var
-     */
-    Precision getPrecision() const { return fPrecision; }
-
-    /**
-     * Set the precision of the var
-     */
-    void setPrecision(Precision p) { fPrecision = p; }
-
-    /**
      * Get the origin of the var
      */
     Origin getOrigin() const { return fOrigin; }
 
     /**
      * Set the origin of the var
      */
     void setOrigin(Origin origin) { fOrigin = origin; }
 
     /**
@@ skipping 82 matching lines @@
             case kVaryingIn_TypeModifier:
                 return k110_GrGLSLGeneration == gen ? "varying" : "in";
             case kVaryingOut_TypeModifier:
                 return k110_GrGLSLGeneration == gen ? "varying" : "out";
             default:
                 SkFAIL("Unknown shader variable type modifier.");
                 return ""; // suppress warning
         }
     }
 
-    GrSLType        fType;
-    TypeModifier    fTypeModifier;
-    SkString        fName;
-    int             fCount;
-    Precision       fPrecision;
     Origin          fOrigin;
     /// Work around driver bugs on some hardware that don't correctly
     /// support uniform float []
     bool            fUseUniformFloatArrays;
+
+    typedef GrShaderVar INHERITED;
 };
 
 #endif