Default geometry processor

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 39 matching lines @@
     // get the initial color and coverage to feed into the first effect in each effect chain
     GrGLSLExpr4 inputColor;
     GrGLSLExpr1 inputCoverage;
     pb->setupUniformColorAndCoverageIfNeeded(&inputColor,  &inputCoverage);
 
     // if we have a vertex shader(we don't only if we are using NVPR or NVPR ES), then we may have
     // to setup a few more things like builtin vertex attributes
     bool hasVertexShader = !(header.fUseNvpr &&
                              gpu->glPathRendering()->texturingMode() ==
                              GrGLPathRendering::FixedFunction_TexturingMode);
+
     if (hasVertexShader) {
+        pb->fVS.setupUniformViewMatrix();
         pb->fVS.setupLocalCoords();
-        pb->fVS.transformGLToSkiaCoords();
         if (header.fEmitsPointSize) {
             pb->fVS.codeAppend("gl_PointSize = 1.0;");
         }
         if (GrProgramDesc::kAttribute_ColorInput == header.fColorInput) {
             pb->fVS.setupBuiltinVertexAttribute("Color", &inputColor);
         }
         if (GrProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
             pb->fVS.setupBuiltinVertexAttribute("Coverage", &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 = GrGLSLExpr4::VectorCast(inputCoverage);
 
-    pb->emitAndInstallProcs(optState, &inputColor, &inputCoverageVec4);
-
-    if (hasVertexShader) {
-        pb->fVS.transformSkiaToGLCoords();
-    }
+    pb->emitAndInstallProcs(&inputColor, &inputCoverageVec4);
 
     // write the secondary color output if necessary
     if (GrProgramDesc::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
         pb->fFS.enableSecondaryOutput(inputColor, inputCoverageVec4);
     }
 
     pb->fFS.combineColorAndCoverage(inputColor, inputCoverageVec4);
 
     return pb->finalize();
 }
@@ skipping 71 matching lines @@
                                                                           int count,
                                                                           const char** outName) {
     SkASSERT(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
     SkASSERT(0 == (~kVisibilityMask & visibility));
     SkASSERT(0 != visibility);
 
     UniformInfo& uni = fUniforms.push_back();
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
-    this->nameVariable(uni.fVariable.accessName(), 'u', name);
+    // TODO this is a bit hacky, lets think of a better way.  Basically we need to be able to use
+    // the uniform view matrix name in the GP, and the GP is immutable so it has to tell the PB
+    // exactly what name it wants to use for the uniform view matrix.  If we prefix anythings, then
+    // the names will mismatch.  I think the correct solution is to have all GPs which need the
+    // uniform view matrix, they should upload the view matrix in their setData along with regular
+    // uniforms.
+    char prefix = 'u';
+    if ('u' == name[0]) {
+        prefix = '\0';
+    }
+    this->nameVariable(uni.fVariable.accessName(), prefix, name);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
 
     // If it is visible in both the VS and FS, the precision must match.
     // We declare a default FS precision, but not a default VS. So set the var
     // to use the default FS precision.
     if ((kVertex_Visibility | kFragment_Visibility) == visibility) {
         // the fragment and vertex precisions must match
         uni.fVariable.setPrecision(kDefaultFragmentPrecision);
     }
@@ skipping 38 matching lines @@
             this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                              kFloat_GrSLType,
                              "Coverage",
                              &name);
         *inputCoverage = GrGLSLExpr1(name);
     } else if (GrProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
         *inputCoverage = GrGLSLExpr1(1);
     }
 }
 
