Use texture size to determine precision of texture coord varyings

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 993 matching lines @@
     fCompressedTexSubImageSupport = false;
 
     fUseDrawInsteadOfClear = false;
 
     fMapBufferFlags = kNone_MapFlags;
 
     fMaxRenderTargetSize = 0;
     fMaxTextureSize = 0;
     fMaxSampleCount = 0;
 
+    fShaderPrecisionVaries = false;
+
     memset(fConfigRenderSupport, 0, sizeof(fConfigRenderSupport));
     memset(fConfigTextureSupport, 0, sizeof(fConfigTextureSupport));
 }
 
 GrDrawTargetCaps& GrDrawTargetCaps::operator=(const GrDrawTargetCaps& other) {
     fMipMapSupport = other.fMipMapSupport;
     fNPOTTextureTileSupport = other.fNPOTTextureTileSupport;
     fTwoSidedStencilSupport = other.fTwoSidedStencilSupport;
     fStencilWrapOpsSupport = other.fStencilWrapOpsSupport;
     fHWAALineSupport = other.fHWAALineSupport;
@@ skipping 11 matching lines @@
 
     fMapBufferFlags = other.fMapBufferFlags;
 
     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) {
+            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";
     } else {
         SkASSERT(GrDrawTargetCaps::kCanMap_MapFlag & flags);
         SkDEBUGCODE(flags &= ~GrDrawTargetCaps::kCanMap_MapFlag);
         str = "can_map";
 
         if (GrDrawTargetCaps::kSubset_MapFlag & flags) {
             str.append(" partial");
         } else {
             str.append(" full");
         }
         SkDEBUGCODE(flags &= ~GrDrawTargetCaps::kSubset_MapFlag);
     }
     SkASSERT(0 == flags); // Make sure we handled all the flags.
     return str;
 }
 
+static const char* shader_type_to_string(GrShaderType type) {
+    switch (type) {
+        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) {
+    switch (p) {
+        case GrShaderVar::kLow_Precision:
+            return "low";
+        case GrShaderVar::kMedium_Precision:
+            return "medium";
+        case GrShaderVar::kHigh_Precision:
+            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]);
     r.appendf("Two Sided Stencil Support          : %s\n", gNY[fTwoSidedStencilSupport]);
     r.appendf("Stencil Wrap Ops  Support          : %s\n", gNY[fStencilWrapOpsSupport]);
     r.appendf("HW AA Lines Support                : %s\n", gNY[fHWAALineSupport]);
     r.appendf("Shader Derivative Support          : %s\n", gNY[fShaderDerivativeSupport]);
     r.appendf("Geometry Shader Support            : %s\n", gNY[fGeometryShaderSupport]);
@@ skipping 55 matching lines @@
     }
 
     SkASSERT(!fConfigTextureSupport[kUnknown_GrPixelConfig]);
 
     for (size_t i = 1; i < SK_ARRAY_COUNT(kConfigNames); ++i)  {
         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) {
+            if (fFloatPrecisions[s][p].supported()) {
+                GrShaderVar::Precision precision = static_cast<GrShaderVar::Precision>(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;
 }
 
 uint32_t GrDrawTargetCaps::CreateUniqueID() {
     static int32_t gUniqueID = SK_InvalidUniqueID;
     uint32_t id;
     do {
         id = static_cast<uint32_t>(sk_atomic_inc(&gUniqueID) + 1);
     } while (id == SK_InvalidUniqueID);
     return id;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool GrClipTarget::setupClip(const SkRect* devBounds,
                              GrDrawState::AutoRestoreEffects* are,
                              GrDrawState::AutoRestoreStencil* ars,
                              GrDrawState* ds,
                              GrClipMaskManager::ScissorState* scissorState) {
     return fClipMaskManager.setupClipping(ds,
                                           are,
                                           ars,
                                           scissorState,
                                           this->getClip(),
                                           devBounds);
 }