Make GrGLSLProgramBuilder base class for ProgramBuilder

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 
 #include "GrAutoLocaleSetter.h"
 #include "GrCoordTransform.h"
 #include "GrGLProgramBuilder.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTraceEvent.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLXferProcessor.h"
 #include "gl/builders/GrGLShaderStringBuilder.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X)
 
-const int GrGLProgramBuilder::kVarsPerBlock = 8;
-
 GrGLProgram* GrGLProgramBuilder::CreateProgram(const DrawArgs& args, GrGLGpu* gpu) {
     GrAutoLocaleSetter als("C");
 
     // create a builder.  This will be handed off to effects so they can use it to add
     // uniforms, varyings, textures, etc
     SkAutoTDelete<GrGLProgramBuilder> builder(new GrGLProgramBuilder(gpu, args));
 
     GrGLProgramBuilder* pb = builder.get();
 
     // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
     // seed correctly here
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
     if (!pb->emitAndInstallProcs(&inputColor, &inputCoverage)) {
         return nullptr;
     }
 
     return pb->finalize();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
-    : fVS(this)
-    , fGS(this)
-    , fFS(this, args.fDesc->header().fFragPosKey)
-    , fStageIndex(-1)
+    : INHERITED(args)
     , fGeometryProcessor(nullptr)
     , fXferProcessor(nullptr)
-    , fArgs(args)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock)
     , fSamplerUniforms(4)
     , fSeparableVaryingInfos(kVarsPerBlock) {
 }
 
 void GrGLProgramBuilder::addVarying(const char* name,
-                                    GrGLVarying* varying,
+                                    GrGLSLVarying* varying,
                                     GrSLPrecision precision) {
     SkASSERT(varying);
     if (varying->vsVarying()) {
         fVS.addVarying(name, precision, varying);
     }
     if (this->primitiveProcessor().willUseGeoShader()) {
         fGS.addVarying(name, precision, varying);
     }
     if (varying->fsVarying()) {
         fFS.addVarying(varying, precision);
     }
 }
 
 void GrGLProgramBuilder::addPassThroughAttribute(const GrPrimitiveProcessor::Attribute* input,
                                                  const char* output) {
     GrSLType type = GrVertexAttribTypeToSLType(input->fType);
-    GrGLVertToFrag v(type);
+    GrGLSLVertToFrag v(type);
     this->addVarying(input->fName, &v);
     fVS.codeAppendf("%s = %s;", v.vsOut(), input->fName);
     fFS.codeAppendf("%s = %s;", output, v.fsIn());
 }
 
 GrGLProgramBuilder::SeparableVaryingHandle GrGLProgramBuilder::addSeparableVarying(
                                                                         const char* name,
-                                                                        GrGLVertToFrag* v,
+                                                                        GrGLSLVertToFrag* v,
                                                                         GrSLPrecision fsPrecision) {
     // This call is not used for non-NVPR backends.
     SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport() &&
              fArgs.fPrimitiveProcessor->isPathRendering() &&
              !fArgs.fPrimitiveProcessor->willUseGeoShader() &&
              fArgs.fPrimitiveProcessor->numAttribs() == 0);
     this->addVarying(name, v, fsPrecision);
     SeparableVaryingInfo& varyingInfo = fSeparableVaryingInfos.push_back();
     varyingInfo.fVariable = this->getFragmentShaderBuilder()->fInputs.back();
     varyingInfo.fLocation = fSeparableVaryingInfos.count() - 1;
     return SeparableVaryingHandle(varyingInfo.fLocation);
 }
 
