Initial refactor of shaderbuilder

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 365 matching lines @@
 
     fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
     fPtsToUnit.postScale(inv, inv);
 }
 
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTBackendEffectFactory.h"
-#include "gl/GrGLShaderBuilder.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 #include "SkGr.h"
 
 // For brevity
 typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
 class GrGLRadial2Gradient : public GrGLGradientEffect {
 
 public:
 
     GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&);
     virtual ~GrGLRadial2Gradient() { }
 
-    virtual void emitCode(GrGLShaderBuilder*,
+    virtual void emitCode(GrGLProgramBuilder*,
                           const GrDrawEffect&,
                           const GrEffectKey&,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
     virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
 
     static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
 
@@ skipping 135 matching lines @@
     , 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,
+void GrGLRadial2Gradient::emitCode(GrGLProgramBuilder* builder,
                                    const GrDrawEffect& drawEffect,
                                    const GrEffectKey& key,
                                    const char* outputColor,
                                    const char* inputColor,
                                    const TransformedCoordsArray& coords,
                                    const TextureSamplerArray& samplers) {
     uint32_t baseKey = key.get32(0);
     this->emitUniforms(builder, baseKey);
-    fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility,
+    fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType, "Radial2FSParams", 6);
 
     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(fParamUni).appendArrayAccess(0, &p0);
     builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
     builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
     builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3);
     builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4);
     builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5);
 
+    GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     // We interpolate the linear component in coords[1].
     SkASSERT(coords[0].type() == coords[1].type());
     const char* coords2D;
     SkString bVar;
     if (kVec3f_GrSLType == coords[0].type()) {
-        builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n",
+        fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n",
                                coords[0].c_str(), coords[1].c_str(), coords[0].c_str());
         coords2D = "interpolants.xy";
         bVar = "interpolants.z";
     } else {
         coords2D = coords[0].c_str();
         bVar.printf("%s.x", coords[1].c_str());
     }
 
     // c = (x^2)+(y^2) - params[4]
-    builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
+    fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
                            cName.c_str(), coords2D, coords2D, p4.c_str());
 
     // If we aren't degenerate, emit some extra code, and accept a slightly
     // more complex coord.
     if (!fIsDegenerate) {
 
         // ac4 = 4.0 * params[0] * c
-        builder->fsCodeAppendf("\tfloat %s = %s * 4.0 * %s;\n",
+        fsBuilder->codeAppendf("\tfloat %s = %s * 4.0 * %s;\n",
                                ac4Name.c_str(), p0.c_str(),
                                cName.c_str());
 
         // root = sqrt(b^2-4ac)
         // (abs to avoid exception due to fp precision)
-        builder->fsCodeAppendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n",
+        fsBuilder->codeAppendf("\tfloat %s = sqrt(abs(%s*%s - %s));\n",
                                rootName.c_str(), bVar.c_str(), bVar.c_str(),
                                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());
     }
@@ skipping 81 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