Initial change to create GeometryProcessor

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 "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 13 matching lines @@
 
 // number of each input/output type in a single allocation block
 static const int kVarsPerBlock = 8;
 
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool GrGLProgramBuilder::genProgram(const GrEffectStage* colorStages[],
+bool GrGLProgramBuilder::genProgram(const GrEffectStage* geometryProcessor,
+                                    const GrEffectStage* colorStages[],
                                     const GrEffectStage* coverageStages[]) {
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
     fFS.emitCodeBeforeEffects();
 
     ///////////////////////////////////////////////////////////////////////////
     // get the initial color and coverage to feed into the first effect in each effect chain
 
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
@@ skipping 27 matching lines @@
     ///////////////////////////////////////////////////////////////////////////
     // emit the per-effect code for both color and coverage effects
 
     GrGLProgramDesc::EffectKeyProvider colorKeyProvider(
         &this->desc(), GrGLProgramDesc::EffectKeyProvider::kColor_EffectType);
     fColorEffects.reset(this->createAndEmitEffects(colorStages,
                                                    this->desc().numColorEffects(),
                                                    colorKeyProvider,
                                                    &inputColor));
 
+    this->emitGeometryProcessor(geometryProcessor, &inputCoverage);
+
     GrGLProgramDesc::EffectKeyProvider coverageKeyProvider(
         &this->desc(), GrGLProgramDesc::EffectKeyProvider::kCoverage_EffectType);
     fCoverageEffects.reset(this->createAndEmitEffects(coverageStages,
                                                       this->desc().numCoverageEffects(),
                                                       coverageKeyProvider,
                                                       &inputCoverage));
 
     this->emitCodeAfterEffects();
 
     fFS.emitCodeAfterEffects(inputColor, inputCoverage);
@@ skipping 235 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFullProgramBuilder::GrGLFullProgramBuilder(GrGpuGL* gpu,
                                               const GrGLProgramDesc& desc)
     : INHERITED(gpu, desc)
     , fGS(this)
     , fVS(this) {
 }
 
-void GrGLFullProgramBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) {
+void GrGLFullProgramBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color,
+                                                   GrGLSLExpr4* coverage) {
     fVS.emitCodeBeforeEffects(color, coverage);
 }
 
+void GrGLFullProgramBuilder::emitGeometryProcessor(const GrEffectStage* geometryProcessor,
+                                                   GrGLSLExpr4* coverage) {
+    if (NULL != geometryProcessor) {
+        GrGLProgramDesc::EffectKeyProvider geometryProcessorKeyProvider(
+                &this->desc(), GrGLProgramDesc::EffectKeyProvider::kGeometryProcessor_EffectType);
+        fGeometryProcessor.reset(this->createAndEmitEffect(
+                                 geometryProcessor,
+                                 geometryProcessorKeyProvider,
+                                 coverage));
+    }
+}
+
 void GrGLFullProgramBuilder::emitCodeAfterEffects() {
     fVS.emitCodeAfterEffects();
 }
 
 void GrGLFullProgramBuilder::addVarying(GrSLType type,
                                         const char* name,
                                         const char** vsOutName,
                                         const char** fsInName,
                                         GrGLShaderVar::Precision fsPrecision) {
     fVS.addVarying(type, name, vsOutName);
@@ skipping 30 matching lines @@
 
     GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
                                           effectStages,
                                           effectCnt,
                                           keyProvider,
                                           inOutFSColor);
     return programEffectsBuilder.finish();
 }
 
+void GrGLFullProgramBuilder::createAndEmitEffect(GrGLProgramEffectsBuilder* programEffectsBuilder,
+                                              const GrEffectStage* effectStages,
+                                              const GrGLProgramDesc::EffectKeyProvider& keyProvider,
+                                              GrGLSLExpr4* fsInOutColor) {
+    GrGLSLExpr4 inColor = *fsInOutColor;
+    GrGLSLExpr4 outColor;
+
+    SkASSERT(NULL != effectStages && NULL != effectStages->getEffect());
+    const GrEffectStage& stage = *effectStages;
+
+    // Using scope to force ASR destructor to be triggered
+    {
+        CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
+
+        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;
+
+
+        programEffectsBuilder->emitEffect(stage,
+                                          keyProvider.get(0),
+                                          outColor.c_str(),
+                                          inColor.isOnes() ? NULL : inColor.c_str(),
+                                          fCodeStage.stageIndex());
+    }
+
+    *fsInOutColor = outColor;
+}
+
+GrGLProgramEffects* GrGLFullProgramBuilder::createAndEmitEffect(
+        const GrEffectStage* geometryProcessor,
+        const GrGLProgramDesc::EffectKeyProvider& keyProvider,
+        GrGLSLExpr4* inOutFSColor) {
+
+    GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, 1);
+    this->createAndEmitEffect(&programEffectsBuilder, geometryProcessor, keyProvider, inOutFSColor);
+    return programEffectsBuilder.finish();
+}
+
 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
          ;
 }
@@ skipping 27 matching lines @@
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectCnt,
                                           keyProvider,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }