Draft change to start pulling uniform color into GP

src/gpu/GrGeometryProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGeometryProcessor_DEFINED
 #define GrGeometryProcessor_DEFINED
 
 #include "GrColor.h"
 #include "GrGeometryData.h"
 #include "GrProcessor.h"
 #include "GrShaderVar.h"
 
 /*
  * A struct for tracking batching decisions.  While this lives on GrOptState, it is managed
  * entirely by the derived classes of the GP.
  */
 class GrBatchTracker {
 public:
     template <typename T> const T& cast() const {
         SkASSERT(sizeof(T) <= kMaxSize);
-        return *reinterpret_cast<const T*>(fData);
+        return *reinterpret_cast<const T*>(fData.get());
     }
 
     template <typename T> T* cast() {
         SkASSERT(sizeof(T) <= kMaxSize);
-        return reinterpret_cast<T*>(fData);
+        return reinterpret_cast<T*>(fData.get());
     }
 
     static const size_t kMaxSize = 32;
 
 private:
-    uint8_t fData[kMaxSize];
+    mutable SkAlignedSStorage<kMaxSize> fData;
 };
 
 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 getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
     virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
 
 private:
     typedef GrProcessor INHERITED;
 };
 
+enum GPInput {

[bsalomon, 2014/12/12 14:29:35]

Can this be nested inside GrGP? Otherwise it needs a Gr prefix. Also needs some
dox.

+    kAllOnes_GPInput,
+    kAttribute_GPInput,
+    kUniform_GPInput,
+};
+
 /**
  * A GrGeometryProcessor is used to perform computation in the vertex shader and
  * add support for custom vertex attributes. A GrGemeotryProcessor is typically
  * tied to the code that does a specific type of high-level primitive rendering
  * (e.g. anti-aliased circle rendering). The GrGeometryProcessor used for a draw is
  * specified using GrDrawState. There can only be one geometry processor active for
  * a draw. The custom vertex attributes required by the geometry processor must be
  * added to the vertex attribute array specified on the GrDrawState.
  * GrGeometryProcessor subclasses should be immutable after construction.
  */
@@ skipping 75 matching lines @@
         }
 
         // 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);
     }
 
+    /*
+     * This struct allows the optstate to communicate requirements to the GP.
+     * TODO when the GP can encapsulate draw information in bundles, we can refactor this struct.
+     * Ultimately, when setColor and setCoverage live on the GP, this struct can be replaced with
+     * a simple override color passed into initBatchTracker

[bsalomon, 2014/12/12 14:29:35]

From discussion with Greg, I think this will become

bool fColorOutputIgnored; // the GP doesn't write a color output
GrColor fColorOverride; // respect if !fColorOutputIgnored and not
Gr_ColorINVALID.

and similar for coverage, though maybe no need for override there...

+     */
     struct InitBT {
         bool fOutputColor;
         bool fOutputCoverage;
+        bool fRemoveColorAttr;
+        bool fRemoveCoverageAttr;
         GrColor fColor;
         GrColor fCoverage;
     };
 
-    virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const {}
+    virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const = 0;
 
+    // TODO this call is temporary.  Once we have deferred geometry, GPs can always make themselves
+    // equal
+    bool canBatch(const GrBatchTracker& left, const GrBatchTracker& right) const {
+        return this->onCanBatch(left, right);
+    }
+
+    virtual bool onCanBatch(const GrBatchTracker&, const GrBatchTracker&) const = 0;
+    
     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
     bool hasVertexColor() const { return fHasVertexColor; }
     bool hasVertexCoverage() const { return fHasVertexCoverage; }
     bool hasLocalCoords() const { return fHasLocalCoords; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
 
 protected:
+    static GPInput GetColorInputType(const InitBT& init, bool hasVertexColor) {

[bsalomon, 2014/12/12 14:29:35]

Document?

+        bool hasUniformColor = (init.fOutputColor && !hasVertexColor) || init.fRemoveColorAttr;
+        if (!init.fOutputColor) {
+            return kAllOnes_GPInput;
+        } else if (hasUniformColor) {
+            return kUniform_GPInput;
+        } else {
+            SkASSERT(hasVertexColor);
+            return kAttribute_GPInput;
+        }
+    }
+
+    static bool CanCombineOutput(GPInput left, GrColor lColor, GPInput right, GrColor rColor) {

[bsalomon, 2014/12/12 14:29:35]

Document?

+        if (left != right) {
+            return false;
+        }
+
+        if (kUniform_GPInput == left && lColor != rColor) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Subclasses call this from their constructor to register vertex attributes.  Attributes
      * will be padded to the nearest 4 bytes for performance reasons.
      * TODO After deferred geometry, we should do all of this inline in GenerateGeometry alongside
      * the struct used to actually populate the attributes
      */
     const GrAttribute& addVertexAttrib(const GrAttribute& attribute) {
         fVertexStride += attribute.fOffset;
         return fAttribs.push_back(attribute);
     }
@@ skipping 39 matching lines @@
     void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
 
 private:
     GrPathProcessor(GrColor color) : fColor(color) {}
     GrColor fColor;
 
     typedef GrProcessor INHERITED;
 };
 #endif