Make GrGLSLProgramBuilder base class for ProgramBuilder

src/gpu/GrPathProcessor.cpp

 /*
 * Copyright 2013 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrPathProcessor.h"
 
 #include "gl/GrGLGpu.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLProcessorTypes.h"
 
 class GrGLPathProcessor : public GrGLPrimitiveProcessor {
 public:
     GrGLPathProcessor() : fColor(GrColor_ILLEGAL) {}
 
     static void GenKey(const GrPathProcessor& pathProc,
                        const GrGLSLCaps&,
                        GrProcessorKeyBuilder* b) {
         b->add32(SkToInt(pathProc.opts().readsColor()) |
                  SkToInt(pathProc.opts().readsCoverage()) << 16);
     }
 
     void emitCode(EmitArgs& args) override {
-        GrGLGPBuilder* pb = args.fPB;
+        GrGLSLGPBuilder* pb = args.fPB;
         GrGLFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
         const GrPathProcessor& pathProc = args.fGP.cast<GrPathProcessor>();
 
         // emit transforms
         this->emitTransforms(args.fPB, args.fTransformsIn, args.fTransformsOut);
 
         // Setup uniform color
         if (pathProc.opts().readsColor()) {
             const char* stagedLocalVarName;
             fColorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                            kVec4f_GrSLType,
                                            kDefault_GrSLPrecision,
                                            "Color",
                                            &stagedLocalVarName);
             fs->codeAppendf("%s = %s;", args.fOutputColor, stagedLocalVarName);
         }
 
         // setup constant solid coverage
         if (pathProc.opts().readsCoverage()) {
             fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
         }
     }
 
-    void emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin, TransformsOut* tout) {
+    void emitTransforms(GrGLSLGPBuilder* pb, const TransformsIn& tin, TransformsOut* tout) {
         tout->push_back_n(tin.count());
         fInstalledTransforms.push_back_n(tin.count());
         for (int i = 0; i < tin.count(); i++) {
             const ProcCoords& coordTransforms = tin[i];
             fInstalledTransforms[i].push_back_n(coordTransforms.count());
             for (int t = 0; t < coordTransforms.count(); t++) {
                 GrSLType varyingType =
                         coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType :
                                                                            kVec2f_GrSLType;
 
                 SkString strVaryingName("MatrixCoord");
                 strVaryingName.appendf("_%i_%i", i, t);
-                GrGLVertToFrag v(varyingType);
+                GrGLSLVertToFrag v(varyingType);
                 fInstalledTransforms[i][t].fHandle =
                         pb->addSeparableVarying(strVaryingName.c_str(), &v).toIndex();
                 fInstalledTransforms[i][t].fType = varyingType;
 
                 SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLSLTransformedCoords,
                                        (SkString(v.fsIn()), varyingType));
             }
         }
     }
 
@@ skipping 52 matching lines @@
 
 void GrPathProcessor::getGLProcessorKey(const GrGLSLCaps& caps,
                                         GrProcessorKeyBuilder* b) const {
     GrGLPathProcessor::GenKey(*this, caps, b);
 }
 
 GrGLPrimitiveProcessor* GrPathProcessor::createGLInstance(const GrGLSLCaps& caps) const {
     SkASSERT(caps.pathRenderingSupport());
     return new GrGLPathProcessor();
 }