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;

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

Maybe these just shouldn't be const if this field needs to me mutable.

 };
 
 class GrGLCaps;
 class GrGLGeometryProcessor;
 class GrOptDrawState;
 
 struct GrInitInvariantOutput;
 
 /*
  * GrGeometryProcessors and GrPathProcessors may effect invariantColor
@@ skipping 16 matching lines @@
  * 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.
  */
 class GrGeometryProcessor : public GrPrimitiveProcessor {
 public:
     GrGeometryProcessor(GrColor color, uint8_t coverage = 0xff)
-        : fVertexStride(0)
+        : /*TODO HACK*/fNewStyle(false), fVertexStride(0)
         , fColor(color)
         , fCoverage(coverage)
         , fWillUseGeoShader(false)
         , fHasVertexColor(false)
         , fHasVertexCoverage(false)
         , fHasLocalCoords(false) {}
 
     virtual const char* name() const = 0;
 
     /**
@@ skipping 53 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
+     */
     struct InitBT {
         bool fOutputColor;
         bool fOutputCoverage;
+        bool fRemoveColorAttr;
+        bool fRemoveCoverageAttr;
         GrColor fColor;
         GrColor fCoverage;
     };
 
     virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const {}
 
+    // TODO this call is temporary.  Once we have deferred geometry, GPs can always make themselves

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

can/should we fold this into isEqual, that is replace isEqual with a canBatch
that checks for classID equality and then calls a virtual?

+    // equal
+    virtual bool canBatch(const GrBatchTracker&, const GrBatchTracker&) const { SkFAIL("s"); return false; }
+    
     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 getOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
     void getOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
+    // TODO hack
+    bool fNewStyle;

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

I know it's a hack but can you formalize this a little bit beyond a public data
member (clearer name, protected member, public getter, comment that'd make sense
to someone else)

 
 protected:
+    enum Output {
+        kAllOnes_Output,
+        kAttribute_Output,
+        kUniform_Output,
+    };
+
+    static Output GetColorOutputType(const InitBT& init, bool hasVertexColor) {
+        bool hasUniformColor = (init.fOutputColor && !hasVertexColor) || init.fRemoveColorAttr;
+        if (!init.fOutputColor) {
+            return kAllOnes_Output;
+        } else if (hasUniformColor) {
+            return kUniform_Output;
+        } else {
+            SkASSERT(hasVertexColor);
+            return kAttribute_Output;
+        }
+    }
+
     /**
      * 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 38 matching lines @@
     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