remove path specific program building classes

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 "GrGLPathProgramBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "GrTexture.h"
 #include "SkRTConf.h"
 #include "SkTraceEvent.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLPathProcessor.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLXferProcessor.h"
 #include "glsl/GrGLSLCaps.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(CreateProgramBuilder(args, gpu));
+    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::CreateProgramBuilder(const DrawArgs& args,
-                                                             GrGLGpu* gpu) {
-    if (args.fPrimitiveProcessor->isPathRendering()) {
-        SkASSERT(gpu->glCaps().shaderCaps()->pathRenderingSupport() &&
-                 !args.fPrimitiveProcessor->willUseGeoShader() &&
-                 args.fPrimitiveProcessor->numAttribs() == 0);
-        return new GrGLPathProgramBuilder(gpu, args);
-    } else {
-        return new 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(nullptr)
     , fXferProcessor(nullptr)
     , fArgs(args)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock)
-    , fSamplerUniforms(4) {
+    , fSamplerUniforms(4)
+    , fSeparableVaryingInfos(kVarsPerBlock) {
 }
 
 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();
+GrGLProgramBuilder::SeparableVaryingHandle GrGLProgramBuilder::addSeparableVarying(
+                                                                        const char* name,
+                                                                        GrGLVertToFrag* 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) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
     if (!fOutOfStage) {
         if (out->endsWith('_')) {
@@ skipping 310 matching lines @@
     bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != nullptr;
     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);
+
+    // 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,
+                                          fSeparableVaryingInfos[i].fVariable.c_str()));
+        fSeparableVaryingInfos[i].fLocation = i;
+    }
 }
 
 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) {
@@ skipping 16 matching lines @@
 void GrGLProgramBuilder::resolveProgramResourceLocations(GrGLuint programID) {
     bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != nullptr;
     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;
         }
     }
+
+    // handle NVPR separable varyings
+    if (!fGpu->glCaps().shaderCaps()->pathRenderingSupport() ||
+        !fGpu->glPathRendering()->shouldBindFragmentInputs()) {
+        return;
+    }
+    int count = fSeparableVaryingInfos.count();
+    for (int i = 0; i < count; ++i) {
+        GrGLint location;
+        GL_CALL_RET(location,
+                    GetProgramResourceLocation(programID,
+                                               GR_GL_FRAGMENT_INPUT,
+                                               fSeparableVaryingInfos[i].fVariable.c_str()));
+        fSeparableVaryingInfos[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 new GrGLProgram(fGpu, this->desc(), fUniformHandles, programID, fUniforms,
+                           fSeparableVaryingInfos,
                            fGeometryProcessor, fXferProcessor, fFragmentProcessors.get(),
                            &fSamplerUniforms);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }