Draft change to start pulling uniform color into 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 "GrGLProgramBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
@@ skipping 19 matching lines @@
     // 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(optState,
                                                                    optState.hasGeometryProcessor(),
                                                                    gpu));
 
     GrGLProgramBuilder* pb = builder.get();
     const GrGLProgramDescBuilder::GLKeyHeader& header = GrGLProgramDescBuilder::GetHeader(pb->desc());
 
     // emit code to read the dst copy texture, if necessary
-    if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey
-            && !gpu->glCaps().fbFetchSupport()) {
+    if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey &&
+        !gpu->glCaps().fbFetchSupport()) {
         pb->fFS.emitCodeToReadDstTexture();
     }
 
-    // get the initial color and coverage to feed into the first effect in each effect chain
+    // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
+    // seed correctly here
     GrGLSLExpr4 inputColor;
-    GrGLSLExpr1 inputCoverage;
-    pb->setupUniformColorAndCoverageIfNeeded(&inputColor,  &inputCoverage);
+    GrGLSLExpr4 inputCoverage;
 
-    // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can
-    // remove this cast to a vec4.
-    GrGLSLExpr4 inputCoverageVec4;
-    if (inputCoverage.isValid()) {
-        inputCoverageVec4 = GrGLSLExpr4::VectorCast(inputCoverage);
-    }
-
-    pb->emitAndInstallProcs(&inputColor, &inputCoverageVec4);
+    pb->emitAndInstallProcs(&inputColor, &inputCoverage);
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder* GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
                                                              bool hasGeometryProcessor,
                                                              GrGpuGL* gpu) {
     const GrProgramDesc& desc = optState.programDesc();
     if (GrGLProgramDescBuilder::GetHeader(desc).fUseNvpr) {
         SkASSERT(gpu->glCaps().pathRenderingSupport());
-        SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fColorInput);
-        SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fCoverageInput);
         SkASSERT(!hasGeometryProcessor);
         if (gpu->glPathRendering()->texturingMode() ==
             GrGLPathRendering::FixedFunction_TexturingMode) {
             return SkNEW_ARGS(GrGLLegacyNvprProgramBuilder, (gpu, optState));
         } else {
             return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, optState));
         }
     } else {
         return SkNEW_ARGS(GrGLProgramBuilder, (gpu, optState));
     }
@@ skipping 98 matching lines @@
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
-void GrGLProgramBuilder::setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor,
-                                                              GrGLSLExpr1* inputCoverage) {
-    const GrProgramDesc::KeyHeader& header = this->header();
-    if (GrProgramDesc::kUniform_ColorInput == header.fColorInput) {
-        const char* name;
-        fUniformHandles.fColorUni =
-            this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                             kVec4f_GrSLType, kDefault_GrSLPrecision,
-                             "Color", &name);
-        *inputColor = GrGLSLExpr4(name);
-    } else if (GrProgramDesc::kAllOnes_ColorInput == header.fColorInput) {
-        *inputColor = GrGLSLExpr4(1);
-    }
-    if (GrProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
-        const char* name;
-        fUniformHandles.fCoverageUni =
-            this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                             kFloat_GrSLType, kDefault_GrSLPrecision,
-                             "Coverage",&name);
-        *inputCoverage = GrGLSLExpr1(name);
-    } else if (GrProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
-        *inputCoverage = GrGLSLExpr1(1);
-    }
-}
-
 void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage) {
     if (fOptState.hasGeometryProcessor()) {
         fVS.setupUniformViewMatrix();
 
-        const GrProgramDesc::KeyHeader& header = this->header();
         fVS.codeAppend("gl_PointSize = 1.0;");
 
         // Setup position
         // TODO it'd be possible to remove these from the vertexshader builder and have them
         // be outputs from the emit call.  We don't do this because emitargs is constant.  It would
         // be easy to change this though
         fVS.codeAppendf("vec3 %s;", fVS.glPosition());
         fVS.codeAppendf("vec2 %s;", fVS.positionCoords());
         fVS.codeAppendf("vec2 %s;", fVS.localCoords());
 
         const GrGeometryProcessor& gp = *fOptState.getGeometryProcessor();
         fVS.emitAttributes(gp);
-        GrGLSLExpr4 outputColor;
-        GrGLSLExpr4 outputCoverage;
-        this->emitAndInstallProc(gp, &outputColor, &outputCoverage);
+    }
 
-        // We may override color and coverage here if we have unform color or coverage.  This is
-        // obviously not ideal.
-        // TODO lets the GP itself do the override
-        if (GrProgramDesc::kAttribute_ColorInput == header.fColorInput) {
-            *inputColor = outputColor;
-        }
-
-        // We may have uniform coverage, if so we need to multiply the GPs output by the uniform
-        // coverage
-        if (GrProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
-            fFS.codeAppendf("%s *= %s;", outputCoverage.c_str(), inputCoverage->c_str());
-        }
-        *inputCoverage = outputCoverage;
-    }
+    const GrPrimitiveProcessor& primProc = *fOptState.getPrimitiveProcessor();
+    this->emitAndInstallProc(primProc, inputColor, inputCoverage);
 
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = fOptState.numFragmentStages();
     this->emitAndInstallFragProcs(0, fOptState.numColorStages(), inputColor);
     this->emitAndInstallFragProcs(fOptState.numColorStages(), numProcs,  inputCoverage);
 
     if (fOptState.hasGeometryProcessor()) {
         fVS.transformToNormalizedDeviceSpace();
     }
 
@@ skipping 38 matching lines @@
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
     fFS.codeAppend(openBrace.c_str());
 
     this->emitAndInstallProc(proc, output->c_str(), input.isOnes() ? NULL : input.c_str());
 
     fFS.codeAppend("}");
 }
 
-void GrGLProgramBuilder::emitAndInstallProc(const GrGeometryProcessor& proc,
+void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& proc,
                                             GrGLSLExpr4* outputColor,
                                             GrGLSLExpr4* outputCoverage) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
     this->nameExpression(outputColor, "outputColor");
     this->nameExpression(outputCoverage, "outputCoverage");
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
@@ skipping 20 matching lines @@
     this->emitTransforms(fs, &coords, ifp);
 
     ifp->fGLProc->emitCode(this, fp, outColor, inColor, coords, samplers);
 
     // 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(fp);
     fFragmentProcessors->fProcs.push_back(ifp);
 }
 
-void GrGLProgramBuilder::emitAndInstallProc(const GrGeometryProcessor& gp,
+void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& gp,
                                             const char* outColor,
                                             const char* outCoverage) {
     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = SkNEW(GrGLInstalledGeoProc);
 
     const GrBatchTracker& bt = fOptState.getBatchTracker();
     fGeometryProcessor->fGLProc.reset(gp.createGLInstance(bt));
 
     SkSTArray<4, GrGLProcessor::TextureSampler> samplers(gp.numTextures());
     this->emitSamplers(gp, &samplers, fGeometryProcessor);
@@ skipping 38 matching lines @@
                                      fFS.getPrimaryColorOutputName(),
                                      fFS.getSecondaryColorOutputName(), samplers);
     fXferProcessor->fGLProc->emitCode(args);
 
     // 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(xp);
     fFS.codeAppend("}");
 }
 
-void GrGLProgramBuilder::verify(const GrGeometryProcessor& gp) {
+void GrGLProgramBuilder::verify(const GrPrimitiveProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }
 
 void GrGLProgramBuilder::verify(const GrXferProcessor& xp) {
     // TODO: Once will readDst is only xp enable this assert and remove it from the
     // FragmentProcessor verify()
     //SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
 }
 
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
@@ skipping 65 matching lines @@
 GrGLProgram* GrGLProgramBuilder::finalize() {
     // verify we can get a program id
     GrGLuint programID;
     GL_CALL_RET(programID, CreateProgram());
     if (0 == programID) {
         return NULL;
     }
 
     // compile shaders and bind attributes / uniforms
     SkTDArray<GrGLuint> shadersToDelete;
-    if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
-        this->cleanupProgram(programID, shadersToDelete);
-        return NULL;
-    }
-
     if (!(GrGLProgramDescBuilder::GetHeader(fDesc).fUseNvpr &&
           fGpu->glPathRendering()->texturingMode() ==
           GrGLPathRendering::FixedFunction_TexturingMode)) {
         if (!fVS.compileAndAttachShaders(programID, &shadersToDelete)) {
             this->cleanupProgram(programID, shadersToDelete);
             return NULL;
         }
 
         // Non fixed function NVPR actually requires a vertex shader to compile
         if (fOptState.hasGeometryProcessor()) {
             fVS.bindVertexAttributes(programID);
         }
     }
+
+    if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
+        this->cleanupProgram(programID, shadersToDelete);
+        return NULL;
+    }
+
     bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
     if (usingBindUniform) {
         this->bindUniformLocations(programID);
     }
     fFS.bindFragmentShaderLocations(programID);
     GL_CALL(LinkProgram(programID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = !fGpu->ctxInfo().isChromium();
 #ifdef SK_DEBUG
@@ skipping 68 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }