Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/effects/gradients/SkTwoPointRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
  #include "SkTwoPointRadialGradient.h"
 
@@ skipping 356 matching lines @@
     fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
     fPtsToUnit.postScale(inv, inv);
 }
 
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTBackendEffectFactory.h"
 
-// For brevity
-typedef GrGLUniformManager::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
-
 class GrGLRadial2Gradient : public GrGLGradientEffect {
 
 public:
 
     GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&);
     virtual ~GrGLRadial2Gradient() { }
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
     static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
 
 protected:
 
-    UniformHandle   fVSParamUni;
-    UniformHandle   fFSParamUni;
+    GrGLUniform* fVSParamUni;
+    GrGLUniform* fFSParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsDegenerate;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenter;
@@ skipping 97 matching lines @@
                                                                          tm));
     SkPaint paint;
     return shader->asNewEffect(context, paint);
 }
 
 /////////////////////////////////////////////////////////////////////
 
 GrGLRadial2Gradient::GrGLRadial2Gradient(const GrBackendEffectFactory& factory,
                                          const GrDrawEffect& drawEffect)
     : INHERITED(factory)
-    , fVSParamUni(kInvalidUniformHandle)
-    , fFSParamUni(kInvalidUniformHandle)
+    , fVSParamUni(NULL)
+    , fFSParamUni(NULL)
     , fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenter(SK_ScalarMax)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedPosRoot(0) {
 
     const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>();
     fIsDegenerate = data.isDegenerate();
 }
 
 void GrGLRadial2Gradient::emitCode(GrGLShaderBuilder* builder,
                                    const GrDrawEffect& drawEffect,
                                    EffectKey key,
                                    const char* outputColor,
                                    const char* inputColor,
                                    const TextureSamplerArray& samplers) {
 
-    this->emitYCoordUniform(builder);
+    GrGLShaderBuilder::Uniform* yCoordUni = this->emitYCoordUniform(builder);
     const char* fsCoords;
     const char* vsCoordsVarying;
     GrSLType coordsVaryingType;
     this->setupMatrix(builder, key, &fsCoords, &vsCoordsVarying, &coordsVaryingType);
 
     // 2 copies of uniform array, 1 for each of vertex & fragment shader,
     // to work around Xoom bug. Doesn't seem to cause performance decrease
     // in test apps, but need to keep an eye on it.
-    fVSParamUni = builder->addUniformArray(GrGLShaderBuilder::kVertex_ShaderType,
-                                           kFloat_GrSLType, "Radial2VSParams", 6);
-    fFSParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_ShaderType,
-                                           kFloat_GrSLType, "Radial2FSParams", 6);
+    GrGLShaderBuilder::Uniform* vsParamUni =
+        builder->addUniformArray(GrGLShaderBuilder::kVertex_ShaderType,
+                                 kFloat_GrSLType, "Radial2VSParams", 6);
+    fVSParamUni = vsParamUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* fsParamUni =
+        builder->addUniformArray(GrGLShaderBuilder::kFragment_ShaderType,
+                                 kFloat_GrSLType, "Radial2FSParams", 6);
+    fFSParamUni = fsParamUni->glUniform();
 
     // For radial gradients without perspective we can pass the linear
     // part of the quadratic as a varying.
     if (kVec2f_GrSLType == coordsVaryingType) {
         builder->addVarying(kFloat_GrSLType, "Radial2BCoeff", &fVSVaryingName, &fFSVaryingName);
     }
 
     // VS
     {
         SkString p2;
         SkString p3;
-        builder->getUniformVariable(fVSParamUni).appendArrayAccess(2, &p2);
-        builder->getUniformVariable(fVSParamUni).appendArrayAccess(3, &p3);
+        vsParamUni->appendArrayAccess(2, &p2);
+        vsParamUni->appendArrayAccess(3, &p3);
 
         // For radial gradients without perspective we can pass the linear
         // part of the quadratic as a varying.
         if (kVec2f_GrSLType == coordsVaryingType) {
             // r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
             builder->vsCodeAppendf("\t%s = 2.0 *(%s * %s.x - %s);\n",
                                    fVSVaryingName, p2.c_str(),
                                    vsCoordsVarying, p3.c_str());
         }
     }
 
     // FS
     {
         SkString cName("c");
         SkString ac4Name("ac4");
         SkString rootName("root");
         SkString t;
         SkString p0;
         SkString p1;
         SkString p2;
         SkString p3;
         SkString p4;
         SkString p5;
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(0, &p0);
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(1, &p1);
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(2, &p2);
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(3, &p3);
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(4, &p4);
-        builder->getUniformVariable(fFSParamUni).appendArrayAccess(5, &p5);
+        fsParamUni->appendArrayAccess(0, &p0);
+        fsParamUni->appendArrayAccess(1, &p1);
+        fsParamUni->appendArrayAccess(2, &p2);
+        fsParamUni->appendArrayAccess(3, &p3);
+        fsParamUni->appendArrayAccess(4, &p4);
+        fsParamUni->appendArrayAccess(5, &p5);
 
         // If we we're able to interpolate the linear component,
         // bVar is the varying; otherwise compute it
         SkString bVar;
         if (kVec2f_GrSLType == coordsVaryingType) {
             bVar = fFSVaryingName;
         } else {
             bVar = "b";
             builder->fsCodeAppendf("\tfloat %s = 2.0 * (%s * %s.x - %s);\n",
                                    bVar.c_str(), p2.c_str(), fsCoords, p3.c_str());
@@ skipping 22 matching lines @@
                                    ac4Name.c_str());
 
             // t is: (-b + params[5] * sqrt(b^2-4ac)) * params[1]
             t.printf("(-%s + %s * %s) * %s", bVar.c_str(), p5.c_str(),
                      rootName.c_str(), p1.c_str());
         } else {
             // t is: -c/b
             t.printf("-%s / %s", cName.c_str(), bVar.c_str());
         }
 
-        this->emitColorLookup(builder, t.c_str(), outputColor, inputColor, samplers[0]);
+        this->emitColorLookup(builder, yCoordUni, t.c_str(), outputColor, inputColor, samplers[0]);
     }
 }
 
-void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,
+void GrGLRadial2Gradient::setData(const GrGLContext& context,
                                   const GrDrawEffect& drawEffect) {
-    INHERITED::setData(uman, drawEffect);
+    INHERITED::setData(context, drawEffect);
     const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>();
     GrAssert(data.isDegenerate() == fIsDegenerate);
     SkScalar centerX1 = data.center();
     SkScalar radius0 = data.radius();
     if (fCachedCenter != centerX1 ||
         fCachedRadius != radius0 ||
         fCachedPosRoot != data.isPosRoot()) {
 
         SkScalar a = SkScalarMul(centerX1, centerX1) - SK_Scalar1;
 
         // When we're in the degenerate (linear) case, the second
         // value will be INF but the program doesn't read it. (We
         // use the same 6 uniforms even though we don't need them
         // all in the linear case just to keep the code complexity
         // down).
         float values[6] = {
             SkScalarToFloat(a),
             1 / (2.f * SkScalarToFloat(a)),
             SkScalarToFloat(centerX1),
             SkScalarToFloat(radius0),
             SkScalarToFloat(SkScalarMul(radius0, radius0)),
             data.isPosRoot() ? 1.f : -1.f
         };
 
-        uman.set1fv(fVSParamUni, 0, 6, values);
-        uman.set1fv(fFSParamUni, 0, 6, values);
+        fVSParamUni->set1fv(context, 0, 6, values);
+        fFSParamUni->set1fv(context, 0, 6, values);
         fCachedCenter = centerX1;
         fCachedRadius = radius0;
         fCachedPosRoot = data.isPosRoot();
     }
 }
 
 GrGLEffect::EffectKey GrGLRadial2Gradient::GenKey(const GrDrawEffect& drawEffect,
                                                   const GrGLCaps&) {
     enum {
         kIsDegenerate = 1 << kMatrixKeyBitCnt,
@@ skipping 30 matching lines @@
 }
 
 #else
 
 GrEffectRef* SkTwoPointRadialGradient::asNewEffect(GrContext*, const SkPaint&) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return NULL;
 }
 
 #endif