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 13 matching lines @@
         fUniformHandles.fCoverageUni =
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                              kVec4f_GrSLType,
                              "Coverage",
                              &name);
         inputCoverage = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
         inputCoverage = GrGLSLExpr4(1);
     }
 
-    this->emitCodeBeforeEffects(&inputColor, &inputCoverage);
+    this->emitCodeBeforeEffects(geometryProcessor, &inputColor, &inputCoverage);
 
     ///////////////////////////////////////////////////////////////////////////
     // 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));
@@ skipping 246 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(const GrEffectStage* geometryProcessor,
+                                                   GrGLSLExpr4* color,
+                                                   GrGLSLExpr4* coverage) {
+    const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
+
     fVS.emitCodeBeforeEffects(color, coverage);
+
+    if (geometryProcessor) {
+        GrGLProgramDesc::EffectKeyProvider geometryProcessorKeyProvider(
+                &this->desc(), GrGLProgramDesc::EffectKeyProvider::kGeometryProcessor_EffectType);
+        fGeometryProcessor.reset(this->createAndEmitEffect(
+                                 geometryProcessor,
+                                 geometryProcessorKeyProvider,
+                                 header.fSeparateCoverageFromColor ? coverage : color));
+    }
 }
 
 void GrGLFullProgramBuilder::emitCodeAfterEffects() {
     fVS.emitCodeAfterEffects();
 }
 
 void GrGLFullProgramBuilder::addVarying(GrSLType type,
                                         const char* name,
                                         const char** vsOutName,
                                         const char** fsInName) {
@@ skipping 31 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;
+
+    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("\tvec4 %s = %s;\n", inColorName.c_str(), inColor.c_str());
+        inColor = inColorName;
+    }
+
+    // create var to hold stage result
+    SkString outColorName;
+    this->nameVariable(&outColorName, '\0', "output");
+    fFS.codeAppendf("\tvec4 %s;\n", 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();
 }