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 "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;
 
 /**
  * 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.
  */
 class GrGeometryProcessor : public GrProcessor {
 public:
     GrGeometryProcessor()
-        : fVertexStride(0)
+        : /*TODO HACK*/fNewStyle(false), fVertexStride(0)
         , fWillUseGeoShader(false)
         , fHasVertexColor(false)
         , fHasVertexCoverage(false)
         , fHasLocalCoords(false) {}
 
     virtual const char* name() const = 0;
 
     /** Implemented using GLProcessor::GenKey as described in this class's comment. */
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
@@ skipping 38 matching lines @@
         A return value of true from isEqual() should not be used to test whether the processors
         would generate the same shader code. To test for identical code generation use the
         processors' keys computed by the GrBackendEffectFactory. */
     bool isEqual(const GrGeometryProcessor& that) const {
         if (this->classID() != that.classID() || !this->hasSameTextureAccesses(that)) {
             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
+    // equal
+    virtual bool canBatch(const GrBatchTracker&, const GrBatchTracker&) const { SkFAIL("s"); return false; }
+
     // 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; }
 
+    // TODO hack
+    bool fNewStyle;
+
 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 11 matching lines @@
     SkSTArray<kMaxVertexAttribs, GrAttribute, true> fAttribs;
     size_t fVertexStride;
     bool fWillUseGeoShader;
     bool fHasVertexColor;
     bool fHasVertexCoverage;
     bool fHasLocalCoords;
 
     typedef GrProcessor INHERITED;
 };
 #endif