Draft change to start pulling uniform color into GP

src/gpu/GrDefaultGeoProcFactory.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 "GrDefaultGeoProcFactory.h"
 
 #include "GrDrawState.h"
@@ skipping 14 matching lines @@
         return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags));
     }
 
     virtual const char* name() const SK_OVERRIDE { return "DefaultGeometryProcessor"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inColor() const { return fInColor; }
     const GrAttribute* inLocalCoords() const { return fInLocalCoords; }
     const GrAttribute* inCoverage() const { return fInCoverage; }
 
+    void initBatchTracker(GrBatchTracker* bt, const InitBT& init) const SK_OVERRIDE {
+        BatchTracker* local = bt->cast<BatchTracker>();
+
+        // We will ignore this color unless we have uniform color
+        local->fColor = init.fColor;
+        local->fOutputColor = GetColorOutputType(init, SkToBool(fInColor));
+
+        bool hasVertexCoverage = init.fOutputCoverage && fInCoverage && !init.fRemoveCoverageAttr;
+        bool covIsSolidWhite = !hasVertexCoverage && 0xffffffff == init.fCoverage;
+        if (covIsSolidWhite || !init.fOutputCoverage) {
+            local->fOutputCoverage = kAllOnes_Output;
+        } else if (!hasVertexCoverage) {
+            local->fOutputCoverage = kUniform_Output;
+            local->fCoverage = init.fCoverage;
+        } else {
+            SkASSERT(fInCoverage);
+            local->fOutputCoverage = kAttribute_Output;
+        }
+    }
+
+    virtual bool canBatch(const GrBatchTracker& l, const GrBatchTracker& r) const SK_OVERRIDE {
+        const BatchTracker& left = l.cast<BatchTracker>();
+        const BatchTracker& right = r.cast<BatchTracker>();
+        if (left.fOutputColor != right.fOutputColor) {
+            return false;
+        }
+
+        if (kAttribute_Output != left.fOutputColor && left.fColor != right.fColor) {

[bsalomon, 2014/12/10 18:36:20]

need these comparisons for coverage too? also seems like kUniform_Output ==
would be a bit clearer. Isn't it more correct too? (If they're both AllOnes do
we need to compare?)

+            return false;
+        }
+
+        return true;
+    }
+
     class GLProcessor : public GrGLGeometryProcessor {
     public:
-        GLProcessor(const GrGeometryProcessor&,
-                    const GrBatchTracker&) {}
+        GLProcessor(const GrGeometryProcessor&, const GrBatchTracker&) {}
 
         virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
             const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
-            GrGLVertexBuilder* vs = args.fPB->getVertexShaderBuilder();
+            GrGLGPBuilder* pb = args.fPB;
+            GrGLVertexBuilder* vs = pb->getVertexShaderBuilder();
+            GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
+            const BatchTracker& local = args.fBT.cast<BatchTracker>();
 
             vs->codeAppendf("%s = %s;", vs->positionCoords(), gp.inPosition()->fName);
 
             // Setup pass through color
-            if (gp.inColor()) {
+            if (kUniform_Output == local.fOutputColor) {
+                const char* fragColor;
+                fColorUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                               kVec4f_GrSLType,
+                                               kDefault_GrSLPrecision,
+                                               "Color",
+                                               &fragColor);
+                fs->codeAppendf("%s = %s;", args.fOutputColor, fragColor);
+            } else if (kAttribute_Output == local.fOutputColor) {
+                SkASSERT(gp.inColor());
                 args.fPB->addPassThroughAttribute(gp.inColor(), args.fOutputColor);
+            } else {
+                fs->codeAppendf("%s = vec4(1);", args.fOutputColor);
             }
 
             // Setup local coords if needed
             if (gp.inLocalCoords()) {
                 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inLocalCoords()->fName);
             } else {
                 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inPosition()->fName);
             }
 
             // setup position varying
             vs->codeAppendf("%s = %s * vec3(%s, 1);", vs->glPosition(), vs->uViewM(),
                             gp.inPosition()->fName);
 
             // Setup coverage as pass through
