Opt state takes a GP instead of a GeometryStage

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/GrGLProgram.h"
@@ skipping 11 matching lines @@
 #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)
 
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 
 //////////////////////////////////////////////////////////////////////////////
 
 const int GrGLProgramBuilder::kVarsPerBlock = 8;
 
+// Below are some helper classes which help keep the create and emit pipeline general
+template <class Derived>
+struct FragmentStageClassMap {
+    static const GrFragmentProcessor* GetProcessor(const GrOptDrawState& opt, int index) {
+        SkASSERT(Derived::GetStage(opt, index)->getProcessor());
+        return Derived::GetStage(opt, index)->getProcessor();
+    }
+    typedef GrFragmentProcessor Processor;
+    typedef GrFragmentStage ProcessorStaged;
+    typedef GrGLFragmentProcessor GLProcessor;
+};
+
+struct ColorStageClassMap : public FragmentStageClassMap<ColorStageClassMap> {
+    static int GetCount(const GrOptDrawState& opt) { return opt.numColorStages(); }
+    static const GrFragmentStage* GetStage(const GrOptDrawState& opt, int index) {
+        return &opt.getColorStage(index);
+    }
+};
+
+struct CoverageStageClassMap : public FragmentStageClassMap<CoverageStageClassMap> {
+    static int GetCount(const GrOptDrawState& opt) { return opt.numCoverageStages(); }
+    static const GrFragmentStage* GetStage(const GrOptDrawState& opt, int index) {
+        return &opt.getCoverageStage(index);
+    }
+};
+
+struct GeometryProcessorClassMap {
+    static int GetCount(const GrOptDrawState& opt) { return 1; }
+    static const GrGeometryProcessor* GetStage(const GrOptDrawState& opt, int index) {
+        SkASSERT(0 == index && opt.hasGeometryProcessor());
+        return opt.getGeometryProcessor();
+    }
+    static const GrGeometryProcessor* GetProcessor(const GrOptDrawState& opt, int index) {
+        return GetStage(opt, index);
+    }
+    typedef GrGeometryProcessor Processor;
+    typedef GrGeometryProcessor ProcessorStaged;
+    typedef GrGLGeometryProcessor GLProcessor;
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
 GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState,
                                                const GrGLProgramDesc& desc,
                                                GrGpu::DrawType drawType,
-                                               const GrGeometryStage* geometryProcessor,
-                                               const GrFragmentStage* colorStages[],
-                                               const GrFragmentStage* coverageStages[],
                                                GrGpuGL* gpu) {
     // 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(desc,
                                                                    optState,
                                                                    drawType,
-                                                                   SkToBool(geometryProcessor),
+                                                                   optState.hasGeometryProcessor(),
                                                                    gpu));
 
     GrGLProgramBuilder* pb = builder.get();
     const GrGLProgramDesc::KeyHeader& header = pb->header();
 
     // emit code to read the dst copy texture, if necessary
     if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey
             && !gpu->glCaps().fbFetchSupport()) {
         pb->fFS.emitCodeToReadDstTexture();
     }
@@ skipping 12 matching lines @@
             pb->fVS.codeAppend("gl_PointSize = 1.0;");
         }
         if (GrGLProgramDesc::kAttribute_ColorInput == header.fColorInput) {
             pb->fVS.setupBuiltinVertexAttribute("Color", &inputColor);
         }
         if (GrGLProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
             pb->fVS.setupBuiltinVertexAttribute("Coverage", &inputCoverage);
         }
     }
 
-    pb->createAndEmitProcessors(geometryProcessor, colorStages, coverageStages, &inputColor,
-                                &inputCoverage);
+    bool useLocalCoords = pb->fVS.hasExplicitLocalCoords();
+    pb->createAndEmitProcessors<ColorStageClassMap>(EffectKeyProvider::kColor_EffectType,
+                                                    useLocalCoords,
+                                                    &pb->fColorEffects,
+                                                    &inputColor);
+    if (optState.hasGeometryProcessor()) {
+        pb->fVS.emitAttributes(*optState.getGeometryProcessor());
+        pb->createAndEmitProcessors<GeometryProcessorClassMap>(
+                EffectKeyProvider::kGeometryProcessor_EffectType,
+                false,
+                &pb->fGeometryProcessor,
+                &inputCoverage);
+    }
+    pb->createAndEmitProcessors<CoverageStageClassMap>(EffectKeyProvider::kCoverage_EffectType,
+                                                       useLocalCoords,
+                                                       &pb->fCoverageEffects,
+                                                       &inputCoverage);
 
     if (hasVertexShader) {
         pb->fVS.transformSkiaToGLCoords();
     }
 
     // write the secondary color output if necessary
     if (GrOptDrawState::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
         pb->fFS.enableSecondaryOutput(inputColor, inputCoverage);
     }
 
