Added GrGLFragmentProcessor::EmitArgs struct for use with emitCode()

src/gpu/effects/GrConvolutionEffect.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 "GrConvolutionEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLTexture.h"
@@ skipping 63 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * Applies a convolution effect which restricts samples to the provided bounds
  * using shader logic.
  */
 class GrGLBoundedConvolutionEffect : public GrGLConvolutionEffect {
 public:
     GrGLBoundedConvolutionEffect(const GrProcessor& processor) : INHERITED(processor) {}
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
 
     void setData(const GrGLProgramDataManager& pdman, const GrProcessor&) override;
 
 private:
     UniformHandle       fKernelUni;
     UniformHandle       fImageIncrementUni;
     UniformHandle       fBoundsUni;
 
     typedef GrGLConvolutionEffect INHERITED;
 };
 
-void GrGLBoundedConvolutionEffect::emitCode(GrGLFPBuilder* builder,
-                                            const GrFragmentProcessor& processor,
-                                            const char* outputColor,
-                                            const char* inputColor,
-                                            const TransformedCoordsArray& coords,
-                                            const TextureSamplerArray& samplers) {
+void GrGLBoundedConvolutionEffect::emitCode(EmitArgs& args) {
     fImageIncrementUni =
-        builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,
+            args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,
                             kDefault_GrSLPrecision, "ImageIncrement");
 
-    fBoundsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,
+    fBoundsUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,

[joshualitt, 2015/07/22 19:34:05]

line wrap @100

                                      kDefault_GrSLPrecision, "Bounds");
 
-    fKernelUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType,
+    fKernelUni = args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType,

[joshualitt, 2015/07/22 19:34:05]

line wrap @100

                                           kDefault_GrSLPrecision, "Kernel", this->width());
 
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2D = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
 
-    fsBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);\n", outputColor);
+    fsBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);\n", args.fOutputColor);
 
     int width = this->width();
-    const GrGLShaderVar& kernel = builder->getUniformVariable(fKernelUni);
-    const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
+    const GrGLShaderVar& kernel = args.fBuilder->getUniformVariable(fKernelUni);
+    const char* imgInc = args.fBuilder->getUniformCStr(fImageIncrementUni);
 
     fsBuilder->codeAppendf("vec2 coord = %s - %d.0 * %s;\n", coords2D.c_str(), this->radius(),
                            imgInc);
 
     // Manually unroll loop because some drivers don't; yields 20-30% speedup.
     for (int i = 0; i < width; i++) {
         SkString index;
         SkString kernelIndex;
         index.appendS32(i);
         kernel.appendArrayAccess(index.c_str(), &kernelIndex);
         // We used to compute a bool indicating whether we're in bounds or not, cast it to a
         // float, and then mul weight*texture_sample by the float. However, the Adreno 430 seems
         // to have a bug that caused corruption.
-        const char* bounds = builder->getUniformCStr(fBoundsUni);
+        const char* bounds = args.fBuilder->getUniformCStr(fBoundsUni);
         const char* component = this->direction() == Gr1DKernelEffect::kY_Direction ? "y" : "x";
         fsBuilder->codeAppendf("if (coord.%s >= %s.x && coord.%s <= %s.y) {",
             component, bounds, component, bounds);
-        fsBuilder->codeAppendf("%s += ", outputColor);
-        fsBuilder->appendTextureLookup(samplers[0], "coord");
+        fsBuilder->codeAppendf("%s += ", args.fOutputColor);
+        fsBuilder->appendTextureLookup(args.fSamplers[0], "coord");
         fsBuilder->codeAppendf(" * %s;\n", kernelIndex.c_str());
         fsBuilder->codeAppend("}");
         fsBuilder->codeAppendf("coord += %s;\n", imgInc);
     }
 
     SkString modulate;
