Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkOrderedReadBuffer.h"
 #include "SkOrderedWriteBuffer.h"
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLEffectMatrix.h"
 #include "GrEffect.h"
 #include "GrTBackendEffectFactory.h"
 
 class GrGLDiffuseLightingEffect;
 class GrGLSpecularLightingEffect;
 
-// For brevity
-typedef GrGLUniformManager::UniformHandle UniformHandle;
-static const UniformHandle kInvalidUniformHandle = GrGLUniformManager::kInvalidUniformHandle;
 #endif
 
 namespace {
 
 const SkScalar gOneThird = SkScalarInvert(SkIntToScalar(3));
 const SkScalar gTwoThirds = SkScalarDiv(SkIntToScalar(2), SkIntToScalar(3));
 const SkScalar gOneHalf = SkFloatToScalar(0.5f);
 const SkScalar gOneQuarter = SkFloatToScalar(0.25f);
 
 #if SK_SUPPORT_GPU
-void setUniformPoint3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {
+void setUniformPoint3(const GrGLContext& context, GrGLUniform* uni, const SkPoint3& point) {
     GR_STATIC_ASSERT(sizeof(SkPoint3) == 3 * sizeof(GrGLfloat));
-    uman.set3fv(uni, 0, 1, &point.fX);
+    uni->set3fv(context, 0, 1, &point.fX);
 }
 
-void setUniformNormal3(const GrGLUniformManager& uman, UniformHandle uni, const SkPoint3& point) {
-    setUniformPoint3(uman, uni, SkPoint3(point.fX, point.fY, point.fZ));
+void setUniformNormal3(const GrGLContext& context, GrGLUniform* uni, const SkPoint3& point) {
+    setUniformPoint3(context, uni, SkPoint3(point.fX, point.fY, point.fZ));
 }
 #endif
 
 // Shift matrix components to the left, as we advance pixels to the right.
 inline void shiftMatrixLeft(int m[9]) {
     m[0] = m[1];
     m[3] = m[4];
     m[6] = m[7];
     m[1] = m[2];
     m[4] = m[5];
@@ skipping 356 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLLight {
 public:
     virtual ~GrGLLight() {}
 
     /**
      * This is called by GrGLLightingEffect::emitCode() before either of the two virtual functions
      * below. It adds a vec3f uniform visible in the FS that represents the constant light color.
      */
-    void emitLightColorUniform(GrGLShaderBuilder*);
+    GrGLShaderBuilder::Uniform* emitLightColorUniform(GrGLShaderBuilder*);
 
     /**
      * These two functions are called from GrGLLightingEffect's emitCode() function.
      * emitSurfaceToLight places an expression in param out that is the vector from the surface to
      * the light. The expression will be used in the FS. emitLightColor writes an expression into
      * the FS that is the color of the light. Either function may add functions and/or uniforms to
      * the FS. The default of emitLightColor appends the name of the constant light color uniform
      * and so this function only needs to be overridden if the light color varies spatially.
      */
     virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) = 0;
-    virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight);
+    virtual void emitLightColor(GrGLShaderBuilder*, GrGLShaderBuilder::Uniform*, const char *surfaceToLight);
 
     // This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLight must call
     // INHERITED::setData().
-    virtual void setData(const GrGLUniformManager&,
+    virtual void setData(const GrGLContext&,
                          const SkLight* light,
                          const SkIPoint& offset) const;
 
 protected:
     /**
      * Gets the constant light color uniform. Subclasses can use this in their emitLightColor
      * function.
      */
-    UniformHandle lightColorUni() const { return fColorUni; }
+    GrGLUniform* lightColorUni() const { return fColorUni; }
 
 private:
-    UniformHandle fColorUni;
+    GrGLUniform* fColorUni;
 
     typedef SkRefCnt INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistantLight : public GrGLLight {
 public:
     virtual ~GrGLDistantLight() {}
-    virtual void setData(const GrGLUniformManager&,
+    virtual void setData(const GrGLContext&,
                          const SkLight* light,
                          const SkIPoint& offset) const SK_OVERRIDE;
     virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;
 
 private:
     typedef GrGLLight INHERITED;
-    UniformHandle fDirectionUni;
+    GrGLUniform* fDirectionUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLPointLight : public GrGLLight {
 public:
     virtual ~GrGLPointLight() {}
-    virtual void setData(const GrGLUniformManager&,
+    virtual void setData(const GrGLContext&,
                          const SkLight* light,
                          const SkIPoint& offset) const SK_OVERRIDE;
     virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;
 
 private:
     typedef GrGLLight INHERITED;
-    UniformHandle fLocationUni;
+    GrGLUniform* fLocationUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpotLight : public GrGLLight {
 public:
     virtual ~GrGLSpotLight() {}
-    virtual void setData(const GrGLUniformManager&,
+    virtual void setData(const GrGLContext&,
                          const SkLight* light,
                          const SkIPoint& offset) const SK_OVERRIDE;
     virtual void emitSurfaceToLight(GrGLShaderBuilder*, const char* z) SK_OVERRIDE;
-    virtual void emitLightColor(GrGLShaderBuilder*, const char *surfaceToLight) SK_OVERRIDE;
+    virtual void emitLightColor(GrGLShaderBuilder*, GrGLShaderBuilder::Uniform*, const char *surfaceToLight) SK_OVERRIDE;
 
 private:
     typedef GrGLLight INHERITED;
 
     SkString        fLightColorFunc;
-    UniformHandle   fLocationUni;
-    UniformHandle   fExponentUni;
-    UniformHandle   fCosOuterConeAngleUni;
-    UniformHandle   fCosInnerConeAngleUni;
-    UniformHandle   fConeScaleUni;
-    UniformHandle   fSUni;
+    GrGLUniform*        fLocationUni;
+    GrGLUniform*        fExponentUni;
+    GrGLUniform*        fCosOuterConeAngleUni;
+    GrGLUniform*        fCosInnerConeAngleUni;
+    GrGLUniform*        fConeScaleUni;
+    GrGLUniform*        fSUni;
 };
 #else
 
 class GrGLLight;
 
 #endif
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 516 matching lines @@
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
 
     /**
      * Subclasses of GrGLLightingEffect must call INHERITED::setData();
      */
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
 protected:
     virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) = 0;
 
 private:
     typedef GrGLEffect INHERITED;
 
-    UniformHandle       fImageIncrementUni;
-    UniformHandle       fSurfaceScaleUni;
+    GrGLUniform*            fImageIncrementUni;
+    GrGLUniform*            fSurfaceScaleUni;
     GrGLLight*          fLight;
     GrGLEffectMatrix    fEffectMatrix;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
                               const GrDrawEffect& drawEffect);
     virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
-    UniformHandle   fKDUni;
+    GrGLUniform*   fKDUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,
                                const GrDrawEffect& effect);
     virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
-    UniformHandle   fKSUni;
-    UniformHandle   fShininessUni;
+    GrGLUniform*   fKSUni;
+    GrGLUniform*   fShininessUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrLightingEffect::GrLightingEffect(GrTexture* texture,
                                    const SkLight* light,
                                    SkScalar surfaceScale,
                                    const SkIPoint& offset)
     : INHERITED(texture, MakeDivByTextureWHMatrix(texture))
     , fLight(light)
@@ skipping 49 matching lines @@
     return GrDiffuseLightingEffect::Create(textures[GrEffectUnitTest::kAlphaTextureIdx],
                                            light, surfaceScale, offset, kd);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLLightingEffect::GrGLLightingEffect(const GrBackendEffectFactory& factory,
                                        const GrDrawEffect& drawEffect)
     : INHERITED(factory)
-    , fImageIncrementUni(kInvalidUniformHandle)
-    , fSurfaceScaleUni(kInvalidUniformHandle)
+    , fImageIncrementUni(NULL)
+    , fSurfaceScaleUni(NULL)
     , fEffectMatrix(drawEffect.castEffect<GrLightingEffect>().coordsType()) {
     const GrLightingEffect& m = drawEffect.castEffect<GrLightingEffect>();
     fLight = m.light()->createGLLight();
 }
 
 GrGLLightingEffect::~GrGLLightingEffect() {
     delete fLight;
 }
 
 void GrGLLightingEffect::emitCode(GrGLShaderBuilder* builder,
                                   const GrDrawEffect&,
                                   EffectKey key,
                                   const char* outputColor,
                                   const char* inputColor,
                                   const TextureSamplerArray& samplers) {
     const char* coords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &coords);
 
-    fImageIncrementUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                              kVec2f_GrSLType,
-                                             "ImageIncrement");
-    fSurfaceScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                           kFloat_GrSLType,
-                                           "SurfaceScale");
-    fLight->emitLightColorUniform(builder);
+    GrGLShaderBuilder::Uniform* imageIncrementUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec2f_GrSLType,
+                            "ImageIncrement");
+    fImageIncrementUni = imageIncrementUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* surfaceScaleUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType, "SurfaceScale");
+    fSurfaceScaleUni = surfaceScaleUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* lightColorUni = fLight->emitLightColorUniform(builder);
     SkString lightFunc;
     this->emitLightFunc(builder, &lightFunc);
     static const GrGLShaderVar gSobelArgs[] =  {
         GrGLShaderVar("a", kFloat_GrSLType),
         GrGLShaderVar("b", kFloat_GrSLType),
         GrGLShaderVar("c", kFloat_GrSLType),
         GrGLShaderVar("d", kFloat_GrSLType),
         GrGLShaderVar("e", kFloat_GrSLType),
         GrGLShaderVar("f", kFloat_GrSLType),
         GrGLShaderVar("scale", kFloat_GrSLType),
@@ skipping 36 matching lines @@
                           kVec3f_GrSLType,
                           "interiorNormal",
                           SK_ARRAY_COUNT(gInteriorNormalArgs),
                           gInteriorNormalArgs,
                           interiorNormalBody.c_str(),
                           &interiorNormalName);
 
     builder->fsCodeAppendf("\t\tvec2 coord = %s;\n", coords);
     builder->fsCodeAppend("\t\tfloat m[9];\n");
 
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni);
-
     int index = 0;
     for (int dy = -1; dy <= 1; dy++) {
         for (int dx = -1; dx <= 1; dx++) {
             SkString texCoords;
-            texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc);
+            texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imageIncrementUni->c_str());
             builder->fsCodeAppendf("\t\tm[%d] = ", index++);
             builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
                                          samplers[0],
                                          texCoords.c_str());
             builder->fsCodeAppend(".a;\n");
         }
     }
     builder->fsCodeAppend("\t\tvec3 surfaceToLight = ");
     SkString arg;
