Move shader precision out of GrShaderVar

include/gpu/GrShaderVar.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrShaderVar_DEFINED
 #define GrShaderVar_DEFINED
 
@@ skipping 16 matching lines @@
         kOut_TypeModifier,
         kIn_TypeModifier,
         kInOut_TypeModifier,
         kUniform_TypeModifier,
         // GL Specific types below
         kAttribute_TypeModifier,
         kVaryingIn_TypeModifier,
         kVaryingOut_TypeModifier
     };
 
-    enum Precision {
-        kLow_Precision,
-        kMedium_Precision,
-        kHigh_Precision,
-
-        // Default precision is medium. This is because on OpenGL ES 2 highp support is not
-        // guaranteed. On (non-ES) OpenGL the specifiers have no effect on precision.
-        kDefault_Precision = kMedium_Precision,
-
-        kLast_Precision = kHigh_Precision
-    };
-    static const int kPrecisionCount = kLast_Precision + 1;
-
     /**
      * Defaults to a float with no precision specifier
      */
     GrShaderVar()
         : fType(kFloat_GrSLType)
         , fTypeModifier(kNone_TypeModifier)
         , fCount(kNonArray)
-        , fPrecision(kDefault_Precision) {
+        , fPrecision(kDefault_GrSLPrecision) {
     }
 
     GrShaderVar(const SkString& name, GrSLType type, int arrayCount = kNonArray,
-                Precision precision = kDefault_Precision)
+                GrSLPrecision precision = kDefault_GrSLPrecision)
         : fType(type)
         , fTypeModifier(kNone_TypeModifier)
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
         SkASSERT(kVoid_GrSLType != type);
     }
 
     GrShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
-                  Precision precision = kDefault_Precision)
+                GrSLPrecision precision = kDefault_GrSLPrecision)
         : fType(type)
         , fTypeModifier(kNone_TypeModifier)
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
         SkASSERT(kVoid_GrSLType != type);
     }
 
     GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
-                  int arrayCount = kNonArray, Precision precision = kDefault_Precision)
+                  int arrayCount = kNonArray, GrSLPrecision precision = kDefault_GrSLPrecision)
         : fType(type)
         , fTypeModifier(typeModifier)
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
         SkASSERT(kVoid_GrSLType != type);
     }
 
     /**
      * 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) {
+             GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
         fCount = kNonArray;
         fPrecision = precision;
     }
 
     /**
      * Sets as a non-array.
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const char* name,
-             Precision precision = kDefault_Precision) {
+             GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
         fCount = kNonArray;
         fPrecision = precision;
     }
 
     /**
      * Set all var options
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const SkString& name,
              int count,
-             Precision precision = kDefault_Precision) {
+             GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
         fCount = count;
         fPrecision = precision;
     }
 
     /**
      * Set all var options
      */
     void set(GrSLType type,
              TypeModifier typeModifier,
              const char* name,
              int count,
-             Precision precision = kDefault_Precision) {
+             GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
         fCount = count;
         fPrecision = precision;
     }
 
     /**
      * Is the var an array.
@@ skipping 48 matching lines @@
      * 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; }
+    GrSLPrecision getPrecision() const { return fPrecision; }
 
     /**
      * Set the precision of the var
      */
-    void setPrecision(Precision p) { fPrecision = p; }
+    void setPrecision(GrSLPrecision p) { fPrecision = p; }
 
 protected:
     GrSLType        fType;
     TypeModifier    fTypeModifier;
     SkString        fName;
     int             fCount;
-    Precision       fPrecision;
+    GrSLPrecision   fPrecision;
 };
 
 #endif