Use texture size to determine precision of texture coord varyings

src/gpu/gl/GrGLProgramDesc.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrGLProgramDesc.h"
 
 #include "GrGLProcessor.h"
 #include "GrProcessor.h"
 #include "GrGpuGL.h"
 #include "GrOptDrawState.h"
 #include "SkChecksum.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 
 /**
- * The key for an individual coord transform is made up of a matrix type and a bit that
- * indicates the source of the input coords.
- */
-enum {
-    kMatrixTypeKeyBits   = 1,
-    kMatrixTypeKeyMask   = (1 << kMatrixTypeKeyBits) - 1,
-    kPositionCoords_Flag = (1 << kMatrixTypeKeyBits),
-    kTransformKeyBits    = kMatrixTypeKeyBits + 1,
-};
-
-/**
- * We specialize the vertex code for each of these matrix types.
- */
-enum MatrixType {
-    kNoPersp_MatrixType  = 0,
-    kGeneral_MatrixType  = 1,
-};
-
-/**
  * Do we need to either map r,g,b->a or a->r. configComponentMask indicates which channels are
  * present in the texture's config. swizzleComponentMask indicates the channels present in the
  * shader swizzle.
  */
 static bool swizzle_requires_alpha_remapping(const GrGLCaps& caps,
                                              uint32_t configComponentMask,
                                              uint32_t swizzleComponentMask) {
     if (caps.textureSwizzleSupport()) {
         // Any remapping is handled using texture swizzling not shader modifications.
         return false;
@@ skipping 19 matching lines @@
     const GrGeometryProcessor::VertexAttribArray& vars = proc.getAttribs();
     int numAttributes = vars.count();
     SkASSERT(numAttributes <= GrGeometryProcessor::kMaxVertexAttribs);
     for (int a = 0; a < numAttributes; ++a) {
         uint32_t value = 1 << a;
         key |= value;
     }
     return key;
 }
 
-static uint32_t gen_transform_key(const GrPendingFragmentStage& stage,
-                                  bool useExplicitLocalCoords) {
+/**
+ * The key for an individual coord transform is made up of a matrix type, a precision, and a bit
+ * that indicates the source of the input coords.
+ */
+enum {
+    kMatrixTypeKeyBits   = 1,
+    kMatrixTypeKeyMask   = (1 << kMatrixTypeKeyBits) - 1,
+    
+    kPrecisionBits       = 2,
+    kPrecisionShift      = kMatrixTypeKeyBits,
+
+    kPositionCoords_Flag = (1 << (kPrecisionShift + kPrecisionBits)),
+
+    kTransformKeyBits    = kMatrixTypeKeyBits + kPrecisionBits + 1,
+};
+
+GR_STATIC_ASSERT(GrShaderVar::kHigh_Precision < (1 << kPrecisionBits));
+
+/**
+ * We specialize the vertex code for each of these matrix types.
+ */
+enum MatrixType {
+    kNoPersp_MatrixType  = 0,
+    kGeneral_MatrixType  = 1,
+};
+
+static uint32_t gen_transform_key(const GrPendingFragmentStage& stage, bool useExplicitLocalCoords) {
     uint32_t totalKey = 0;
     int numTransforms = stage.getProcessor()->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         uint32_t key = 0;
         if (stage.isPerspectiveCoordTransform(t)) {
             key |= kGeneral_MatrixType;
         } else {
             key |= kNoPersp_MatrixType;
         }
 
         const GrCoordTransform& coordTransform = stage.getProcessor()->coordTransform(t);
         if (kLocal_GrCoordSet != coordTransform.sourceCoords() && useExplicitLocalCoords) {
             key |= kPositionCoords_Flag;
         }
+
+        SkASSERT(coordTransform.precision() <= (1 << kPrecisionBits));
+        key |= (coordTransform.precision() << kPrecisionShift);
+
         key <<= kTransformKeyBits * t;
+
         SkASSERT(0 == (totalKey & key)); // keys for each transform ought not to overlap
         totalKey |= key;
     }
     return totalKey;
 }
 
 static uint32_t gen_texture_key(const GrProcessor& proc, const GrGLCaps& caps) {
     uint32_t key = 0;
     int numTextures = proc.numTextures();
     for (int t = 0; t < numTextures; ++t) {
@@ skipping 148 matching lines @@
     }
 
     header->fPrimaryOutputType = descInfo.fPrimaryOutputType;
     header->fSecondaryOutputType = descInfo.fSecondaryOutputType;
 
     header->fColorEffectCnt = optState.numColorStages();
     header->fCoverageEffectCnt = optState.numCoverageStages();
     desc->finalize();
     return true;
 }