-void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
-    if ('\0' == prefix) {
-        *out = name;
-    } else {
-        out->printf("%c%s", prefix, name);
-    }
-    if (mangle) {
-        if (out->endsWith('_')) {
-            // Names containing "__" are reserved.
-            out->append("x");
-        }
-        out->appendf("_Stage%d%s", fStageIndex, fFS.getMangleString().c_str());
-    }
-}
-
 GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::internalAddUniformArray(
                                                                 uint32_t visibility,
                                                                 GrSLType type,
                                                                 GrSLPrecision precision,
                                                                 const char* name,
                                                                 bool mangleName,
                                                                 int count,
                                                                 const char** outName) {
     SkASSERT(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
@@ skipping 18 matching lines @@
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
     uni.fVariable.setPrecision(precision);
 
     if (outName) {
         *outName = uni.fVariable.c_str();
     }
     return GrGLSLProgramDataManager::UniformHandle(fUniforms.count() - 1);
 }
 
-void GrGLProgramBuilder::appendUniformDecls(ShaderVisibility visibility,
-                                            SkString* out) const {
+void GrGLProgramBuilder::onAppendUniformDecls(ShaderVisibility visibility,
+                                              SkString* out) const {
     for (int i = 0; i < fUniforms.count(); ++i) {
         if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(this->glslCaps(), out);
             out->append(";\n");
         }
     }
 }
 
-const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
-    return fGpu->ctxInfo();
-}
-
 const GrGLSLCaps* GrGLProgramBuilder::glslCaps() const {
-    return this->ctxInfo().caps()->glslCaps();
+    return this->fGpu->ctxInfo().caps()->glslCaps();
 }
 
 bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage) {
     // First we loop over all of the installed processors and collect coord transforms.  These will
     // be sent to the GrGLPrimitiveProcessor in its emitCode function
     const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
     int totalTextures = primProc.numTextures();
     const int maxTextureUnits = fGpu->glCaps().maxFragmentTextureUnits();
 
     for (int i = 0; i < this->pipeline().numFragmentProcessors(); i++) {
@@ skipping 135 matching lines @@
     SkASSERT(!fXferProcessor);
     fXferProcessor = new GrGLInstalledXferProc;
 
     fXferProcessor->fGLProc.reset(xp.createGLInstance());
 
     // Enable dual source secondary output if we have one
     if (xp.hasSecondaryOutput()) {
         fFS.enableSecondaryOutput();
     }
 
-    if (this->ctxInfo().caps()->glslCaps()->mustDeclareFragmentShaderOutput()) {
+    if (this->glslCaps()->mustDeclareFragmentShaderOutput()) {
         fFS.enableCustomOutput();
     }
 
     SkString openBrace;
     openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
     fFS.codeAppend(openBrace.c_str());
 
     SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
     this->emitSamplers(xp, &samplers, fXferProcessor);
 
@@ skipping 72 matching lines @@
     SkTDArray<GrGLuint> shadersToDelete;
     fVS.finalize(kVertex_Visibility);
     if (!this->compileAndAttachShaders(fVS, programID, GR_GL_VERTEX_SHADER, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
         return nullptr;
     }
 
     // NVPR actually requires a vertex shader to compile
     bool useNvpr = primitiveProcessor().isPathRendering();
     if (!useNvpr) {
-        fVS.bindVertexAttributes(programID);
+        const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
+
+        int vaCount = primProc.numAttribs();
+        for (int i = 0; i < vaCount; i++) {
+            GL_CALL(BindAttribLocation(programID, i, primProc.getAttrib(i).fName));
+        }
     }
 
     fFS.finalize(kFragment_Visibility);
     if (!this->compileAndAttachShaders(fFS, programID, GR_GL_FRAGMENT_SHADER, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
         return nullptr;
     }
 
     this->bindProgramResourceLocations(programID);
 
@@ skipping 16 matching lines @@
 
 void GrGLProgramBuilder::bindProgramResourceLocations(GrGLuint programID) {
     if (fGpu->glCaps().bindUniformLocationSupport()) {
         int count = fUniforms.count();
         for (int i = 0; i < count; ++i) {
             GL_CALL(BindUniformLocation(programID, i, fUniforms[i].fVariable.c_str()));
             fUniforms[i].fLocation = i;
         }
     }
 
-    fFS.bindFragmentShaderLocations(programID);
+    const GrGLCaps& caps = this->gpu()->glCaps();
+    if (fFS.hasCustomColorOutput() && caps.bindFragDataLocationSupport()) {
+        GL_CALL(BindFragDataLocation(programID, 0,
+                                     GrGLFragmentShaderBuilder::DeclaredColorOutputName()));
+    }
+    if (fFS.hasSecondaryOutput() && caps.glslCaps()->mustDeclareFragmentShaderOutput()) {
+        GL_CALL(BindFragDataLocationIndexed(programID, 0, 1,
+                                    GrGLFragmentShaderBuilder::DeclaredSecondaryColorOutputName()));
+    }
 
     // handle NVPR separable varyings
     if (!fGpu->glCaps().shaderCaps()->pathRenderingSupport() ||
         !fGpu->glPathRendering()->shouldBindFragmentInputs()) {
         return;
     }
     int count = fSeparableVaryingInfos.count();
     for (int i = 0; i < count; ++i) {
         GL_CALL(BindFragmentInputLocation(programID,
                                           i,
@@ skipping 70 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }