Solo gp

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 12 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* geometryProcessor,
-                                    const GrEffectStage* colorStages[],
-                                    const GrEffectStage* coverageStages[]) {
+bool GrGLProgramBuilder::genProgram(const GrGeometryStage* geometryProcessor,
+                                    const GrFragmentStage* colorStages[],
+                                    const GrFragmentStage* 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 31 matching lines @@
         return false;
     }
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu,
                                        const GrGLProgramDesc& desc)
-    : fFragOnly(!desc.getHeader().fRequiresVertexShader &&
+    : fEffectEmitter(NULL)
+    , fFragOnly(!desc.getHeader().fRequiresVertexShader &&
                 gpu->glCaps().pathRenderingSupport() &&
                 gpu->glPathRendering()->texturingMode() == GrGLPathRendering::FixedFunction_TexturingMode)
     , fTexCoordSetCnt(0)
     , fProgramID(0)
     , fFS(this, desc)
     , fSeparableVaryingInfos(kVarsPerBlock)
+    , fGrProcessorEmitter(this)
     , fDesc(desc)
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock) {
 }
 
 void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
@@ skipping 48 matching lines @@
 void GrGLProgramBuilder::appendUniformDecls(ShaderVisibility visibility,
                                             SkString* out) const {
     for (int i = 0; i < fUniforms.count(); ++i) {
         if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
-void GrGLProgramBuilder::createAndEmitEffects(const GrEffectStage* effectStages[],
+void GrGLProgramBuilder::createAndEmitEffects(const GrFragmentStage* effectStages[],
                                               int effectCnt,
                                               const GrGLProgramDesc::EffectKeyProvider& keyProvider,
                                               GrGLSLExpr4* fsInOutColor) {
     bool effectEmitted = false;
 
     GrGLSLExpr4 inColor = *fsInOutColor;
     GrGLSLExpr4 outColor;
 
     for (int e = 0; e < effectCnt; ++e) {
+        fGrProcessorEmitter.set(effectStages[e]->getFragmentProcessor());
+        fEffectEmitter = &fGrProcessorEmitter;
         // calls into the subclass to emit the actual effect into the program effect object
         this->emitEffect(*effectStages[e], e, keyProvider, &inColor, &outColor);
         effectEmitted = true;
     }
 
     if (effectEmitted) {
         *fsInOutColor = outColor;
     }
 }
 
-void GrGLProgramBuilder::emitEffect(const GrEffectStage& effectStage,
+void GrGLProgramBuilder::emitEffect(const GrProcessorStage& effectStage,
                                     int effectIndex,
                                     const GrGLProgramDesc::EffectKeyProvider& keyProvider,
                                     GrGLSLExpr4* inColor,
                                     GrGLSLExpr4* outColor) {
-    SkASSERT(effectStage.getEffect());
+    SkASSERT(effectStage.getProcessor());
     CodeStage::AutoStageRestore csar(&fCodeStage, &effectStage);
 
     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;
 
     this->emitEffect(effectStage, keyProvider.get(effectIndex), outColor->c_str(),
                      inColor->isOnes() ? NULL : inColor->c_str(), fCodeStage.stageIndex());
 
     *inColor = *outColor;
 }
 
-void GrGLProgramBuilder::emitSamplers(const GrEffect& effect,
-                                      GrGLEffect::TextureSamplerArray* outSamplers) {
+void GrGLProgramBuilder::emitSamplers(const GrProcessor& effect,
+                                      GrGLProcessor::TextureSamplerArray* outSamplers) {
     SkTArray<GrGLProgramEffects::Sampler, true>& samplers =
             this->getProgramEffects()->addSamplers();
     int numTextures = effect.numTextures();
     samplers.push_back_n(numTextures);
     SkString name;
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
         samplers[t].fUniform = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                 kSampler2D_GrSLType,
                                                 name.c_str());
-        SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLEffect::TextureSampler,
+        SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
                                (samplers[t].fUniform, effect.textureAccess(t)));
     }
 }
 
 bool GrGLProgramBuilder::finish() {
     SkASSERT(0 == fProgramID);
     GL_CALL_RET(fProgramID, CreateProgram());
     if (!fProgramID) {
         return false;
     }
@@ skipping 85 matching lines @@
                     GetProgramResourceLocation(programId,
                                                GR_GL_FRAGMENT_INPUT,
                                                fSeparableVaryingInfos[i].fVariable.c_str()));
         fSeparableVaryingInfos[i].fLocation = location;
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }