Refactor separable varying location info to be stored in GrGLProgram subclass

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 "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLPathProcessor.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLUniformHandle.h"
 #include "gl/GrGLXferProcessor.h"
 #include "GrAutoLocaleSetter.h"
 #include "GrCoordTransform.h"
+#include "GrGLPathProgramBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTraceEvent.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)
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-class GrGLNvprProgramBuilder : public GrGLProgramBuilder {
-public:
-    GrGLNvprProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
-        : INHERITED(gpu, args) {}
-
-    GrGLProgram* createProgram(GrGLuint programID) override {
-        // this is just for nvpr es, which has separable varyings that are plugged in after
-        // building
-        GrGLPathProcessor* pathProc =
-                static_cast<GrGLPathProcessor*>(fGeometryProcessor->fGLProc.get());
-        pathProc->resolveSeparableVaryings(fGpu, programID);
-        return SkNEW_ARGS(GrGLNvprProgram, (fGpu, this->desc(), fUniformHandles, programID,
-                                            fUniforms,
-                                            fGeometryProcessor,
-                                            fXferProcessor, fFragmentProcessors.get()));
-    }
-
-private:
-    typedef GrGLProgramBuilder INHERITED;
-};
-
-
-
-//////////////////////////////////////////////////////////////////////////////
-
 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(CreateProgramBuilder(args, gpu));
 
     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 NULL;
     }
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const DrawArgs& args,
                                                              GrGLGpu* gpu) {
     if (args.fPrimitiveProcessor->isPathRendering()) {
         SkASSERT(gpu->glCaps().shaderCaps()->pathRenderingSupport() &&
                  !args.fPrimitiveProcessor->willUseGeoShader() &&
                  args.fPrimitiveProcessor->numAttribs() == 0);
-        return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, args));
+        return SkNEW_ARGS(GrGLPathProgramBuilder, (gpu, args));
     } else {
         return SkNEW_ARGS(GrGLProgramBuilder, (gpu, args));
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
     , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(NULL)
     , fXferProcessor(NULL)
     , fArgs(args)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock) {
+

[joshualitt, 2015/06/23 14:07:24]

extra newline

[Kimmo Kinnunen, 2015/06/25 12:38:11]

Done.

 }
 
 void GrGLProgramBuilder::addVarying(const char* name,
                                     GrGLVarying* varying,
                                     GrSLPrecision fsPrecision) {
     SkASSERT(varying);
     if (varying->vsVarying()) {
         fVS.addVarying(name, varying);
     }
     if (this->primitiveProcessor().willUseGeoShader()) {
         fGS.addVarying(name, varying);
     }
     if (varying->fsVarying()) {
         fFS.addVarying(varying, fsPrecision);
     }
 }
 
 void GrGLProgramBuilder::addPassThroughAttribute(const GrPrimitiveProcessor::Attribute* input,
                                                  const char* output) {
     GrSLType type = GrVertexAttribTypeToSLType(input->fType);
     GrGLVertToFrag 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*,
+                                                                                   GrGLVertToFrag*,
+                                                                                   GrSLPrecision) {
+    // This call is not used for non-NVPR backends. However, the polymorphism between
+    // GrPrimitiveProcessor, GrGLPrimitiveProcessor and GrGLProgramBuilder does not allow for
+    // a system where GrGLPathProcessor would be able to refer to a primitive-specific builder
+    // that would understand separable varyings. Thus separable varyings need to be present
+    // early in the inheritance chain of builders.
+    SkASSERT(false);
+    return SeparableVaryingHandle();
+}
+
 void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
     if (!fOutOfStage) {
         if (out->endsWith('_')) {
             // Names containing "__" are reserved.
             out->append("x");
@@ skipping 276 matching lines @@
     bool useNvpr = primitiveProcessor().isPathRendering();
     if (!useNvpr) {
         fVS.bindVertexAttributes(programID);
     }
 
     if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
         this->cleanupProgram(programID, shadersToDelete);
         return NULL;
     }
 
-    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
-    if (usingBindUniform) {
-        this->bindUniformLocations(programID);
-    }
-    fFS.bindFragmentShaderLocations(programID);
+    this->bindProgramResourceLocations(programID);
+
     GL_CALL(LinkProgram(programID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = kChromium_GrGLDriver != fGpu->ctxInfo().driver();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
         checkLinkStatus(programID);
     }
-    if (!usingBindUniform) {
-        this->resolveUniformLocations(programID);
-    }
+    this->resolveProgramResourceLocations(programID);
 
     this->cleanupShaders(shadersToDelete);
 
     return this->createProgram(programID);
 }
 
-void GrGLProgramBuilder::bindUniformLocations(GrGLuint programID) {
-    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;
+void GrGLProgramBuilder::bindProgramResourceLocations(GrGLuint programID) {
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    if (usingBindUniform) {
+        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);
 }
 
 bool GrGLProgramBuilder::checkLinkStatus(GrGLuint programID) {
     GrGLint linked = GR_GL_INIT_ZERO;
     GL_CALL(GetProgramiv(programID, GR_GL_LINK_STATUS, &linked));
     if (!linked) {
         GrGLint infoLen = GR_GL_INIT_ZERO;
         GL_CALL(GetProgramiv(programID, GR_GL_INFO_LOG_LENGTH, &infoLen));
         SkAutoMalloc log(sizeof(char)*(infoLen+1));  // outside if for debugger
         if (infoLen > 0) {
             // retrieve length even though we don't need it to workaround
             // bug in chrome cmd buffer param validation.
             GrGLsizei length = GR_GL_INIT_ZERO;
             GL_CALL(GetProgramInfoLog(programID,
                                       infoLen+1,
                                       &length,
                                       (char*)log.get()));
             SkDebugf("%s", (char*)log.get());
         }
         SkDEBUGFAIL("Error linking program");
         GL_CALL(DeleteProgram(programID));
         programID = 0;
     }
     return SkToBool(linked);
 }
 
-void GrGLProgramBuilder::resolveUniformLocations(GrGLuint programID) {
-    int count = fUniforms.count();
-    for (int i = 0; i < count; ++i) {
-        GrGLint location;
-        GL_CALL_RET(location, GetUniformLocation(programID, fUniforms[i].fVariable.c_str()));
-        fUniforms[i].fLocation = location;
+void GrGLProgramBuilder::resolveProgramResourceLocations(GrGLuint programID) {
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    if (!usingBindUniform) {
+        int count = fUniforms.count();
+        for (int i = 0; i < count; ++i) {
+            GrGLint location;
+            GL_CALL_RET(location, GetUniformLocation(programID, fUniforms[i].fVariable.c_str()));
+            fUniforms[i].fLocation = location;
+        }
     }
 }
 
 void GrGLProgramBuilder::cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs) {
     GL_CALL(DeleteProgram(programID));
     cleanupShaders(shaderIDs);
 }
 void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) {
     for (int i = 0; i < shaderIDs.count(); ++i) {
       GL_CALL(DeleteShader(shaderIDs[i]));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
     return SkNEW_ARGS(GrGLProgram, (fGpu, this->desc(), fUniformHandles, programID, fUniforms,
                                     fGeometryProcessor, fXferProcessor, fFragmentProcessors.get()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }