Late creation of GrPathProcessor

src/gpu/gl/GrGLPathProcessor.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLPathProcessor.h"
 
 #include "GrPathProcessor.h"
 #include "GrGLGpu.h"
 #include "GrGLPathRendering.h"
 
 GrGLPathProcessor::GrGLPathProcessor(const GrPathProcessor&, const GrBatchTracker&)
     : fColor(GrColor_ILLEGAL) {}
 
 void GrGLPathProcessor::emitCode(EmitArgs& args) {
     GrGLGPBuilder* pb = args.fPB;
     GrGLFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
-    const PathBatchTracker& local = args.fBT.cast<PathBatchTracker>();
+    const GrPathProcessor& pathProc = args.fGP.cast<GrPathProcessor>();
 
     // emit transforms
     this->emitTransforms(args.fPB, args.fTransformsIn, args.fTransformsOut);
 
     // Setup uniform color
-    if (kUniform_GrGPInput == local.fInputColorType) {
+    if (pathProc.opts().readsColor()) {
         const char* stagedLocalVarName;
         fColorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                        kVec4f_GrSLType,
                                        kDefault_GrSLPrecision,
                                        "Color",
                                        &stagedLocalVarName);
         fs->codeAppendf("%s = %s;", args.fOutputColor, stagedLocalVarName);
     }
 
     // setup constant solid coverage
-    if (kAllOnes_GrGPInput == local.fInputCoverageType) {
+    if (pathProc.opts().readsCoverage()) {
         fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
     }
 }
 
-void GrGLPathProcessor::GenKey(const GrPathProcessor&,
+void GrGLPathProcessor::GenKey(const GrPathProcessor& pathProc,
                                const GrBatchTracker& bt,
                                const GrGLSLCaps&,
                                GrProcessorKeyBuilder* b) {
-    const PathBatchTracker& local = bt.cast<PathBatchTracker>();
-    b->add32(local.fInputColorType | local.fInputCoverageType << 16);
+    b->add32(SkToInt(pathProc.opts().readsColor()) |
+             SkToInt(pathProc.opts().readsCoverage()) << 16);
 }
 
 void GrGLPathProcessor::setData(const GrGLProgramDataManager& pdman,
                                 const GrPrimitiveProcessor& primProc,
                                 const GrBatchTracker& bt) {
-    const PathBatchTracker& local = bt.cast<PathBatchTracker>();
-    if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
+    const GrPathProcessor& pathProc = primProc.cast<GrPathProcessor>();
+    if (pathProc.opts().readsColor() && pathProc.color() != fColor) {
         GrGLfloat c[4];
-        GrColorToRGBAFloat(local.fColor, c);
+        GrColorToRGBAFloat(pathProc.color(), c);
         pdman.set4fv(fColorUniform, 1, c);
-        fColor = local.fColor;
+        fColor = pathProc.color();
     }
 }
 
 void GrGLPathProcessor::emitTransforms(GrGLGPBuilder* pb, const TransformsIn& tin,
                                        TransformsOut* tout) {
     tout->push_back_n(tin.count());
     fInstalledTransforms.push_back_n(tin.count());
     for (int i = 0; i < tin.count(); i++) {
         const ProcCoords& coordTransforms = tin[i];
         fInstalledTransforms[i].push_back_n(coordTransforms.count());
@@ skipping 31 matching lines @@
             continue;
         }
         transforms[t].fCurrentValue = transform;
 
         SkASSERT(transforms[t].fType == kVec2f_GrSLType ||
                  transforms[t].fType == kVec3f_GrSLType);
         unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3;
         pdman.setPathFragmentInputTransform(transforms[t].fHandle.handle(), components, transform);
     }
 }