-    arg.appendf("%s * m[4]", surfScale);
+    arg.appendf("%s * m[4]", surfaceScaleUni->c_str());
     fLight->emitSurfaceToLight(builder, arg.c_str());
     builder->fsCodeAppend(";\n");
     builder->fsCodeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ",
-                           outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale);
-    fLight->emitLightColor(builder, "surfaceToLight");
+                           outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfaceScaleUni->c_str());
+    fLight->emitLightColor(builder, lightColorUni, "surfaceToLight");
     builder->fsCodeAppend(");\n");
     SkString modulate;
     GrGLSLMulVarBy4f(&modulate, 2, outputColor, inputColor);
     builder->fsCodeAppend(modulate.c_str());
 }
 
 GrGLEffect::EffectKey GrGLLightingEffect::GenKey(const GrDrawEffect& drawEffect,
                                                  const GrGLCaps& caps) {
     const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>();
     EffectKey key = lighting.light()->type();
     key <<= GrGLEffectMatrix::kKeyBits;
     EffectKey matrixKey = GrGLEffectMatrix::GenKey(lighting.getMatrix(),
                                                    drawEffect,
                                                    lighting.coordsType(),
                                                    lighting.texture(0));
     return key | matrixKey;
 }
 
-void GrGLLightingEffect::setData(const GrGLUniformManager& uman,
+void GrGLLightingEffect::setData(const GrGLContext& context,
                                  const GrDrawEffect& drawEffect) {
     const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>();
     GrTexture* texture = lighting.texture(0);
     float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
-    uman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
-    uman.set1f(fSurfaceScaleUni, lighting.surfaceScale());
-    fLight->setData(uman, lighting.light(), lighting.offset());
-    fEffectMatrix.setData(uman,
+    fImageIncrementUni->set2f(context, 1.0f / texture->width(), ySign / texture->height());
+    fSurfaceScaleUni->set1f(context, lighting.surfaceScale());
+    fLight->setData(context, lighting.light(), lighting.offset());
+    fEffectMatrix.setData(context,
                           lighting.getMatrix(),
                           drawEffect,
                           lighting.texture(0));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
                                                      const GrDrawEffect& drawEffect)
     : INHERITED(factory, drawEffect)
-    , fKDUni(kInvalidUniformHandle) {
+    , fKDUni(NULL) {
 }
 
 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkString* funcName) {
     const char* kd;
     fKDUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                  kFloat_GrSLType,
                                  "KD",
-                                 &kd);
+                                 &kd)->glUniform();
 
     static const GrGLShaderVar gLightArgs[] = {
         GrGLShaderVar("normal", kVec3f_GrSLType),
         GrGLShaderVar("surfaceToLight", kVec3f_GrSLType),
         GrGLShaderVar("lightColor", kVec3f_GrSLType)
     };
     SkString lightBody;
     lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n", kd);
     lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
     builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
                           kVec4f_GrSLType,
                           "light",
                           SK_ARRAY_COUNT(gLightArgs),
                           gLightArgs,
                           lightBody.c_str(),
                           funcName);
 }
 
-void GrGLDiffuseLightingEffect::setData(const GrGLUniformManager& uman,
+void GrGLDiffuseLightingEffect::setData(const GrGLContext& context,
                                         const GrDrawEffect& drawEffect) {
-    INHERITED::setData(uman, drawEffect);
+    INHERITED::setData(context, drawEffect);
     const GrDiffuseLightingEffect& diffuse = drawEffect.castEffect<GrDiffuseLightingEffect>();
-    uman.set1f(fKDUni, diffuse.kd());
+    fKDUni->set1f(context, diffuse.kd());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture,
                                                    const SkLight* light,
                                                    SkScalar surfaceScale,
                                                    const SkIPoint& offset,
                                                    SkScalar ks,
                                                    SkScalar shininess)
@@ skipping 25 matching lines @@
     SkAutoTUnref<SkLight> light(create_random_light(random));
     SkIPoint offset = SkIPoint::Make(random->nextS(), random->nextS());
     return GrSpecularLightingEffect::Create(textures[GrEffectUnitTest::kAlphaTextureIdx],
                                             light, surfaceScale, offset, ks, shininess);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,
                                                        const GrDrawEffect& drawEffect)
-    : GrGLLightingEffect(factory, drawEffect)
-    , fKSUni(kInvalidUniformHandle)
-    , fShininessUni(kInvalidUniformHandle) {
+    : INHERITED(factory, drawEffect)
+    , fKSUni(NULL)
+    , fShininessUni(NULL) {
 }
 
 void GrGLSpecularLightingEffect::emitLightFunc(GrGLShaderBuilder* builder, SkString* funcName) {
     const char* ks;
     const char* shininess;
 
     fKSUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                 kFloat_GrSLType, "KS", &ks);
+                                 kFloat_GrSLType, "KS", &ks)->glUniform();
     fShininessUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                        kFloat_GrSLType, "Shininess", &shininess);
+                                        kFloat_GrSLType, "Shininess", &shininess)->glUniform();
 
     static const GrGLShaderVar gLightArgs[] = {
         GrGLShaderVar("normal", kVec3f_GrSLType),
         GrGLShaderVar("surfaceToLight", kVec3f_GrSLType),
         GrGLShaderVar("lightColor", kVec3f_GrSLType)
     };
     SkString lightBody;
     lightBody.appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0, 0, 1)));\n");
     lightBody.appendf("\tfloat colorScale = %s * pow(dot(normal, halfDir), %s);\n", ks, shininess);
     lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
     lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b));\n");
     builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
                           kVec4f_GrSLType,
                           "light",
                           SK_ARRAY_COUNT(gLightArgs),
                           gLightArgs,
                           lightBody.c_str(),
                           funcName);
 }
 
-void GrGLSpecularLightingEffect::setData(const GrGLUniformManager& uman,
+void GrGLSpecularLightingEffect::setData(const GrGLContext& context,
                                          const GrDrawEffect& drawEffect) {
-    INHERITED::setData(uman, drawEffect);
+    INHERITED::setData(context, drawEffect);
     const GrSpecularLightingEffect& spec = drawEffect.castEffect<GrSpecularLightingEffect>();
-    uman.set1f(fKSUni, spec.ks());
-    uman.set1f(fShininessUni, spec.shininess());
+    fKSUni->set1f(context, spec.ks());
+    fShininessUni->set1f(context, spec.shininess());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-void GrGLLight::emitLightColorUniform(GrGLShaderBuilder* builder) {
-    fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                    kVec3f_GrSLType, "LightColor");
+GrGLShaderBuilder::Uniform* GrGLLight::emitLightColorUniform(GrGLShaderBuilder* builder) {
+    GrGLShaderBuilder::Uniform* colorUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+                            kVec3f_GrSLType, "LightColor");
+    fColorUni = colorUni->glUniform();
+    return colorUni;
 }
 
 void GrGLLight::emitLightColor(GrGLShaderBuilder* builder,
+                               GrGLShaderBuilder::Uniform* colorUni,
                                const char *surfaceToLight) {
-    builder->fsCodeAppend(builder->getUniformCStr(this->lightColorUni()));
+    builder->fsCodeAppend(colorUni->c_str());
 }
 
-void GrGLLight::setData(const GrGLUniformManager& uman,
+void GrGLLight::setData(const GrGLContext& context,
                         const SkLight* light,
                         const SkIPoint&) const {
-    setUniformPoint3(uman, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255)));
+    setUniformPoint3(context, fColorUni, light->color() * SkScalarInvert(SkIntToScalar(255)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLDistantLight::setData(const GrGLUniformManager& uman,
+void GrGLDistantLight::setData(const GrGLContext& context,
                                const SkLight* light,
                                const SkIPoint& offset) const {
-    INHERITED::setData(uman, light, offset);
+    INHERITED::setData(context, light, offset);
     SkASSERT(light->type() == SkLight::kDistant_LightType);
     const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light);
-    setUniformNormal3(uman, fDirectionUni, distantLight->direction());
+    setUniformNormal3(context, fDirectionUni, distantLight->direction());
 }
 
 void GrGLDistantLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {
     const char* dir;
     fDirectionUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec3f_GrSLType,
-                                        "LightDirection", &dir);
+                                        "LightDirection", &dir)->glUniform();
     builder->fsCodeAppend(dir);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLPointLight::setData(const GrGLUniformManager& uman,
+void GrGLPointLight::setData(const GrGLContext& context,
                              const SkLight* light,
                              const SkIPoint& offset) const {
-    INHERITED::setData(uman, light, offset);
+    INHERITED::setData(context, light, offset);
     SkASSERT(light->type() == SkLight::kPoint_LightType);
     const SkPointLight* pointLight = static_cast<const SkPointLight*>(light);
     SkPoint3 location = pointLight->location();
     location.fX -= offset.fX;
     location.fY -= offset.fY;
-    setUniformPoint3(uman, fLocationUni, location);
+    setUniformPoint3(context, fLocationUni, location);
 }
 
 void GrGLPointLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {
     const char* loc;
     fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec3f_GrSLType,
-                                       "LightLocation", &loc);
+                                       "LightLocation", &loc)->glUniform();
     builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))", loc, builder->fragmentPosition(), z);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLSpotLight::setData(const GrGLUniformManager& uman,