-    GrGLSLMulVarBy4f(&modulate, outputColor, inputColor);
+    GrGLSLMulVarBy4f(&modulate, args.fOutputColor, args.fInputColor);
     fsBuilder->codeAppend(modulate.c_str());
 }
 
 void GrGLBoundedConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
                                            const GrProcessor& processor) {
     const GrConvolutionEffect& conv = processor.cast<GrConvolutionEffect>();
 
     // the code we generated was for a specific kernel radius
     SkASSERT(conv.radius() == this->radius());
 
@@ skipping 17 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * Applies a convolution effect which applies the convolution using a linear
  * interpolation optimization to use half as many samples.
  */
 class GrGLLerpConvolutionEffect : public GrGLConvolutionEffect {
 public:
     GrGLLerpConvolutionEffect(const GrProcessor& processor) : INHERITED(processor) {}
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    virtual void emitCode(EmitArgs&) override;
 
     void setData(const GrGLProgramDataManager& pdman, const GrProcessor&) override;
 
 private:
     int bilerpSampleCount() const;
 
     // Bounded uniforms
     UniformHandle fSampleWeightUni;
     UniformHandle fSampleOffsetUni;
 
     typedef GrGLConvolutionEffect INHERITED;
 };
 
-void GrGLLerpConvolutionEffect::emitCode(GrGLFPBuilder* builder,
-                                         const GrFragmentProcessor& processor,
-                                         const char* outputColor,
-                                         const char* inputColor,
-                                         const TransformedCoordsArray& coords,
-                                         const TextureSamplerArray& samplers) {
+void GrGLLerpConvolutionEffect::emitCode(EmitArgs& args) {
     int sampleCount = bilerpSampleCount();
 
     // We use 2 * sampleCount uniforms. The maximum allowed by PS2.0 is 32, so
     // ensure we don't exceed this. Note that it is currently impossible to
     // exceed this as bilerpSampleCount = (kernelWidth + 1) / 2, and kernelWidth
     // maxes out at 25, resulting in a max sampleCount of 26.
     SkASSERT(sampleCount < 16);
 
     fSampleOffsetUni =
-        builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,
+        args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kVec2f_GrSLType,
                                  kDefault_GrSLPrecision, "SampleOffset", sampleCount);
     fSampleWeightUni =
-        builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType,
+        args.fBuilder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility, kFloat_GrSLType,
                                  kDefault_GrSLPrecision, "SampleWeight", sampleCount);
 
-    GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
-    SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);
+    GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+    SkString coords2D = fsBuilder->ensureFSCoords2D(args.fCoords, 0);
 
-    fsBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);\n", outputColor);
+    fsBuilder->codeAppendf("%s = vec4(0, 0, 0, 0);\n", args.fOutputColor);
 
-    const GrGLShaderVar& kernel = builder->getUniformVariable(fSampleWeightUni);
-    const GrGLShaderVar& imgInc = builder->getUniformVariable(fSampleOffsetUni);
+    const GrGLShaderVar& kernel = args.fBuilder->getUniformVariable(fSampleWeightUni);
+    const GrGLShaderVar& imgInc = args.fBuilder->getUniformVariable(fSampleOffsetUni);
 
     fsBuilder->codeAppendf("vec2 coord; \n");
 
     // Manually unroll loop because some drivers don't; yields 20-30% speedup.
     for (int i = 0; i < sampleCount; i++) {
         SkString index;
         SkString weightIndex;
         SkString offsetIndex;
         index.appendS32(i);
         kernel.appendArrayAccess(index.c_str(), &weightIndex);
         imgInc.appendArrayAccess(index.c_str(), &offsetIndex);
         fsBuilder->codeAppendf("coord = %s + %s;\n", coords2D.c_str(), offsetIndex.c_str());
-        fsBuilder->codeAppendf("%s += ", outputColor);
-        fsBuilder->appendTextureLookup(samplers[0], "coord");
+        fsBuilder->codeAppendf("%s += ", args.fOutputColor);
+        fsBuilder->appendTextureLookup(args.fSamplers[0], "coord");
         fsBuilder->codeAppendf(" * %s;\n", weightIndex.c_str());
     }
 
     SkString modulate;
-    GrGLSLMulVarBy4f(&modulate, outputColor, inputColor);
+    GrGLSLMulVarBy4f(&modulate, args.fOutputColor, args.fInputColor);
     fsBuilder->codeAppend(modulate.c_str());
 }
 
 void GrGLLerpConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
                                         const GrProcessor& processor) {
     const GrConvolutionEffect& conv = processor.cast<GrConvolutionEffect>();
 
     // the code we generated was for a specific kernel radius
     SkASSERT(conv.radius() == this->radius());
 
@@ skipping 155 matching lines @@
 
     bool useBounds = d->fRandom->nextBool();
     return GrConvolutionEffect::Create(d->fProcDataManager,
                                        d->fTextures[texIdx],
                                        dir,
                                        radius,
                                        kernel,
                                        useBounds,
                                        bounds);
 }