@@ skipping 129 matching lines @@
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                              kVec4f_GrSLType,
                              "Coverage",
                              &name);
         *inputCoverage = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
         *inputCoverage = GrGLSLExpr4(1);
     }
 }
 
-void GrGLProgramBuilder::createAndEmitProcessors(const GrGeometryStage* geometryProcessor,
-                                                 const GrFragmentStage* colorStages[],
-                                                 const GrFragmentStage* coverageStages[],
-                                                 GrGLSLExpr4* inputColor,
-                                                 GrGLSLExpr4* inputCoverage) {
-    bool useLocalCoords = fVS.hasExplicitLocalCoords();
+template <class ClassMap>
+void GrGLProgramBuilder::createAndEmitProcessors(const EffectKeyProvider::EffectType type,
+                                                 bool useLocalCoords,
+                                                 SkAutoTUnref<GrGLInstalledProcessors>* installProc,
+                                                 GrGLSLExpr4* fsInOutColor) {
+    // setup key provider and install point
+    EffectKeyProvider keyProvider(&fDesc, type);
+    int numProcs = ClassMap::GetCount(fOptState);
+    GrGLInstalledProcessors* ip = SkNEW_ARGS(GrGLInstalledProcessors, (numProcs, useLocalCoords));
 
-    EffectKeyProvider colorKeyProvider(&fDesc, EffectKeyProvider::kColor_EffectType);
-    int numColorEffects = fDesc.numColorEffects();
-    GrGLInstalledProcessors* ip = SkNEW_ARGS(GrGLInstalledProcessors, (numColorEffects,
-                                                                       useLocalCoords));
-    this->createAndEmitProcessors<GrFragmentStage>(colorStages, numColorEffects, colorKeyProvider,
-                                                   inputColor, ip);
-    fColorEffects.reset(ip);
-
-    if (geometryProcessor) {
-        fVS.emitAttributes(*geometryProcessor->getProcessor());
-        EffectKeyProvider gpKeyProvider(&fDesc, EffectKeyProvider::kGeometryProcessor_EffectType);
-        ip = SkNEW_ARGS(GrGLInstalledProcessors, (1, useLocalCoords));
-        this->createAndEmitProcessors<GrGeometryStage>(&geometryProcessor, 1, gpKeyProvider,
-                                                       inputCoverage, ip);
-        fGeometryProcessor.reset(ip);
-    }
-
-    EffectKeyProvider coverageKeyProvider(&fDesc, EffectKeyProvider::kCoverage_EffectType);
-    int numCoverageEffects = fDesc.numCoverageEffects();
-    ip = SkNEW_ARGS(GrGLInstalledProcessors, (numCoverageEffects, useLocalCoords));
-    this->createAndEmitProcessors<GrFragmentStage>(coverageStages, numCoverageEffects,
-                                                   coverageKeyProvider, inputCoverage, ip);
-    fCoverageEffects.reset(ip);
-}
-
-template <class ProcessorStage>
-void GrGLProgramBuilder::createAndEmitProcessors(const ProcessorStage* processStages[],
-                                                 int effectCnt,
-                                                 const EffectKeyProvider& keyProvider,
-                                                 GrGLSLExpr4* fsInOutColor,
-                                                 GrGLInstalledProcessors* installedProcessors) {
     bool effectEmitted = false;
 
     GrGLSLExpr4 inColor = *fsInOutColor;
     GrGLSLExpr4 outColor;
 
-    for (int e = 0; e < effectCnt; ++e) {
+    for (int e = 0; e < numProcs; ++e) {
         // Program builders have a bit of state we need to clear with each effect
         AutoStageAdvance adv(this);
-        const ProcessorStage& stage = *processStages[e];
-        SkASSERT(stage.getProcessor());
 
         if (inColor.isZeros()) {
             SkString inColorName;
 
             // Effects have no way to communicate zeros, they treat an empty string as ones.
             this->nameVariable(&inColorName, '\0', "input");
             fFS.codeAppendf("vec4 %s = %s;", inColorName.c_str(), inColor.c_str());
             inColor = inColorName;
         }
 
         // create var to hold stage result
         SkString outColorName;
         this->nameVariable(&outColorName, '\0', "output");
         fFS.codeAppendf("vec4 %s;", outColorName.c_str());
         outColor = outColorName;
 
-        SkASSERT(installedProcessors);
-        const typename ProcessorStage::Processor& processor = *stage.getProcessor();
-        SkSTArray<2, GrGLProcessor::TransformedCoords> coords(processor.numTransforms());
-        SkSTArray<4, GrGLProcessor::TextureSampler> samplers(processor.numTextures());
+        SkASSERT(ip);
+        const typename ClassMap::Processor& processor = *ClassMap::GetProcessor(fOptState, e);
 
-        this->emitTransforms(stage, &coords, installedProcessors);
-        this->emitSamplers(processor, &samplers, installedProcessors);
-
-        typename ProcessorStage::GLProcessor* glEffect =
-                processor.getFactory().createGLInstance(processor);
-        installedProcessors->addEffect(glEffect);
+        typename ClassMap::GLProcessor* glProc = processor.getFactory().createGLInstance(processor);
+        ip->addEffect(glProc);
 
         // Enclose custom code in a block to avoid namespace conflicts
         SkString openBrace;
-        openBrace.printf("{ // Stage %d: %s\n", fStageIndex, glEffect->name());
+        openBrace.printf("{ // Stage %d: %s\n", fStageIndex, glProc->name());
         fFS.codeAppend(openBrace.c_str());
         fVS.codeAppend(openBrace.c_str());
 
-        glEffect->emitCode(this, processor, keyProvider.get(e), outColor.c_str(),
-                           inColor.isOnes() ? NULL : inColor.c_str(), coords, samplers);
+        SkSTArray<4, GrGLProcessor::TextureSampler> samplers(processor.numTextures());
+        this->emitSamplers(processor, &samplers, ip);
+
+        this->emit(*ClassMap::GetStage(fOptState, e), keyProvider.get(e), outColor.c_str(),
+                   inColor.isOnes() ? NULL : inColor.c_str(), samplers, ip, glProc);
+
+        fFS.codeAppend("}");
+        fVS.codeAppend("}");
 
         // We have to check that effects and the code they emit are consistent, ie if an effect
         // asks for dst color, then the emit code needs to follow suit
         verify(processor);
-        fFS.codeAppend("}");
-        fVS.codeAppend("}");
 
         inColor = outColor;
         effectEmitted = true;
     }
 
     if (effectEmitted) {
         *fsInOutColor = outColor;
     }
+
+    // write to output array
+    SkASSERT(installProc);
+    installProc->reset(ip);
+}
+
+void GrGLProgramBuilder::emit(const GrFragmentStage& fs,
+                              const GrProcessorKey& key,
+                              const char* outColor,
+                              const char* inColor,
+                              const GrGLProcessor::TextureSamplerArray& samplers,
+                              GrGLInstalledProcessors* ip,
+                              GrGLFragmentProcessor* glProc) {
+    // Fragment processors can have coord transforms
+    const GrFragmentProcessor* fp = fs.getProcessor();
+    SkSTArray<2, GrGLProcessor::TransformedCoords> coords(fp->numTransforms());
+    this->emitTransforms(fs, &coords, ip);
+
+    glProc->emitCode(this, *fp, key, outColor, inColor, coords, samplers);
+}
+
+void GrGLProgramBuilder::emit(const GrGeometryProcessor& gp,
+                              const GrProcessorKey& key,
+                              const char* outColor,
+                              const char* inColor,
+                              const GrGLProcessor::TextureSamplerArray& samplers,
+                              GrGLInstalledProcessors* ip,
+                              GrGLGeometryProcessor* glProc) {
+    // TODO remove coords from emit code signature, probably best to use a struct here so these
+    // updates are less painful
+    SkSTArray<2, GrGLProcessor::TransformedCoords> coords;
+    glProc->emitCode(this, gp, key, outColor, inColor, coords, samplers);
 }
 
 void GrGLProgramBuilder::verify(const GrGeometryProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }
 
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
     SkASSERT(fFS.hasReadDstColor() == fp.willReadDstColor());
 }
 
-void GrGLProgramBuilder::emitTransforms(const GrProcessorStage& effectStage,
+void GrGLProgramBuilder::emitTransforms(const GrFragmentStage& effectStage,
                                         GrGLProcessor::TransformedCoordsArray* outCoords,
                                         GrGLInstalledProcessors* installedProcessors) {
     SkTArray<GrGLInstalledProcessors::Transform, true>& transforms =
             installedProcessors->addTransforms();
-    const GrProcessor* effect = effectStage.getProcessor();
+    const GrFragmentProcessor* effect = effectStage.getProcessor();
     int numTransforms = effect->numTransforms();
     transforms.push_back_n(numTransforms);
 
     for (int t = 0; t < numTransforms; t++) {
         const char* uniName = "StageMatrix";
         GrSLType varyingType =
                 effectStage.isPerspectiveCoordTransform(t, fVS.hasExplicitLocalCoords()) ?
                         kVec3f_GrSLType :
                         kVec2f_GrSLType;
 
@@ skipping 157 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledProcessors::~GrGLInstalledProcessors() {
     int numEffects = fGLProcessors.count();
     for (int e = 0; e < numEffects; ++e) {
         SkDELETE(fGLProcessors[e]);
     }
 }