Remove GP from drawstate, revision of invariant output for GP

src/gpu/GrGeometryProcessor.h

Index: src/gpu/GrGeometryProcessor.h
diff --git a/src/gpu/GrGeometryProcessor.h b/src/gpu/GrGeometryProcessor.h
index 4801069005fdd21ccc4a9103e1f8b9fac4905059..c4a251ad3965dc8abbdfd7379e988d867bb97db4 100644
--- a/src/gpu/GrGeometryProcessor.h
+++ b/src/gpu/GrGeometryProcessor.h
@@ -39,6 +39,23 @@ class GrGLCaps;
 class GrGLGeometryProcessor;
 class GrOptDrawState;
 
+struct GrInitInvariantOutput;
+
+/*
+ * GrGeometryProcessors and GrPathProcessors may effect invariantColor
+ */
+class GrPrimitiveProcessor : public GrProcessor {
+public:
+    // TODO GPs and PPs have to provide an initial coverage because the coverage invariant code is
+    // broken right now
+    virtual uint8_t coverage() const = 0;
+    virtual void getOutputColor(GrInitInvariantOutput* out) const = 0;

[bsalomon, 2014/12/10 18:44:31]

still find these names confusing, I think it should have the word "invariant",
or something to that effect since the color/cov is variable and this is about
querying whether there are known aspects of it (always single-channel, the red
channel is known to be 0.5, etc).

+    virtual void getOutputCoverage(GrInitInvariantOutput* out) const = 0;
+
+private:
+    typedef GrProcessor INHERITED;
+};
+
 /**
  * A GrGeometryProcessor is used to perform computation in the vertex shader and
  * add support for custom vertex attributes. A GrGemeotryProcessor is typically
@@ -49,7 +66,7 @@ class GrOptDrawState;
  * added to the vertex attribute array specified on the GrDrawState.
  * GrGeometryProcessor subclasses should be immutable after construction.
  */
-class GrGeometryProcessor : public GrProcessor {
+class GrGeometryProcessor : public GrPrimitiveProcessor {
 public:
     GrGeometryProcessor(GrColor color, uint8_t coverage = 0xff)
         : fVertexStride(0)
@@ -111,11 +128,13 @@ public:
             return false;
         }
 
-        if (!fHasVertexColor && this->getColor() != that.getColor()) {
+        if (!fHasVertexColor && this->color() != that.color()) {
             return false;
         }
 
-        if (!fHasVertexCoverage && this->getCoverage() != that.getCoverage()) {
+        // TODO this is fragile, most gps set their coverage to 0xff so this is okay.  In the long
+        // term this should move to subclasses which set explicit coverage
+        if (!fHasVertexCoverage && this->coverage() != that.coverage()) {
             return false;
         }
         return this->onIsEqual(that);
@@ -130,8 +149,8 @@ public:
 
     virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const {}
 
-    GrColor getColor() const { return fColor; }
-    uint8_t getCoverage() const { return fCoverage; }
+    GrColor color() const { return fColor; }
+    uint8_t coverage() const { return fCoverage; }
 
     // TODO this is a total hack until the gp can own whether or not it uses uniform
     // color / coverage
@@ -139,7 +158,8 @@ public:
     bool hasVertexCoverage() const { return fHasVertexCoverage; }
     bool hasLocalCoords() const { return fHasLocalCoords; }
 
-    void computeInvariantColor(GrInvariantOutput* inout) const;
+    void getOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
+    void getOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
 
 protected:
     /**
@@ -160,6 +180,9 @@ protected:
     void setHasVertexCoverage() { fHasVertexCoverage = true; }
     void setHasLocalCoords() { fHasLocalCoords = true; }
 
+    virtual void onGetOutputColor(GrInitInvariantOutput*) const {}
+    virtual void onGetOutputCoverage(GrInitInvariantOutput*) const = 0;
+
 private:
     virtual bool onIsEqual(const GrGeometryProcessor&) const = 0;
 
@@ -174,4 +197,26 @@ private:
 
     typedef GrProcessor INHERITED;
 };
+
+/*
+ * The path equivalent of the GP.  For now this just manages color. In the long term we plan on
+ * extending this class to handle all nvpr uniform / varying / program work.
+ */
+class GrPathProcessor : public GrPrimitiveProcessor {
+public:
+    static GrPathProcessor* Create(GrColor color) {
+        return SkNEW_ARGS(GrPathProcessor, (color));
+    }
+
+    const char* name() SK_OVERRIDE const { return "PathProcessor"; }
+    uint8_t coverage() SK_OVERRIDE const { return 0xff; }
+    void getOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
+    void getOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
+
+private:
+    GrPathProcessor(GrColor color) : fColor(color) {}
+    GrColor fColor;
+
+    typedef GrProcessor INHERITED;
+};
 #endif