-            GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
-            fs->codeAppendf("float alpha = 1.0;");
-            if (gp.inCoverage()) {
+            if (kUniform_Output == local.fOutputCoverage) {
+                const char* fragCoverage;
+                fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                                  kFloat_GrSLType,
+                                                  kDefault_GrSLPrecision,
+                                                  "Coverage",
+                                                  &fragCoverage);
+                fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage);
+            } else if (kAttribute_Output == local.fOutputCoverage) {
+                SkASSERT(gp.inCoverage());
+                fs->codeAppendf("float alpha = 1.0;");
                 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha");
+                fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
+            } else {
+                fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
             }
-            fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
         }
 
         static inline void GenKey(const GrGeometryProcessor& gp,
-                                  const GrBatchTracker&,
+                                  const GrBatchTracker& bt,
                                   const GrGLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
             b->add32(def.fFlags);
+
+            const BatchTracker& local = bt.cast<BatchTracker>();
+            b->add32(local.fOutputColor | local.fOutputCoverage << 16);
         }
 
-        virtual void setData(const GrGLProgramDataManager&,
-                             const GrGeometryProcessor&,
-                             const GrBatchTracker&) SK_OVERRIDE {}
+        virtual void setData(const GrGLProgramDataManager& pdman,
+                             const GrGeometryProcessor& gp,
+                             const GrBatchTracker& bt) SK_OVERRIDE {
+            const BatchTracker& local = bt.cast<BatchTracker>();
+            if (kUniform_Output == local.fOutputColor) {

[bsalomon, 2014/12/10 18:36:20]

I wonder whether we should be skipping uni uploads when the color is unchanged.

+                GrGLfloat c[4];
+                GrColorToRGBAFloat(local.fColor, c);
+                pdman.set4fv(fColorUniform, 1, c);
+            }
+            if (kUniform_Output == local.fOutputCoverage) {
+                pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCoverage));
+            }
+        }
 
     private:
+        UniformHandle fColorUniform;
+        UniformHandle fCoverageUniform;
+
         typedef GrGLGeometryProcessor INHERITED;
     };
 
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
@@ skipping 20 matching lines @@
         if (hasLocalCoord) {
             fInLocalCoords = &this->addVertexAttrib(GrAttribute("inLocalCoord",
                                                                 kVec2f_GrVertexAttribType));
             this->setHasLocalCoords();
         }
         if (hasCoverage) {
             fInCoverage = &this->addVertexAttrib(GrAttribute("inCoverage",
                                                              kFloat_GrVertexAttribType));
             this->setHasVertexCoverage();
         }
+        fNewStyle = true;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
         return gp.fFlags == this->fFlags;
     }
 
     virtual void onGetOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
         if (fInCoverage) {
             out->setUnknownSingleComponent();
         } else {
             // uniform coverage
             out->setKnownSingleComponent(this->coverage());
         }
     }
 
+    struct BatchTracker {
+        Output fOutputColor;

[bsalomon, 2014/12/10 18:36:20]

The names of these vars and enum don't seem right to me. fOutputColor sounds
like a color. Also, are they really outputs? They seem more like inputs to the
GP methods that the GP uses to get its color/coverage. Just curious, do we use
kAllOnes for color ever?

+        Output fOutputCoverage;
+        GrColor fColor;
+        GrColor fCoverage;
+    };
+
     const GrAttribute* fInPosition;
     const GrAttribute* fInColor;
     const GrAttribute* fInLocalCoords;
     const GrAttribute* fInCoverage;
     uint32_t fFlags;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
@@ skipping 15 matching lines @@
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     }
 
     return DefaultGeoProc::Create(GrRandomColor(random), GrRandomCoverage(random), flags);
 }
 
 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(GrColor color, uint32_t gpTypeFlags,
                                                            uint8_t coverage) {
     return DefaultGeoProc::Create(color, coverage, gpTypeFlags);
 }