Solo gp

src/gpu/gl/builders/GrGLFullProgramBuilder.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 "GrGLFullProgramBuilder.h"
 #include "../GrGLGeometryProcessor.h"
 #include "../GrGpuGL.h"
 
 GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu,
-                                              const GrGLProgramDesc& desc)
+                                               const GrGLProgramDesc& desc)
     : INHERITED(gpu, desc)
+    , fGLGeometryProcessorEmitter(this)
     , fGS(this)
     , fVS(this) {
 }
 
 void
-GrGLFullProgramBuilder::createAndEmitEffects(const GrEffectStage* geometryProcessor,
-                                             const GrEffectStage* colorStages[],
-                                             const GrEffectStage* coverageStages[],
+GrGLFullProgramBuilder::createAndEmitEffects(const GrGeometryStage* geometryProcessor,
+                                             const GrFragmentStage* colorStages[],
+                                             const GrFragmentStage* coverageStages[],
                                              GrGLSLExpr4* inputColor,
                                              GrGLSLExpr4* inputCoverage) {
     fVS.emitCodeBeforeEffects(inputColor, inputCoverage);
 
     ///////////////////////////////////////////////////////////////////////////
     // emit the per-effect code for both color and coverage effects
 
-    bool useLocalCoords = this->getVertexShaderBuilder()->hasExplicitLocalCoords();
     EffectKeyProvider colorKeyProvider(&this->desc(), EffectKeyProvider::kColor_EffectType);
     fColorEffects.reset(this->onCreateAndEmitEffects(colorStages,
                                                      this->desc().numColorEffects(),
                                                      colorKeyProvider,
                                                      inputColor));
 
     if (geometryProcessor) {
+        const GrGeometryProcessor& gp = *geometryProcessor->getGeometryProcessor();
+        fGLGeometryProcessorEmitter.set(&gp);
+        fEffectEmitter = &fGLGeometryProcessorEmitter;
+        fVS.emitAttributes(gp);
         GrGLSLExpr4 gpInputCoverage = *inputCoverage;
         GrGLSLExpr4 gpOutputCoverage;
         EffectKeyProvider gpKeyProvider(&this->desc(),
                 EffectKeyProvider::kGeometryProcessor_EffectType);
+        bool useLocalCoords = this->getVertexShaderBuilder()->hasExplicitLocalCoords();
         fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects, (1, useLocalCoords)));
         this->INHERITED::emitEffect(*geometryProcessor, 0, gpKeyProvider, &gpInputCoverage,
                                     &gpOutputCoverage);
         fGeometryProcessor.reset(fProgramEffects.detach());
         *inputCoverage = gpOutputCoverage;
     }
 
     EffectKeyProvider coverageKeyProvider(&this->desc(), EffectKeyProvider::kCoverage_EffectType);
     fCoverageEffects.reset(this->onCreateAndEmitEffects(coverageStages,
                                                         this->desc().numCoverageEffects(),
@@ skipping 27 matching lines @@
                                             const char* name,
                                             const char** vsOutName,
                                             const char** fsInName) {
     addVarying(type, name, vsOutName, fsInName);
     SeparableVaryingInfo& varying = fSeparableVaryingInfos.push_back();
     varying.fVariable = fFS.fInputs.back();
     return VaryingHandle::CreateFromSeparableVaryingIndex(fSeparableVaryingInfos.count() - 1);
 }
 
 GrGLProgramEffects* GrGLFullProgramBuilder::onCreateAndEmitEffects(
-        const GrEffectStage* effectStages[],
+        const GrFragmentStage* effectStages[],
         int effectCnt,
         const GrGLProgramDesc::EffectKeyProvider& keyProvider,
         GrGLSLExpr4* inOutFSColor) {
     fProgramEffects.reset(SkNEW_ARGS(GrGLVertexProgramEffects,
                                  (effectCnt,
                                   this->getVertexShaderBuilder()->hasExplicitLocalCoords())));
     this->INHERITED::createAndEmitEffects(effectStages,
                                           effectCnt,
                                           keyProvider,
                                           inOutFSColor);
     return fProgramEffects.detach();
 }
 
-void GrGLFullProgramBuilder::emitEffect(const GrEffectStage& stage,
-                                                 const GrEffectKey& key,
-                                                 const char* outColor,
-                                                 const char* inColor,
-                                                 int stageIndex) {
+void GrGLFullProgramBuilder::emitEffect(const GrProcessorStage& stage,
+                                        const GrProcessorKey& key,
+                                        const char* outColor,
+                                        const char* inColor,
+                                        int stageIndex) {
     SkASSERT(fProgramEffects.get());
-    const GrEffect& effect = *stage.getEffect();
-    SkSTArray<2, GrGLEffect::TransformedCoords> coords(effect.numTransforms());
-    SkSTArray<4, GrGLEffect::TextureSampler> samplers(effect.numTextures());
+    const GrProcessor& effect = *stage.getProcessor();
+    SkSTArray<2, GrGLProcessor::TransformedCoords> coords(effect.numTransforms());
+    SkSTArray<4, GrGLProcessor::TextureSampler> samplers(effect.numTextures());
 
-    fVS.emitAttributes(stage);
     this->emitTransforms(stage, &coords);
     this->emitSamplers(effect, &samplers);
 
-    GrGLEffect* glEffect = effect.getFactory().createGLInstance(effect);
+    SkASSERT(fEffectEmitter);
+    GrGLProcessor* glEffect = fEffectEmitter->createGLInstance();
     fProgramEffects->addEffect(glEffect);
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d: %s\n", stageIndex, glEffect->name());
     fFS.codeAppend(openBrace.c_str());
     fVS.codeAppend(openBrace.c_str());
 
-    if (glEffect->isVertexEffect()) {
-        GrGLGeometryProcessor* vertexEffect = static_cast<GrGLGeometryProcessor*>(glEffect);
-        vertexEffect->emitCode(this, effect, key, outColor, inColor, coords, samplers);
-    } else {
-        glEffect->emitCode(this, effect, key, outColor, inColor, coords, samplers);
-    }
+    fEffectEmitter->emit(key, outColor, inColor, coords, samplers);
 
     fVS.codeAppend("\t}\n");
     fFS.codeAppend("\t}\n");
 }
 
-void GrGLFullProgramBuilder::emitTransforms(const GrEffectStage& effectStage,
-                                            GrGLEffect::TransformedCoordsArray* outCoords) {
+void GrGLFullProgramBuilder::emitTransforms(const GrProcessorStage& effectStage,
+                                            GrGLProcessor::TransformedCoordsArray* outCoords) {
     SkTArray<GrGLVertexProgramEffects::Transform, true>& transforms =
             fProgramEffects->addTransforms();
-    const GrEffect* effect = effectStage.getEffect();
+    const GrProcessor* effect = effectStage.getProcessor();
     int numTransforms = effect->numTransforms();
     transforms.push_back_n(numTransforms);
 
     SkTArray<GrGLVertexProgramEffects::PathTransform, true>* pathTransforms = NULL;
     const GrGLCaps* glCaps = this->ctxInfo().caps();
     if (glCaps->pathRenderingSupport() &&
         this->gpu()->glPathRendering()->texturingMode() ==
            GrGLPathRendering::SeparableShaders_TexturingMode) {
         pathTransforms = &fProgramEffects->addPathTransforms();
         pathTransforms->push_back_n(numTransforms);
@@ skipping 40 matching lines @@
                                           fVS.localCoordsAttribute();
         // varying = matrix * coords (logically)
         SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
         if (kVec2f_GrSLType == varyingType) {
             fVS.codeAppendf("%s = (%s * vec3(%s, 1)).xy;",
                             vsVaryingName, uniName, coords.c_str());
         } else {
             fVS.codeAppendf("%s = %s * vec3(%s, 1);",
                             vsVaryingName, uniName, coords.c_str());
         }
-        SkNEW_APPEND_TO_TARRAY(outCoords, GrGLEffect::TransformedCoords,
+        SkNEW_APPEND_TO_TARRAY(outCoords, GrGLProcessor::TransformedCoords,
                                (SkString(fsVaryingName), varyingType));
     }
 }
 
 bool GrGLFullProgramBuilder::compileAndAttachShaders(GrGLuint programId,
                                                      SkTDArray<GrGLuint>* shaderIds) const {
     return INHERITED::compileAndAttachShaders(programId, shaderIds)
          && fVS.compileAndAttachShaders(programId, shaderIds)
 #if GR_GL_EXPERIMENTAL_GS
          && (!desc().getHeader().fExperimentalGS
                  || fGS.compileAndAttachShaders(programId, shaderIds))
 #endif
          ;
 }
 
 void GrGLFullProgramBuilder::bindProgramLocations(GrGLuint programId) {
     fVS.bindProgramLocations(programId);
     INHERITED::bindProgramLocations(programId);
 }