+void GrGLSpotLight::setData(const GrGLContext& context,
                             const SkLight* light,
                             const SkIPoint& offset) const {
-    INHERITED::setData(uman, light, offset);
+    INHERITED::setData(context, light, offset);
     SkASSERT(light->type() == SkLight::kSpot_LightType);
     const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light);
     SkPoint3 location = spotLight->location();
     location.fX -= offset.fX;
     location.fY -= offset.fY;
-    setUniformPoint3(uman, fLocationUni, location);
-    uman.set1f(fExponentUni, spotLight->specularExponent());
-    uman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle());
-    uman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle());
-    uman.set1f(fConeScaleUni, spotLight->coneScale());
-    setUniformNormal3(uman, fSUni, spotLight->s());
+    setUniformPoint3(context, fLocationUni, location);
+    fExponentUni->set1f(context, spotLight->specularExponent());
+    fCosInnerConeAngleUni->set1f(context, spotLight->cosInnerConeAngle());
+    fCosOuterConeAngleUni->set1f(context, spotLight->cosOuterConeAngle());
+    fConeScaleUni->set1f(context, spotLight->coneScale());
+    setUniformNormal3(context, fSUni, spotLight->s());
 }
 
 void GrGLSpotLight::emitSurfaceToLight(GrGLShaderBuilder* builder, const char* z) {
     const char* location;
     fLocationUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                       kVec3f_GrSLType, "LightLocation", &location);
+                                       kVec3f_GrSLType, "LightLocation", &location)->glUniform();
     builder->fsCodeAppendf("normalize(%s - vec3(%s.xy, %s))",
                            location, builder->fragmentPosition(), z);
 }
 
 void GrGLSpotLight::emitLightColor(GrGLShaderBuilder* builder,
+                                   GrGLShaderBuilder::Uniform* lightUni,
                                    const char *surfaceToLight) {
 
-    const char* color = builder->getUniformCStr(this->lightColorUni()); // created by parent class.
+    const char* color = lightUni->c_str(); // created by parent class.
 
     const char* exponent;
     const char* cosInner;
     const char* cosOuter;
     const char* coneScale;
     const char* s;
     fExponentUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                       kFloat_GrSLType, "Exponent", &exponent);
+                                       kFloat_GrSLType, "Exponent", &exponent)->glUniform();
     fCosInnerConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                                kFloat_GrSLType, "CosInnerConeAngle", &cosInner);
+                                                kFloat_GrSLType, "CosInnerConeAngle", &cosInner)->glUniform();
     fCosOuterConeAngleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                                kFloat_GrSLType, "CosOuterConeAngle", &cosOuter);
+                                                kFloat_GrSLType, "CosOuterConeAngle", &cosOuter)->glUniform();
     fConeScaleUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                        kFloat_GrSLType, "ConeScale", &coneScale);
+                                        kFloat_GrSLType, "ConeScale", &coneScale)->glUniform();
     fSUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                kVec3f_GrSLType, "S", &s);
+                                kVec3f_GrSLType, "S", &s)->glUniform();
 
     static const GrGLShaderVar gLightColorArgs[] = {
         GrGLShaderVar("surfaceToLight", kVec3f_GrSLType)
     };
     SkString lightColorBody;
     lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s);
     lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter);
     lightColorBody.appendf("\t\treturn vec3(0);\n");
     lightColorBody.appendf("\t}\n");
     lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent);
@@ skipping 15 matching lines @@
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDistantLight)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkPointLight)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpotLight)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END