-void GrGLProgramBuilder::emitAndInstallProcs(const GrOptDrawState& optState,
-                                             GrGLSLExpr4* inputColor,
+void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor,
                                              GrGLSLExpr4* inputCoverage) {
+    // We need to collect all of the transforms to thread them through the GP in the case of GPs
+    // which use additional shader stages between the VS and the FS.  To do this we emit a dummy
+    // input coverage
+    GrGLSLExpr4 coverageInput = *inputCoverage;
+    if (fOptState.hasGeometryProcessor()) {
+        AutoStageAdvance adv(this);
+        SkString outColorName;
+        this->nameVariable(&outColorName, '\0', "gpOutput");
+        coverageInput = outColorName;
+    }
+    GrGLSLExpr4 gpOutput = coverageInput;
+
+    // Emit fragment processors
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
-    int numProcs = optState.numFragmentStages();
-    this->emitAndInstallFragProcs(0, optState.numColorStages(), inputColor);
-    if (optState.hasGeometryProcessor()) {
-        const GrGeometryProcessor& gp = *optState.getGeometryProcessor();
+    int numProcs = fOptState.numFragmentStages();
+    this->emitAndInstallFragProcs(0, fOptState.numColorStages(), inputColor);
+    this->emitAndInstallFragProcs(fOptState.numColorStages(), numProcs,  &coverageInput);
+
+    // We have to save the existing code stack, and then append it to the fragment shader code
+    // after emiting the GP
+    if (fOptState.hasGeometryProcessor()) {
+        SkString existingCode(fFS.fCode);
+        fFS.fCode.reset();
+        const GrGeometryProcessor& gp = *fOptState.getGeometryProcessor();
         fVS.emitAttributes(gp);
         ProcKeyProvider keyProvider(&fDesc,
                                     ProcKeyProvider::kGeometry_ProcessorType,
                                     GrGLProgramDescBuilder::kProcessorKeyOffsetsAndLengthOffset);
-        GrGLSLExpr4 output;
-        this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, keyProvider, *inputCoverage, &output);
-        *inputCoverage = output;
+        this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, keyProvider, *inputCoverage, &gpOutput);
+        fFS.fCode.append(existingCode);
     }
-    this->emitAndInstallFragProcs(optState.numColorStages(), numProcs,  inputCoverage);
+    *inputCoverage = coverageInput;
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut) {
     ProcKeyProvider keyProvider(&fDesc,
                                 ProcKeyProvider::kFragment_ProcessorType,
                                 GrGLProgramDescBuilder::kProcessorKeyOffsetsAndLengthOffset);
     for (int e = procOffset; e < numProcs; ++e) {
         GrGLSLExpr4 output;
         const GrFragmentStage& stage = fOptState.getFragmentStage(e);
         this->emitAndInstallProc<GrFragmentStage>(stage, e, keyProvider, *inOut, &output);
         *inOut = output;
     }
 }
 
 // TODO Processors cannot output zeros because an empty string is all 1s
 // the fix is to allow effects to take the GrGLSLExpr4 directly
 template <class Proc>
 void GrGLProgramBuilder::emitAndInstallProc(const Proc& proc,
                                             int index,
                                             const ProcKeyProvider& keyProvider,
                                             const GrGLSLExpr4& input,
                                             GrGLSLExpr4* output) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
 
-    // create var to hold stage result
+    // create var to hold stage result.  If we already have a valid output name, just use that
+    // otherwise create a new mangled one.
     SkString outColorName;
-    this->nameVariable(&outColorName, '\0', "output");
+    if (output->isValid()) {
+        outColorName = output->c_str();
+    } else {
+        this->nameVariable(&outColorName, '\0', "output");
+    }
     fFS.codeAppendf("vec4 %s;", outColorName.c_str());
     *output = outColorName;
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("{ // Stage %d\n", fStageIndex);
     fFS.codeAppend(openBrace.c_str());
 
     this->emitAndInstallProc(proc, keyProvider.get(index), output->c_str(),
                              input.isOnes() ? NULL : input.c_str());
@@ skipping 79 matching lines @@
                                                        uniName,
                                                        &uniName).toShaderBuilderIndex();
 
         const char* varyingName = "MatrixCoord";
         SkString suffixedVaryingName;
         if (0 != t) {
             suffixedVaryingName.append(varyingName);
             suffixedVaryingName.appendf("_%i", t);
             varyingName = suffixedVaryingName.c_str();
         }
+        const char* coords = kPosition_GrCoordSet == effect->coordTransform(t).sourceCoords() ?
+                                                     fVS.positionAttribute().c_str() :
+                                                     fVS.localCoordsAttribute().c_str();
         GrGLVertToFrag v(varyingType);
-        this->addVarying(varyingName, &v);
+        this->addCoordVarying(varyingName, &v, uniName, coords);
 
-        const GrGLShaderVar& coords =
-                kPosition_GrCoordSet == effect->coordTransform(t).sourceCoords() ?
-                                          fVS.positionAttribute() :
-                                          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;",
-                            v.vsOut(), uniName, coords.c_str());
-        } else {
-            fVS.codeAppendf("%s = %s * vec3(%s, 1);",
-                            v.vsOut(), uniName, coords.c_str());
-        }
         SkNEW_APPEND_TO_TARRAY(outCoords, GrGLProcessor::TransformedCoords,
                                (SkString(v.fsIn()), varyingType));
     }
 }
 
 void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor,
                                       GrGLProcessor::TextureSamplerArray* outSamplers,
                                       GrGLInstalledProc* ip) {
     int numTextures = processor.numTextures();
     ip->fSamplers.push_back_n(numTextures);
@@ skipping 112 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }