Rename GrGLUniformManager to GrGLUniform and ref GrGLUniforms directly

src/effects/SkMatrixConvolutionImageFilter.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 "SkMatrixConvolutionImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkRect.h"
 #include "SkUnPreMultiply.h"
 
 #if SK_SUPPORT_GPU
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLEffectMatrix.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "GrTexture.h"
 #include "SkMatrix.h"
-
+#include "gl/GrGLShaderBuilder.h"
 #endif
 
 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(const SkISize& kernelSize, const SkScalar* kernel, SkScalar gain, SkScalar bias, const SkIPoint& target, TileMode tileMode, bool convolveAlpha, SkImageFilter* input)
   : INHERITED(input),
     fKernelSize(kernelSize),
     fGain(gain),
     fBias(bias),
     fTarget(target),
     fTileMode(tileMode),
     fConvolveAlpha(convolveAlpha) {
@@ skipping 288 matching lines @@
                                 const GrDrawEffect& effect);
     virtual void emitCode(GrGLShaderBuilder*,
                           const GrDrawEffect&,
                           EffectKey,
                           const char* outputColor,
                           const char* inputColor,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
 
-    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+    virtual void setData(const GrGLContext&, const GrDrawEffect&) SK_OVERRIDE;
 
 private:
-    typedef GrGLUniformManager::UniformHandle        UniformHandle;
     typedef SkMatrixConvolutionImageFilter::TileMode TileMode;
     SkISize             fKernelSize;
     TileMode            fTileMode;
     bool                fConvolveAlpha;
 
-    UniformHandle       fKernelUni;
-    UniformHandle       fImageIncrementUni;
-    UniformHandle       fTargetUni;
-    UniformHandle       fGainUni;
-    UniformHandle       fBiasUni;
+    GrGLUniform* fKernelUni;
+    GrGLUniform* fImageIncrementUni;
+    GrGLUniform* fTargetUni;
+    GrGLUniform* fGainUni;
+    GrGLUniform* fBiasUni;
 
     GrGLEffectMatrix    fEffectMatrix;
 
     typedef GrGLEffect INHERITED;
 };
 
 GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
                                                          const GrDrawEffect& drawEffect)
     : INHERITED(factory)
-    , fKernelUni(GrGLUniformManager::kInvalidUniformHandle)
-    , fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle)
-    , fTargetUni(GrGLUniformManager::kInvalidUniformHandle)
-    , fGainUni(GrGLUniformManager::kInvalidUniformHandle)
-    , fBiasUni(GrGLUniformManager::kInvalidUniformHandle)
+    , fKernelUni(NULL)
+    , fImageIncrementUni(NULL)
+    , fTargetUni(NULL)
+    , fGainUni(NULL)
+    , fBiasUni(NULL)
     , fEffectMatrix(drawEffect.castEffect<GrMatrixConvolutionEffect>().coordsType()) {
     const GrMatrixConvolutionEffect& m = drawEffect.castEffect<GrMatrixConvolutionEffect>();
     fKernelSize = m.kernelSize();
     fTileMode = m.tileMode();
     fConvolveAlpha = m.convolveAlpha();
 }
 
 static void appendTextureLookup(GrGLShaderBuilder* builder,
                                 const GrGLShaderBuilder::TextureSampler& sampler,
                                 const char* coord,
@@ skipping 16 matching lines @@
 }
 
 void GrGLMatrixConvolutionEffect::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");
-    fKernelUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_ShaderType,
-                                             kFloat_GrSLType, "Kernel", fKernelSize.width() * fKernelSize.height());
-    fTargetUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                             kVec2f_GrSLType, "Target");
-    fGainUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                   kFloat_GrSLType, "Gain");
-    fBiasUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
-                                   kFloat_GrSLType, "Bias");
 
-    const char* target = builder->getUniformCStr(fTargetUni);
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
-    const char* kernel = builder->getUniformCStr(fKernelUni);
-    const char* gain = builder->getUniformCStr(fGainUni);
-    const char* bias = builder->getUniformCStr(fBiasUni);
+    GrGLShaderBuilder::Uniform* imageIncrementUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec2f_GrSLType, "ImageIncrement");
+    fImageIncrementUni = imageIncrementUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* kernelUni =
+        builder->addUniformArray(GrGLShaderBuilder::kFragment_ShaderType,
+                                 kFloat_GrSLType, "Kernel", fKernelSize.width() * fKernelSize.height());
+    fKernelUni = kernelUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* targetUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kVec2f_GrSLType, "Target");
+    fTargetUni = targetUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* gainUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType, "Gain");
+    fGainUni = gainUni->glUniform();
+
+    GrGLShaderBuilder::Uniform* biasUni =
+        builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType, "Bias");
+    fBiasUni = biasUni->glUniform();
+
+    const char* target = targetUni->c_str();
+    const char* imgInc = imageIncrementUni->c_str();
+    const char* kernel = kernelUni->c_str();
+    const char* gain = gainUni->c_str();
+    const char* bias = biasUni->c_str();
     int kWidth = fKernelSize.width();
     int kHeight = fKernelSize.height();
 
     builder->fsCodeAppend("\t\tvec4 sum = vec4(0, 0, 0, 0);\n");
     builder->fsCodeAppendf("\t\tvec2 coord = %s - %s * %s;\n", coords, target, imgInc);
     builder->fsCodeAppendf("\t\tfor (int y = 0; y < %d; y++) {\n", kHeight);
     builder->fsCodeAppendf("\t\t\tfor (int x = 0; x < %d; x++) {\n", kWidth);
     builder->fsCodeAppendf("\t\t\t\tfloat k = %s[y * %d + x];\n", kernel, kWidth);
     builder->fsCodeAppendf("\t\t\t\tvec2 coord2 = coord + vec2(x, y) * %s;\n", imgInc);
     builder->fsCodeAppend("\t\t\t\tvec4 c = ");
@@ skipping 37 matching lines @@
     key |= m.tileMode() << 7;
     key |= m.convolveAlpha() ? 1 << 9 : 0;
     key <<= GrGLEffectMatrix::kKeyBits;
     EffectKey matrixKey = GrGLEffectMatrix::GenKey(m.getMatrix(),
                                                    drawEffect,
                                                    m.coordsType(),
                                                    m.texture(0));
     return key | matrixKey;
 }
 
-void GrGLMatrixConvolutionEffect::setData(const GrGLUniformManager& uman,
+void GrGLMatrixConvolutionEffect::setData(const GrGLContext& context,
                                           const GrDrawEffect& drawEffect) {
     const GrMatrixConvolutionEffect& conv = drawEffect.castEffect<GrMatrixConvolutionEffect>();
     GrTexture& texture = *conv.texture(0);
     // the code we generated was for a specific kernel size
     GrAssert(conv.kernelSize() == fKernelSize);
     GrAssert(conv.tileMode() == fTileMode);
     float imageIncrement[2];
     float ySign = texture.origin() == kTopLeft_GrSurfaceOrigin ? 1.0f : -1.0f;
     imageIncrement[0] = 1.0f / texture.width();
     imageIncrement[1] = ySign / texture.height();
-    uman.set2fv(fImageIncrementUni, 0, 1, imageIncrement);
-    uman.set2fv(fTargetUni, 0, 1, conv.target());
-    uman.set1fv(fKernelUni, 0, fKernelSize.width() * fKernelSize.height(), conv.kernel());
-    uman.set1f(fGainUni, conv.gain());
-    uman.set1f(fBiasUni, conv.bias());
-    fEffectMatrix.setData(uman,
+    fImageIncrementUni->set2fv(context, 0, 1, imageIncrement);
+    fTargetUni->set2fv(context, 0, 1, conv.target());
+    fKernelUni->set1fv(context, 0, fKernelSize.width() * fKernelSize.height(), conv.kernel());
+    fGainUni->set1f(context, conv.gain());
+    fBiasUni->set1f(context, conv.bias());
+    fEffectMatrix.setData(context,
                           conv.getMatrix(),
                           drawEffect,
                           conv.texture(0));
 }
 
 GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
                                                      const SkISize& kernelSize,
                                                      const SkScalar* kernel,
                                                      SkScalar gain,
                                                      SkScalar bias,
@@ skipping 83 matching lines @@
                                                 fBias,
                                                 fTarget,
                                                 fTileMode,
                                                 fConvolveAlpha);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #endif