Rename GrGLUniformManager to GrGLProgramResourceManager

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 369 matching lines @@
 
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTBackendEffectFactory.h"
 #include "gl/GrGLShaderBuilder.h"
 #include "SkGr.h"
 
 // For brevity
-typedef GrGLUniformManager::UniformHandle UniformHandle;
+typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 class GrGLRadial2Gradient : public GrGLGradientEffect {
 
 public:
 
     GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&);
     virtual ~GrGLRadial2Gradient() { }
 
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           const GrEffectKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
 
     static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
 
 protected:
 
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
@@ skipping 201 matching lines @@
         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->emitColor(builder, t.c_str(), baseKey, outputColor, inputColor, samplers);
 }
 
-void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman,
+void GrGLRadial2Gradient::setData(const GrGLProgramDataManager& pdman,
                                   const GrDrawEffect& drawEffect) {
-    INHERITED::setData(uman, drawEffect);
+    INHERITED::setData(pdman, drawEffect);
     const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>();
     SkASSERT(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(fParamUni, 6, values);
+        pdman.set1fv(fParamUni, 6, values);
         fCachedCenter = centerX1;
         fCachedRadius = radius0;
         fCachedPosRoot = data.isPosRoot();
     }
 }
 
 void GrGLRadial2Gradient::GenKey(const GrDrawEffect& drawEffect,
                                  const GrGLCaps&, GrEffectKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(drawEffect);
@@ skipping 39 matching lines @@
 #else
 
 bool SkTwoPointRadialGradient::asNewEffect(GrContext* context, const SkPaint& paint,
                                            const SkMatrix* localMatrix, GrColor* paintColor,
                                            GrEffect** effect)  const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif