Move shader precision out of GrShaderVar

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 1028 matching lines @@
 
     fMaxRenderTargetSize = other.fMaxRenderTargetSize;
     fMaxTextureSize = other.fMaxTextureSize;
     fMaxSampleCount = other.fMaxSampleCount;
 
     memcpy(fConfigRenderSupport, other.fConfigRenderSupport, sizeof(fConfigRenderSupport));
     memcpy(fConfigTextureSupport, other.fConfigTextureSupport, sizeof(fConfigTextureSupport));
 
     fShaderPrecisionVaries = other.fShaderPrecisionVaries;
     for (int s = 0; s < kGrShaderTypeCount; ++s) {
-        for (int p = 0; p < GrShaderVar::kPrecisionCount; ++p) {
+        for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             fFloatPrecisions[s][p] = other.fFloatPrecisions[s][p];
         }
     }
     return *this;
 }
 
 static SkString map_flags_to_string(uint32_t flags) {
     SkString str;
     if (GrDrawTargetCaps::kNone_MapFlags == flags) {
         str = "none";
@@ skipping 18 matching lines @@
         case kVertex_GrShaderType:
             return "vertex";
         case kGeometry_GrShaderType:
             return "geometry";
         case kFragment_GrShaderType:
             return "fragment";
     }
     return "";
 }
 
-static const char* precision_to_string(GrShaderVar::Precision p) {
+static const char* precision_to_string(GrSLPrecision p) {
     switch (p) {
-        case GrShaderVar::kLow_Precision:
+        case kLow_GrSLPrecision:
             return "low";
-        case GrShaderVar::kMedium_Precision:
+        case kMedium_GrSLPrecision:
             return "medium";
-        case GrShaderVar::kHigh_Precision:
+        case kHigh_GrSLPrecision:
             return "high";
     }
     return "";
 }
 
 SkString GrDrawTargetCaps::dump() const {
     SkString r;
     static const char* gNY[] = {"NO", "YES"};
     r.appendf("MIP Map Support                    : %s\n", gNY[fMipMapSupport]);
     r.appendf("NPOT Texture Tile Support          : %s\n", gNY[fNPOTTextureTileSupport]);
@@ skipping 65 matching lines @@
         r.appendf("%s is uploadable to a texture: %s\n",
                   kConfigNames[i],
                   gNY[fConfigTextureSupport[i]]);
     }
 
     r.appendf("Shader Float Precisions (varies: %s):\n", gNY[fShaderPrecisionVaries]);
 
     for (int s = 0; s < kGrShaderTypeCount; ++s) {
         GrShaderType shaderType = static_cast<GrShaderType>(s);
         r.appendf("\t%s:\n", shader_type_to_string(shaderType));
-        for (int p = 0; p < GrShaderVar::kPrecisionCount; ++p) {
+        for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             if (fFloatPrecisions[s][p].supported()) {
-                GrShaderVar::Precision precision = static_cast<GrShaderVar::Precision>(p);
+                GrSLPrecision precision = static_cast<GrSLPrecision>(p);
                 r.appendf("\t\t%s: log_low: %d log_high: %d bits: %d\n",
                           precision_to_string(precision),
                           fFloatPrecisions[s][p].fLogRangeLow,
                           fFloatPrecisions[s][p].fLogRangeHigh,
                           fFloatPrecisions[s][p].fBits);
             }
         }
     }
 
     return r;
@@ skipping 15 matching lines @@
                              GrDrawState::AutoRestoreStencil* ars,
                              GrDrawState* ds,
                              GrClipMaskManager::ScissorState* scissorState) {
     return fClipMaskManager.setupClipping(ds,
                                           are,
                                           ars,
                                           scissorState,
                                           this->getClip(),
                                           devBounds);
 }