create and thread batch tracker object

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 optstate, it is managed

[bsalomon, 2014/12/03 14:58:52]

Can you make optstate be GrOptState? I've noticed that when we don't use actual
class names in our comments, we wind up with stale comments because they get
missed by search/replace.

+ * entirely by the derived classes of the GP.
+ */
+class GrBatchTracker {
+public:
+    template <typename T> const T& cast() const {
+        return *reinterpret_cast<const T*>(fStorage.begin());
+    }
+
+    template <typename T> T* cast() { return reinterpret_cast<T*>(fStorage.begin()); }
+
+private:
+    // kPreAllocSize is actually more like a maxsize.

[bsalomon, 2014/12/03 14:38:19]

huh?

[bsalomon, 2014/12/03 14:58:52]

If it's a max size and it's preallocated then SkSTArray isn't the right thing.
Just stick a uint8_t fData[32] in there.

How does the client know how big this is? Seems like there should be a public
facing enum or something.

+    static const size_t kPreAllocSize = 32;
+    SkSTArray<kPreAllocSize, uint8_t, true> fStorage;
+};
+
+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.
  */
@@ skipping 41 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->getFactory() != &that.getFactory() || !this->hasSameTextureAccesses(that)) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
+    struct InitBT {

[bsalomon, 2014/12/03 14:38:19]

comments?

We're getting rid of fColor and fCoverage, right?

[bsalomon, 2014/12/03 14:58:52]

What I meant is that GrGP shouldn't have an input color and coverage and
GrOptState shouldn't have a constant color/coverage. The GP is (or should be)
output only.

+        bool fOutputColor;
+        bool fOutputCoverage;
+        GrColor fColor;
+        GrColor fCoverage;
+    };
+
+    virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const {}
+
     // 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; }
 
 protected:
     /**
      * Subclasses call this from their constructor to register vertex attributes.  Attributes
      * will be padded to the nearest 4 bytes for performance reasons.
@@ skipping 19 matching lines @@
     size_t fVertexStride;
     bool fWillUseGeoShader;
     bool fHasVertexColor;
     bool fHasVertexCoverage;
     bool fHasLocalCoords;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif