Make addUniform take a precision

Review URL: https://codereview.chromium.org/788733003

diff --git a/include/gpu/GrShaderVar.h b/include/gpu/GrShaderVar.h
index 3ef24b0..53d0c0f 100644 (file)
--- a/include/gpu/GrShaderVar.h
+++ b/include/gpu/GrShaderVar.h
@@ -51,6 +51,7 @@ public:
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         SkASSERT(kVoid_GrSLType != type);
     }
 
@@ -61,6 +62,7 @@ public:
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         SkASSERT(kVoid_GrSLType != type);
     }
 
@@ -71,6 +73,7 @@ public:
         , fName(name)
         , fCount(arrayCount)
         , fPrecision(precision) {
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         SkASSERT(kVoid_GrSLType != type);
     }
 
@@ -90,6 +93,7 @@ public:
              const SkString& name,
              GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
@@ -105,6 +109,7 @@ public:
              const char* name,
              GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
@@ -121,6 +126,7 @@ public:
              int count,
              GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;
@@ -137,6 +143,7 @@ public:
              int count,
              GrSLPrecision precision = kDefault_GrSLPrecision) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         fType = type;
         fTypeModifier = typeModifier;
         fName = name;

diff --git a/include/gpu/GrTypesPriv.h b/include/gpu/GrTypesPriv.h
index 2a8d4c3..d5227ae 100644 (file)
--- a/include/gpu/GrTypesPriv.h
+++ b/include/gpu/GrTypesPriv.h
@@ -40,7 +40,8 @@ static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
 
 /**
  * Precisions of shader language variables. Not all shading languages support precisions or actually
- * vary the internal precision based on the qualifiers.
+ * vary the internal precision based on the qualifiers. These currently only apply to float types (
+ * including float vectors and matrices).
  */
 enum GrSLPrecision {
     kLow_GrSLPrecision,
@@ -87,6 +88,21 @@ static inline GrSLType GrSLFloatVectorType(int count) {
     GR_STATIC_ASSERT(kVec4f_GrSLType == 4);
 }
 
+/** Is the shading language type floating point (or vector/matrix of fp)? */
+static inline bool GrSLTypeIsFloatType(GrSLType type) {
+    SkASSERT(type >= 0 && type < static_cast<GrSLType>(kGrSLTypeCount));
+    return type >= 1 && type <= 6;
+
+    GR_STATIC_ASSERT(0 == kVoid_GrSLType);
+    GR_STATIC_ASSERT(1 == kFloat_GrSLType);
+    GR_STATIC_ASSERT(2 == kVec2f_GrSLType);
+    GR_STATIC_ASSERT(3 == kVec3f_GrSLType);
+    GR_STATIC_ASSERT(4 == kVec4f_GrSLType);
+    GR_STATIC_ASSERT(5 == kMat33f_GrSLType);
+    GR_STATIC_ASSERT(6 == kMat44f_GrSLType);
+    GR_STATIC_ASSERT(7 == kSampler2D_GrSLType);
+    GR_STATIC_ASSERT(8 == kGrSLTypeCount);
+}
 //////////////////////////////////////////////////////////////////////////////
 
 /**

diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 6f9fefc..8908a6a 100644 (file)
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -143,10 +143,12 @@ void GrGLAlphaThresholdEffect::emitCode(GrGLFPBuilder* builder,
                                         const TextureSamplerArray& samplers) {
     fInnerThresholdVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility,
-        kFloat_GrSLType, "inner_threshold");
+        kFloat_GrSLType, kDefault_GrSLPrecision,
+        "inner_threshold");
     fOuterThresholdVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility,
-        kFloat_GrSLType, "outer_threshold");
+        kFloat_GrSLType, kDefault_GrSLPrecision,
+        "outer_threshold");
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);

diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index 240173b..a1f14ec 100644 (file)
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -371,7 +371,8 @@ void GrGLArithmeticEffect::emitCode(GrGLFPBuilder* builder,
 
     SkASSERT(dstColor);
     fKUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                kVec4f_GrSLType, "k");
+                                kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                "k");
     const char* kUni = builder->getUniformCStr(fKUni);
 
     // We don't try to optimize for this case at all

diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index f7174e9..7692fe7 100644 (file)
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -707,10 +707,12 @@ void GrGLRectBlurEffect::emitCode(GrGLFPBuilder* builder,
 
     fProxyRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
+                                            kDefault_GrSLPrecision,
                                             "proxyRect",
                                             &rectName);
     fProfileSizeUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kFloat_GrSLType,
+                                            kDefault_GrSLPrecision,
                                             "profileSize",
                                             &profileSizeName);
 
@@ -1047,16 +1049,19 @@ void GrGLRRectBlurEffect::emitCode(GrGLFPBuilder* builder,
 
     fProxyRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType,
+                                            kDefault_GrSLPrecision,
                                             "proxyRect",
                                             &rectName);
     fCornerRadiusUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                 kFloat_GrSLType,
-                                                 "cornerRadius",
-                                                 &cornerRadiusName);
+                                               kFloat_GrSLType,
+                                               kDefault_GrSLPrecision,
+                                               "cornerRadius",
+                                               &cornerRadiusName);
     fBlurRadiusUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                 kFloat_GrSLType,
-                                                 "blurRadius",
-                                                 &blurRadiusName);
+                                             kFloat_GrSLType,
+                                              kDefault_GrSLPrecision,
+                                              "blurRadius",
+                                              &blurRadiusName);
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     const char* fragmentPos = fsBuilder->fragmentPosition();

diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
index c26229d..dd20a27 100644 (file)
--- a/src/effects/SkColorCubeFilter.cpp
+++ b/src/effects/SkColorCubeFilter.cpp
@@ -281,10 +281,12 @@ void GrColorCubeEffect::GLProcessor::emitCode(GrGLFPBuilder* builder,
     }
 
     fColorCubeSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kFloat_GrSLType, "Size");
+                                            kFloat_GrSLType, kDefault_GrSLPrecision,
+                                            "Size");
     const char* colorCubeSizeUni = builder->getUniformCStr(fColorCubeSizeUni);
     fColorCubeInvSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                               kFloat_GrSLType, "InvSize");
+                                               kFloat_GrSLType, kDefault_GrSLPrecision,
+                                               "InvSize");
     const char* colorCubeInvSizeUni = builder->getUniformCStr(fColorCubeInvSizeUni);
 
     const char* nonZeroAlpha = "nonZeroAlpha";

diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index d8cc42c..f162d2d 100644 (file)
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -225,7 +225,8 @@ public:
             const char* colorFilterColorUniName = NULL;
             if (fp.cast<ModeColorFilterEffect>().willUseFilterColor()) {
                 fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                      kVec4f_GrSLType, "FilterColor",
+                                                      kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                                      "FilterColor",
                                                       &colorFilterColorUniName);
             }
 

diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index c497655..32f94d9 100644 (file)
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -362,10 +362,10 @@ public:
                               const TransformedCoordsArray&,
                               const TextureSamplerArray&) SK_OVERRIDE {
             fMatrixHandle = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                kMat44f_GrSLType,
+                                                kMat44f_GrSLType, kDefault_GrSLPrecision,
                                                 "ColorMatrix");
             fVectorHandle = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                kVec4f_GrSLType,
+                                                kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                 "ColorMatrixVector");
 
             if (NULL == inputColor) {

diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 04919ee..f13a349 100644 (file)
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -533,7 +533,7 @@ void GrGLDisplacementMapEffect::emitCode(GrGLFPBuilder* builder,
     sk_ignore_unused_variable(inputColor);
 
     fScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kVec2f_GrSLType, "Scale");
+                                    kVec2f_GrSLType, kDefault_GrSLPrecision, "Scale");
     const char* scaleUni = builder->getUniformCStr(fScaleUni);
     const char* dColor = "dColor";
     const char* cCoords = "cCoords";

diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 512c13e..adac45b 100644 (file)
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -1337,10 +1337,10 @@ void GrGLLightingEffect::emitCode(GrGLFPBuilder* builder,
                                   const TransformedCoordsArray& coords,
                                   const TextureSamplerArray& samplers) {
     fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                              kVec2f_GrSLType,
+                                              kVec2f_GrSLType, kDefault_GrSLPrecision,
                                              "ImageIncrement");
     fSurfaceScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                           kFloat_GrSLType,
+                                           kFloat_GrSLType, kDefault_GrSLPrecision,
                                            "SurfaceScale");
     fLight->emitLightColorUniform(builder);
     SkString lightFunc;
@@ -1453,9 +1453,8 @@ GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProcessor& proc)
 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
     const char* kd;
     fKDUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                 kFloat_GrSLType,
-                                 "KD",
-                                 &kd);
+                                 kFloat_GrSLType, kDefault_GrSLPrecision,
+                                 "KD", &kd);
 
     static const GrGLShaderVar gLightArgs[] = {
         GrGLShaderVar("normal", kVec3f_GrSLType),
@@ -1539,9 +1538,9 @@ void GrGLSpecularLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString*
     const char* shininess;
 
     fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                 kFloat_GrSLType, "KS", &ks);
+                                 kFloat_GrSLType, kDefault_GrSLPrecision, "KS", &ks);
     fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                        kFloat_GrSLType, "Shininess", &shininess);
+                                        kFloat_GrSLType, kDefault_GrSLPrecision, "Shininess", &shininess);
 
     static const GrGLShaderVar gLightArgs[] = {
         GrGLShaderVar("normal", kVec3f_GrSLType),
@@ -1572,7 +1571,8 @@ void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman,
 ///////////////////////////////////////////////////////////////////////////////
 void GrGLLight::emitLightColorUniform(GrGLFPBuilder* builder) {
     fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kVec3f_GrSLType, "LightColor");
+                                    kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                    "LightColor");
 }
 
 void GrGLLight::emitLightColor(GrGLFPBuilder* builder,
@@ -1597,7 +1597,8 @@ void GrGLDistantLight::setData(const GrGLProgramDataManager& pdman,
 
 void GrGLDistantLight::emitSurfaceToLight(GrGLFPBuilder* builder, const char* z) {
     const char* dir;
-    fDirectionUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec3f_GrSLType,
+    fDirectionUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                        kVec3f_GrSLType, kDefault_GrSLPrecision,
                                         "LightDirection", &dir);
     builder->getFragmentShaderBuilder()->codeAppend(dir);
 }
@@ -1614,7 +1615,8 @@ void GrGLPointLight::setData(const GrGLProgramDataManager& pdman,
 
 void GrGLPointLight::emitSurfaceToLight(GrGLFPBuilder* builder, const char* z) {
     const char* loc;
-    fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec3f_GrSLType,
+    fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                       kVec3f_GrSLType, kDefault_GrSLPrecision,
                                        "LightLocation", &loc);
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))",
@@ -1639,7 +1641,8 @@ void GrGLSpotLight::setData(const GrGLProgramDataManager& pdman,
 void GrGLSpotLight::emitSurfaceToLight(GrGLFPBuilder* builder, const char* z) {
     const char* location;
     fLocationUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                       kVec3f_GrSLType, "LightLocation", &location);
+                                       kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                       "LightLocation", &location);
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     fsBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))",
@@ -1657,15 +1660,19 @@ void GrGLSpotLight::emitLightColor(GrGLFPBuilder* builder,
     const char* coneScale;
     const char* s;
     fExponentUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                       kFloat_GrSLType, "Exponent", &exponent);
+                                       kFloat_GrSLType, kDefault_GrSLPrecision,
+                                       "Exponent", &exponent);
     fCosInnerConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                kFloat_GrSLType, "CosInnerConeAngle", &cosInner);
+                                                kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                "CosInnerConeAngle", &cosInner);
     fCosOuterConeAngleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                kFloat_GrSLType, "CosOuterConeAngle", &cosOuter);
+                                                kFloat_GrSLType, kDefault_GrSLPrecision,
+                                                "CosOuterConeAngle", &cosOuter);
     fConeScaleUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                        kFloat_GrSLType, "ConeScale", &coneScale);
+                                        kFloat_GrSLType, kDefault_GrSLPrecision,
+                                        "ConeScale", &coneScale);
     fSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                kVec3f_GrSLType, "S", &s);
+                                kVec3f_GrSLType, kDefault_GrSLPrecision, "S", &s);
 
     static const GrGLShaderVar gLightColorArgs[] = {
         GrGLShaderVar("surfaceToLight", kVec3f_GrSLType)

diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 1f89473..ae6637b 100644 (file)
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -125,15 +125,15 @@ void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder,
     fOffsetVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility |
         GrGLProgramBuilder::kVertex_Visibility,
-        kVec2f_GrSLType, "Offset");
+        kVec2f_GrSLType, kDefault_GrSLPrecision, "Offset");
     fInvZoomVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility |
         GrGLProgramBuilder::kVertex_Visibility,
-        kVec2f_GrSLType, "InvZoom");
+        kVec2f_GrSLType, kDefault_GrSLPrecision, "InvZoom");
     fInvInsetVar = builder->addUniform(
         GrGLProgramBuilder::kFragment_Visibility |
         GrGLProgramBuilder::kVertex_Visibility,
-        kVec2f_GrSLType, "InvInset");
+        kVec2f_GrSLType, kDefault_GrSLPrecision, "InvInset");
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);

diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index f896751..4b64ca9 100644 (file)
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -353,7 +353,8 @@ void GrGLMorphologyEffect::emitCode(GrGLFPBuilder* builder,
                                     const TransformedCoordsArray& coords,
                                     const TextureSamplerArray& samplers) {
     fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec2f_GrSLType, "ImageIncrement");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "ImageIncrement");
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);

diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index ebe6159..14c2193 100644 (file)
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -651,16 +651,19 @@ void GrGLPerlinNoise::emitCode(GrGLFPBuilder* builder,
     SkString vCoords = fsBuilder->ensureFSCoords2D(coords, 0);
 
     fBaseFrequencyUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kVec2f_GrSLType, "baseFrequency");
+                                            kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                            "baseFrequency");
     const char* baseFrequencyUni = builder->getUniformCStr(fBaseFrequencyUni);
     fAlphaUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kFloat_GrSLType, "alpha");
+                                    kFloat_GrSLType, kDefault_GrSLPrecision,
+                                    "alpha");
     const char* alphaUni = builder->getUniformCStr(fAlphaUni);
 
     const char* stitchDataUni = NULL;
     if (fStitchTiles) {
         fStitchDataUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec2f_GrSLType, "stitchData");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "stitchData");
         stitchDataUni = builder->getUniformCStr(fStitchDataUni);
     }
 

diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index db25a6f..942bae7 100644 (file)
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -343,7 +343,8 @@ void GLColorTableEffect::emitCode(GrGLFPBuilder* builder,
                                   const TextureSamplerArray& samplers) {
     const char* yoffsets;
     fRGBAYValuesUni = builder->addUniform(GrGLFPBuilder::kFragment_Visibility,
-                                          kVec4f_GrSLType, "yoffsets", &yoffsets);
+                                          kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                          "yoffsets", &yoffsets);
     static const float kColorScaleFactor = 255.0f / 256.0f;
     static const float kColorOffsetFactor = 1.0f / 512.0f;
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();

diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index f3e5131..815a81f 100644 (file)
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -900,21 +900,27 @@ void GrGLGradientEffect::emitUniforms(GrGLFPBuilder* builder, const GrGradientEf
 
     if (SkGradientShaderBase::kTwo_GpuColorType == ge.getColorType()) { // 2 Color case
         fColorStartUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec4f_GrSLType, "GradientStartColor");
+                                             kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                            "GradientStartColor");
         fColorEndUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                           kVec4f_GrSLType, "GradientEndColor");
+                                           kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                           "GradientEndColor");
 
     } else if (SkGradientShaderBase::kThree_GpuColorType == ge.getColorType()) { // 3 Color Case
         fColorStartUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec4f_GrSLType, "GradientStartColor");
+                                             kVec4f_GrSLType,  kDefault_GrSLPrecision,
+                                             "GradientStartColor");
         fColorMidUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                           kVec4f_GrSLType, "GradientMidColor");
+                                           kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                           "GradientMidColor");
         fColorEndUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec4f_GrSLType, "GradientEndColor");
+                                           kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                           "GradientEndColor");
 
     } else { // if not a fast case
         fFSYUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                      kFloat_GrSLType, "GradientYCoordFS");
+                                      kFloat_GrSLType, kDefault_GrSLPrecision,
+                                      "GradientYCoordFS");
     }
 }
 

diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
index e918429..fb55b22 100644 (file)
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -235,7 +235,8 @@ void GLEdge2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
     const Edge2PtConicalEffect& ge = fp.cast<Edge2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                         kFloat_GrSLType, "Conical2FSParams", 3);
+                                         kFloat_GrSLType, kDefault_GrSLPrecision,
+                                         "Conical2FSParams", 3);
 
     SkString cName("c");
     SkString tName("t");
@@ -520,7 +521,8 @@ void GLFocalOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
     const FocalOutside2PtConicalEffect& ge = fp.cast<FocalOutside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                         kFloat_GrSLType, "Conical2FSParams", 2);
+                                         kFloat_GrSLType, kDefault_GrSLPrecision,
+                                         "Conical2FSParams", 2);
     SkString tName("t");
     SkString p0; // focalX
     SkString p1; // 1 - focalX * focalX
@@ -734,7 +736,8 @@ void GLFocalInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
     const FocalInside2PtConicalEffect& ge = fp.cast<FocalInside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kFloat_GrSLType, "Conical2FSParams");
+                                    kFloat_GrSLType, kDefault_GrSLPrecision,
+                                    "Conical2FSParams");
     SkString tName("t");
 
     // this is the distance along x-axis from the end center to focal point in
@@ -990,9 +993,11 @@ void GLCircleInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
     const CircleInside2PtConicalEffect& ge = fp.cast<CircleInside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                     kVec2f_GrSLType, "Conical2FSCenter");
+                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                     "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kVec3f_GrSLType, "Conical2FSParams");
+                                    kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                    "Conical2FSParams");
     SkString tName("t");
 
     GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
@@ -1231,9 +1236,11 @@ void GLCircleOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
     const CircleOutside2PtConicalEffect& ge = fp.cast<CircleOutside2PtConicalEffect>();
     this->emitUniforms(builder, ge);
     fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                     kVec2f_GrSLType, "Conical2FSCenter");
+                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                     "Conical2FSCenter");
     fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                    kVec4f_GrSLType, "Conical2FSParams");
+                                    kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                    "Conical2FSParams");
     SkString tName("t");
 
     GrGLShaderVar center = builder->getUniformVariable(fCenterUni);

diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 2783112..4fb2996 100644 (file)
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -566,7 +566,8 @@ void GrGLRadial2Gradient::emitCode(GrGLFPBuilder* builder,
     const GrRadial2Gradient& ge = fp.cast<GrRadial2Gradient>();
     this->emitUniforms(builder, ge);
     fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                         kFloat_GrSLType, "Radial2FSParams", 6);
+                                         kFloat_GrSLType, kDefault_GrSLPrecision,
+                                         "Radial2FSParams", 6);
 
     SkString cName("c");
     SkString ac4Name("ac4");

diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp
index 804a087..8ada70e 100644 (file)
--- a/src/gpu/effects/GrBicubicEffect.cpp
+++ b/src/gpu/effects/GrBicubicEffect.cpp
@@ -60,9 +60,11 @@ void GrGLBicubicEffect::emitCode(GrGLFPBuilder* builder,
     const GrTextureDomain& domain = effect.cast<GrBicubicEffect>().domain();
 
     fCoefficientsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                           kMat44f_GrSLType, "Coefficients");
+                                           kMat44f_GrSLType, kDefault_GrSLPrecision,
+                                           "Coefficients");
     fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec2f_GrSLType, "ImageIncrement");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "ImageIncrement");
 
     const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
     const char* coeff = builder->getUniformCStr(fCoefficientsUni);

diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index 6f93fb5..248cd17 100644 (file)
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -118,6 +118,7 @@ void GLAARectEffect::emitCode(GrGLFPBuilder* builder,
     // respectively.
     fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                        kVec4f_GrSLType,
+                                       kDefault_GrSLPrecision,
                                        "rect",
                                        &rectName);
 
@@ -211,7 +212,8 @@ void GrGLConvexPolyEffect::emitCode(GrGLFPBuilder* builder,
     const char *edgeArrayName;
     fEdgeUniform = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                             kVec3f_GrSLType,
-                                            "edges",
+                                             kDefault_GrSLPrecision,
+                                             "edges",
                                             cpe.getEdgeCount(),
                                             &edgeArrayName);
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();

diff --git a/src/gpu/effects/GrConvolutionEffect.cpp b/src/gpu/effects/GrConvolutionEffect.cpp
index e4ac4ce..e3f051b 100644 (file)
--- a/src/gpu/effects/GrConvolutionEffect.cpp
+++ b/src/gpu/effects/GrConvolutionEffect.cpp
@@ -58,13 +58,16 @@ void GrGLConvolutionEffect::emitCode(GrGLFPBuilder* builder,
                                      const TransformedCoordsArray& coords,
                                      const TextureSamplerArray& samplers) {
     fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec2f_GrSLType, "ImageIncrement");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "ImageIncrement");
     if (this->useBounds()) {
         fBoundsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                         kVec2f_GrSLType, "Bounds");
+                                         kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                         "Bounds");
     }
     fKernelUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                          kFloat_GrSLType, "Kernel", this->width());
+                                          kFloat_GrSLType, kDefault_GrSLPrecision,
+                                          "Kernel", this->width());
 
     GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);

diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp
index be1b5e5..53485f6 100644 (file)
--- a/src/gpu/effects/GrDashingEffect.cpp
+++ b/src/gpu/effects/GrDashingEffect.cpp
@@ -539,9 +539,8 @@ void GLDashingCircleEffect::emitCode(const EmitArgs& args) {
     // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x coord, and
     // the total interval length of the dash.
     fParamUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                         kVec3f_GrSLType,
-                                         "params",
-                                         &paramName);
+                                         kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                         "params", &paramName);
 
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
 
@@ -762,13 +761,13 @@ void GLDashingLineEffect::emitCode(const EmitArgs& args) {
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                       kVec4f_GrSLType,
+                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
                                        "rect",
                                        &rectName);
     const char *intervalName;
     // The interval uniform's refers to the total length of the interval (on + off)
     fIntervalUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kFloat_GrSLType,
+                                            kFloat_GrSLType, kDefault_GrSLPrecision,
                                             "interval",
                                             &intervalName);
 

diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
index f1f4a9f..0570305 100755 (executable)
--- a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
+++ b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp
@@ -58,8 +58,8 @@ public:
 
         const char* textureSizeUniName = NULL;
         fTextureSizeUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                               kVec2f_GrSLType, "TextureSize",
-                                               &textureSizeUniName);
+                                               kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                               "TextureSize", &textureSizeUniName);
 
         fsBuilder->codeAppend("\tvec4 texColor = ");
         fsBuilder->appendTextureLookup(args.fSamplers[0],
@@ -107,8 +107,8 @@ public:
         const char* luminanceUniName = NULL;
         // width, height, 1/(3*width)
         fLuminanceUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kFloat_GrSLType, "Luminance",
-                                             &luminanceUniName);
+                                             kFloat_GrSLType, kDefault_GrSLPrecision,
+                                             "Luminance", &luminanceUniName);
 
         fsBuilder->codeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName);
         fsBuilder->codeAppend("\tvec4 gammaColor = ");
@@ -297,8 +297,8 @@ public:
 
         const char* textureSizeUniName = NULL;
         fTextureSizeUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                              kVec2f_GrSLType, "TextureSize",
-                                              &textureSizeUniName);
+                                              kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                              "TextureSize", &textureSizeUniName);
 
         fsBuilder->codeAppend("vec4 texColor = ");
         fsBuilder->appendTextureLookup(args.fSamplers[0],
@@ -474,8 +474,8 @@ public:
         const char* textureSizeUniName = NULL;
         // width, height, 1/(3*width)
         fTextureSizeUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                              kVec3f_GrSLType, "TextureSize",
-                                              &textureSizeUniName);
+                                              kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                              "TextureSize", &textureSizeUniName);
 
         GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
@@ -555,8 +555,8 @@ public:
         const char* textColorUniName = NULL;
         // width, height, 1/(3*width)
         fTextColorUni = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec3f_GrSLType, "TextColor",
-                                             &textColorUniName);
+                                             kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                             "TextColor", &textColorUniName);
 
         fsBuilder->codeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName);
         fsBuilder->codeAppend("\tvec4 gammaColor = ");

diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
index 3cd3588..6a71099 100644 (file)
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -55,19 +55,20 @@ void GrGLMatrixConvolutionEffect::emitCode(GrGLFPBuilder* builder,
     const GrTextureDomain& domain = fp.cast<GrMatrixConvolutionEffect>().domain();
 
     fBoundsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                     kVec4f_GrSLType, "Bounds");
+                                     kVec4f_GrSLType, kDefault_GrSLPrecision, "Bounds");
     fImageIncrementUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kVec2f_GrSLType, "ImageIncrement");
+                                             kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                             "ImageIncrement");
     fKernelUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
-                                          kFloat_GrSLType,
+                                          kFloat_GrSLType, kDefault_GrSLPrecision,
                                           "Kernel",
                                           fKernelSize.width() * fKernelSize.height());
     fKernelOffsetUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                           kVec2f_GrSLType, "KernelOffset");
+                                           kVec2f_GrSLType, kDefault_GrSLPrecision, "KernelOffset");
     fGainUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                   kFloat_GrSLType, "Gain");
+                                   kFloat_GrSLType, kDefault_GrSLPrecision, "Gain");
     fBiasUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                   kFloat_GrSLType, "Bias");
+                                   kFloat_GrSLType, kDefault_GrSLPrecision, "Bias");
 
     const char* kernelOffset = builder->getUniformCStr(fKernelOffsetUni);
     const char* imgInc = builder->getUniformCStr(fImageIncrementUni);

diff --git a/src/gpu/effects/GrOvalEffect.cpp b/src/gpu/effects/GrOvalEffect.cpp
index 1ea93a9..b750599 100644 (file)
--- a/src/gpu/effects/GrOvalEffect.cpp
+++ b/src/gpu/effects/GrOvalEffect.cpp
@@ -131,7 +131,7 @@ void GLCircleEffect::emitCode(GrGLFPBuilder* builder,
     // The circle uniform is (center.x, center.y, radius + 0.5) for regular fills and
     // (... ,radius - 0.5) for inverse fills.
     fCircleUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                         kVec3f_GrSLType,
+                                         kVec3f_GrSLType, kDefault_GrSLPrecision,
                                          "circle",
                                          &circleName);
 
@@ -308,7 +308,7 @@ void GLEllipseEffect::emitCode(GrGLFPBuilder* builder,
     const char *ellipseName;
     // The ellipse uniform is (center.x, center.y, 1 / rx^2, 1 / ry^2)
     fEllipseUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                         kVec4f_GrSLType,
+                                         kVec4f_GrSLType, kDefault_GrSLPrecision,
                                          "ellipse",
                                          &ellipseName);
 

diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 4c8e886..64a9d41 100644 (file)
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -168,11 +168,11 @@ void GLCircularRRectEffect::emitCode(GrGLFPBuilder* builder,
     // only rectangular corners, that side's value corresponds to the rect edge's value outset by
     // half a pixel.
     fInnerRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kVec4f_GrSLType,
+                                            kVec4f_GrSLType, kDefault_GrSLPrecision,
                                             "innerRect",
                                             &rectName);
     fRadiusPlusHalfUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                 kFloat_GrSLType,
+                                                 kFloat_GrSLType, kDefault_GrSLPrecision,
                                                  "radiusPlusHalf",
                                                  &radiusPlusHalfName);
 
@@ -521,7 +521,7 @@ void GLEllipticalRRectEffect::emitCode(GrGLFPBuilder* builder,
     const char *rectName;
     // The inner rect is the rrect bounds inset by the x/y radii
     fInnerRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kVec4f_GrSLType,
+                                            kVec4f_GrSLType, kDefault_GrSLPrecision,
                                             "innerRect",
                                             &rectName);
 
@@ -544,7 +544,7 @@ void GLEllipticalRRectEffect::emitCode(GrGLFPBuilder* builder,
         case SkRRect::kSimple_Type: {
             const char *invRadiiXYSqdName;
             fInvRadiiSqdUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                      kVec2f_GrSLType,
+                                                      kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                       "invRadiiXY",
                                                       &invRadiiXYSqdName);
             fsBuilder->codeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");
@@ -555,7 +555,7 @@ void GLEllipticalRRectEffect::emitCode(GrGLFPBuilder* builder,
         case SkRRect::kNinePatch_Type: {
             const char *invRadiiLTRBSqdName;
             fInvRadiiSqdUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                      kVec4f_GrSLType,
+                                                      kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                       "invRadiiLTRB",
                                                       &invRadiiLTRBSqdName);
             fsBuilder->codeAppend("\t\tvec2 dxy = max(max(dxy0, dxy1), 0.0);\n");

diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index c6a9a22..b5b9ae4 100644 (file)
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -56,8 +56,9 @@ void GrTextureDomain::GLDomain::sampleTexture(GrGLShaderBuilder* builder,
         if (textureDomain.fIndex >= 0) {
             uniName.appendS32(textureDomain.fIndex);
         }
-        fDomainUni = program->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec4f_GrSLType,
-                uniName.c_str(), &name);
+        fDomainUni = program->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                         kVec4f_GrSLType, kDefault_GrSLPrecision,
+                                         uniName.c_str(), &name);
         fDomainName = name;
     }
 

diff --git a/src/gpu/effects/GrYUVtoRGBEffect.cpp b/src/gpu/effects/GrYUVtoRGBEffect.cpp
index a477f1e..6891739 100644 (file)
--- a/src/gpu/effects/GrYUVtoRGBEffect.cpp
+++ b/src/gpu/effects/GrYUVtoRGBEffect.cpp
@@ -48,8 +48,8 @@ public:
 
             const char* yuvMatrix   = NULL;
             fMatrixUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                             kMat44f_GrSLType, "YUVMatrix",
-                                             &yuvMatrix);
+                                             kMat44f_GrSLType, kDefault_GrSLPrecision,
+                                             "YUVMatrix", &yuvMatrix);
             fsBuilder->codeAppendf("\t%s = vec4(\n\t\t", outputColor);
             fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), coords[0].getType());
             fsBuilder->codeAppend(".r,\n\t\t");

diff --git a/src/gpu/gl/GrGLShaderVar.h b/src/gpu/gl/GrGLShaderVar.h
index 5d4d700..0a7b1de 100644 (file)
--- a/src/gpu/gl/GrGLShaderVar.h
+++ b/src/gpu/gl/GrGLShaderVar.h
@@ -87,6 +87,7 @@ public:
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         INHERITED::set(type, typeModifier, name, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
@@ -102,6 +103,7 @@ public:
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         INHERITED::set(type, typeModifier, name, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
@@ -118,6 +120,7 @@ public:
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         INHERITED::set(type, typeModifier, name, count, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
@@ -134,6 +137,7 @@ public:
              Origin origin = kDefault_Origin,
              bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
         SkASSERT(kVoid_GrSLType != type);
+        SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
         INHERITED::set(type, typeModifier, name, count, precision);
         fOrigin = origin;
         fUseUniformFloatArrays = useUniformFloatArrays;
@@ -153,6 +157,7 @@ public:
      * Write a declaration of this variable to out.
      */
     void appendDecl(const GrGLContextInfo& ctxInfo, SkString* out) const {
+        SkASSERT(kDefault_GrSLPrecision == fPrecision || GrSLTypeIsFloatType(fType));
         if (kUpperLeft_Origin == fOrigin) {
             // this is the only place where we specify a layout modifier. If we use other layout
             // modifiers in the future then they should be placed in a list.

diff --git a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
index 6de5f69..49be12d 100644 (file)
--- a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
@@ -147,6 +147,7 @@ const char* GrGLFragmentShaderBuilder::fragmentPosition() {
             fProgramBuilder->fUniformHandles.fRTHeightUni =
                     fProgramBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                 kFloat_GrSLType,
+                                                kDefault_GrSLPrecision,
                                                 "RTHeight",
                                                 &rtHeightName);
 
@@ -199,16 +200,19 @@ void GrGLFragmentShaderBuilder::emitCodeToReadDstTexture() {
     fProgramBuilder->fUniformHandles.fDstCopySamplerUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                         kSampler2D_GrSLType,
+                                        kDefault_GrSLPrecision,
                                         "DstCopySampler",
                                         &dstCopySamplerName);
     fProgramBuilder->fUniformHandles.fDstCopyTopLeftUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                         kVec2f_GrSLType,
+                                        kDefault_GrSLPrecision,
                                         "DstCopyUpperLeft",
                                         &dstCopyTopLeftName);
     fProgramBuilder->fUniformHandles.fDstCopyScaleUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                         kVec2f_GrSLType,
+                                        kDefault_GrSLPrecision,
                                         "DstCopyCoordScale",
                                         &dstCopyCoordScaleName);
     const char* fragPos = this->fragmentPosition();

diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 9ce3bb2..e10aa65 100644 (file)
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -140,15 +140,18 @@ void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* na
     }
 }
 
-GrGLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(uint32_t visibility,
-                                                                          GrSLType type,
-                                                                          const char* name,
-                                                                          int count,
-                                                                          const char** outName) {
+GrGLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(
+                                                                uint32_t visibility,
+                                                                GrSLType type,
+                                                                GrSLPrecision precision,
+                                                                const char* name,
+                                                                int count,
+                                                                const char** outName) {
     SkASSERT(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
     SkASSERT(0 == (~kVisibilityMask & visibility));
     SkASSERT(0 != visibility);
+    SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsFloatType(type));
 
     UniformInfo& uni = fUniforms.push_back();
     uni.fVariable.setType(type);
@@ -166,14 +169,7 @@ GrGLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(uint32
     this->nameVariable(uni.fVariable.accessName(), prefix, name);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
-
-    // If it is visible in both the VS and FS, the precision must match.
-    // We declare a default FS precision, but not a default VS. So set the var
-    // to use the default FS precision.
-    if ((kVertex_Visibility | kFragment_Visibility) == visibility) {
-        // the fragment and vertex precisions must match
-        uni.fVariable.setPrecision(kDefault_GrSLPrecision);
-    }
+    uni.fVariable.setPrecision(precision);
 
     if (outName) {
         *outName = uni.fVariable.c_str();
@@ -202,9 +198,8 @@ void GrGLProgramBuilder::setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* input
         const char* name;
         fUniformHandles.fColorUni =
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                             kVec4f_GrSLType,
-                             "Color",
-                             &name);
+                             kVec4f_GrSLType, kDefault_GrSLPrecision,
+                             "Color", &name);
         *inputColor = GrGLSLExpr4(name);
     } else if (GrProgramDesc::kAllOnes_ColorInput == header.fColorInput) {
         *inputColor = GrGLSLExpr4(1);
@@ -213,9 +208,8 @@ void GrGLProgramBuilder::setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* input
         const char* name;
         fUniformHandles.fCoverageUni =
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                             kFloat_GrSLType,
-                             "Coverage",
-                             &name);
+                             kFloat_GrSLType, kDefault_GrSLPrecision,
+                             "Coverage",&name);
         *inputCoverage = GrGLSLExpr1(name);
     } else if (GrProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
         *inputCoverage = GrGLSLExpr1(1);
@@ -397,7 +391,7 @@ void GrGLProgramBuilder::emitTransforms(const GrPendingFragmentStage& stage,
             uniName = suffixedUniName.c_str();
         }
         ifp->fTransforms[t].fHandle = this->addUniform(GrGLProgramBuilder::kVertex_Visibility,
-                                                       kMat33f_GrSLType,
+                                                       kMat33f_GrSLType, kDefault_GrSLPrecision,
                                                        uniName,
                                                        &uniName).toShaderBuilderIndex();
 
@@ -431,7 +425,7 @@ void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor,
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
         ip->fSamplers[t].fUniform = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                     kSampler2D_GrSLType,
+                                                     kSampler2D_GrSLType, kDefault_GrSLPrecision,
                                                      name.c_str());
         SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
                                (ip->fSamplers[t].fUniform, processor.textureAccess(t)));

diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index 7288b94..1798e60 100644 (file)
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -45,15 +45,21 @@ public:
         supported at this time. The actual uniform name will be mangled. If outName is not NULL then
         it will refer to the final uniform name after return. Use the addUniformArray variant to add
         an array of uniforms. */
-    virtual UniformHandle addUniform(uint32_t visibility,
-                                     GrSLType type,
-                                     const char* name,
-                                     const char** outName = NULL) = 0;
-    virtual UniformHandle addUniformArray(uint32_t visibility,
-                                          GrSLType type,
-                                          const char* name,
-                                          int arrayCount,
-                                          const char** outName = NULL) = 0;
+    UniformHandle addUniform(uint32_t visibility,
+                             GrSLType type,
+                             GrSLPrecision precision,
+                             const char* name,
+                             const char** outName = NULL) {
+        return this->addUniformArray(visibility, type, precision, name, 0, outName);
+    }
+
+    virtual UniformHandle addUniformArray(
+        uint32_t visibility,
+        GrSLType type,
+        GrSLPrecision precision,
+        const char* name,
+        int arrayCount,
+        const char** outName = NULL) = 0;
 
     virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const = 0;
 
@@ -188,39 +194,34 @@ public:
      */
     static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
 
-    virtual UniformHandle addUniform(uint32_t visibility,
-                                     GrSLType type,
-                                     const char* name,
-                                     const char** outName = NULL) SK_OVERRIDE {
-        return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
-    }
-    virtual UniformHandle addUniformArray(uint32_t visibility,
-                                          GrSLType type,
-                                          const char* name,
-                                          int arrayCount,
-                                          const char** outName = NULL) SK_OVERRIDE;
+    UniformHandle addUniformArray(uint32_t visibility,
+                                  GrSLType type,
+                                  GrSLPrecision precision,
+                                  const char* name,
+                                  int arrayCount,
+                                  const char** outName) SK_OVERRIDE;
 
-    virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
+    const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
         return fUniforms[u.toShaderBuilderIndex()].fVariable;
     }
 
-    virtual const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
+    const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
         return this->getUniformVariable(u).c_str();
     }
 
-    virtual const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
+    const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
 
-    virtual GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
+    GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
 
-    virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
-    virtual GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
+    GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
+    GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
 
-    virtual void addVarying(
+    void addVarying(
             const char* name,
             GrGLVarying*,
             GrSLPrecision fsPrecision = kDefault_GrSLPrecision) SK_OVERRIDE;
 
-    virtual void addPassThroughAttribute(const GrGeometryProcessor::GrAttribute*,
+    void addPassThroughAttribute(const GrGeometryProcessor::GrAttribute*,
                                          const char* output) SK_OVERRIDE;
 
 

diff --git a/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp b/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
index 63cd352..5f66420 100644 (file)
--- a/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLVertexShaderBuilder.cpp
@@ -29,7 +29,7 @@ void GrGLVertexBuilder::addVarying(const char* name, GrGLVarying* v) {
 void GrGLVertexBuilder::setupUniformViewMatrix() {
     fProgramBuilder->fUniformHandles.fViewMatrixUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kVertex_Visibility,
-                                        kMat33f_GrSLType,
+                                        kMat33f_GrSLType, kDefault_GrSLPrecision,
                                         this->uViewM());
 }
 
@@ -46,7 +46,7 @@ void GrGLVertexBuilder::transformToNormalizedDeviceSpace() {
     // setup RT Uniform
     fProgramBuilder->fUniformHandles.fRTAdjustmentUni =
             fProgramBuilder->addUniform(GrGLProgramBuilder::kVertex_Visibility,
-                                        kVec4f_GrSLType,
+                                        kVec4f_GrSLType, kDefault_GrSLPrecision,
                                         fProgramBuilder->rtAdjustment(),
                                         &fRtAdjustName);
     // Wire transforms