GrBatchPrototype

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"
 
 /*
  * The GrPrimitiveProcessor represents some kind of geometric primitive.  This includes the shape
  * of the primitive and the inherent color of the primitive.  The GrPrimitiveProcessor is
  * responsible for providing a color and coverage input into the Ganesh rendering pipeline.  Through
  * optimization, Ganesh may decide a different color, no color, and / or no coverage are required
  * from the GrPrimitiveProcessor, so the GrPrimitiveProcessor must be able to support this
  * functionality.  We also use the GrPrimitiveProcessor to make batching decisions.
@@ skipping 16 matching lines @@
  * it draws.  Each primitive draw will bundle all required data to perform the draw, and these
  * bundles of data will be owned by an instance of the associated GrPrimitiveProcessor.  Bundles
  * can be updated alongside the GrBatchTracker struct itself, ultimately allowing the
  * GrPrimitiveProcessor complete control of how it gets data into the fragment shader as long as
  * it emits the appropriate color, or none at all, as directed.
  */
 
 /*
  * A struct for tracking batching decisions.  While this lives on GrOptState, it is managed
  * entirely by the derived classes of the GP.
+ * // TODO this was an early attempt at handling out of order batching.  It should be
+ * used carefully as it is being replaced by GrBatch
  */
 class GrBatchTracker {
 public:
     template <typename T> const T& cast() const {
         SkASSERT(sizeof(T) <= kMaxSize);
         return *reinterpret_cast<const T*>(fData.get());
     }
 
     template <typename T> T* cast() {
         SkASSERT(sizeof(T) <= kMaxSize);
         return reinterpret_cast<T*>(fData.get());
     }
 
     static const size_t kMaxSize = 32;
 
 private:
     SkAlignedSStorage<kMaxSize> fData;
 };
 
+class GrIndexBufferAllocPool;
 class GrGLCaps;
 class GrGLPrimitiveProcessor;
-class GrOptDrawState;
+class GrVertexBufferAllocPool;
 
 struct GrInitInvariantOutput;
 
+/*
+ * This struct allows the GrPipeline to communicate information about the pipeline.  Most of this
+ * is overrides, but some of it is general information.  Logically it should live in GrPipeline.h,
+ * but this is problematic due to circular dependencies.
+ */
+struct GrPipelineInfo {
+    bool fColorIgnored;
+    bool fCoverageIgnored;
+    GrColor fOverrideColor;
+    bool fUsesLocalCoords;
+};
 
 /*
  * This enum is shared by GrPrimitiveProcessors and GrGLPrimitiveProcessors to coordinate shaders
  * with vertex attributes / uniforms.
  */
 enum GrGPInput {
     kAllOnes_GrGPInput,
     kAttribute_GrGPInput,
     kUniform_GrGPInput,
     kIgnored_GrGPInput,
 };
 
 /*
  * GrPrimitiveProcessor defines an interface which all subclasses must implement.  All
  * GrPrimitiveProcessors must proivide seed color and coverage for the Ganesh color / coverage
  * pipelines, and they must provide some notion of equality
  */
 class GrPrimitiveProcessor : public GrProcessor {
 public:
     // TODO let the PrimProc itself set this in its setData call, this should really live on the
     // bundle of primitive data
     const SkMatrix& viewMatrix() const { return fViewMatrix; }
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
 
-    /*
-     * This struct allows the optstate to communicate requirements to the GrPrimitiveProcessor.
-     */
-    struct InitBT {
-        bool fColorIgnored;
-        bool fCoverageIgnored;
-        GrColor fOverrideColor;
-        bool fUsesLocalCoords;
-    };
-
-    virtual void initBatchTracker(GrBatchTracker*, const InitBT&) const = 0;
+    virtual void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const = 0;
 
     virtual bool canMakeEqual(const GrBatchTracker& mine,
                               const GrPrimitiveProcessor& that,
                               const GrBatchTracker& theirs) const = 0;
 
     virtual void getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
     virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
 
     // Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but
     // we put these calls on the base class to prevent having to cast
@@ skipping 178 matching lines @@
     /*
      * An optional simple helper function to determine by what means the GrGeometryProcessor should
      * use to provide color.  If we are given an override color(ie the given overridecolor is NOT
      * GrColor_ILLEGAL) then we must always emit that color(currently overrides are only supported
      * via uniform, but with deferred Geometry we could use attributes).  Otherwise, if our color is
      * ignored then we should not emit a color.  Lastly, if we don't have vertex colors then we must
      * emit a color via uniform
      * TODO this function changes quite a bit with deferred geometry.  There the GrGeometryProcessor
      * can upload a new color via attribute if needed.
      */
-    static GrGPInput GetColorInputType(GrColor* color, GrColor primitiveColor, const InitBT& init,
+    static GrGPInput GetColorInputType(GrColor* color, GrColor primitiveColor,
+                                       const GrPipelineInfo& init,
                                        bool hasVertexColor) {
         if (init.fColorIgnored) {
             *color = GrColor_ILLEGAL;
             return kIgnored_GrGPInput;
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             *color = init.fOverrideColor;
             return kUniform_GrGPInput;
         }
 
         *color = primitiveColor;
@@ skipping 53 matching lines @@
  * extending this class to handle all nvpr uniform / varying / program work.
  */
 class GrPathProcessor : public GrPrimitiveProcessor {
 public:
     static GrPathProcessor* Create(GrColor color,
                                    const SkMatrix& viewMatrix = SkMatrix::I(),
                                    const SkMatrix& localMatrix = SkMatrix::I()) {
         return SkNEW_ARGS(GrPathProcessor, (color, viewMatrix, localMatrix));
     }
     
-    void initBatchTracker(GrBatchTracker*, const InitBT&) const SK_OVERRIDE;
+    void initBatchTracker(GrBatchTracker*, const GrPipelineInfo&) const SK_OVERRIDE;
 
     bool canMakeEqual(const GrBatchTracker& mine,
                       const GrPrimitiveProcessor& that,
                       const GrBatchTracker& theirs) const SK_OVERRIDE;
 
     const char* name() const SK_OVERRIDE { return "PathProcessor"; }
 
     GrColor color() const { return fColor; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
@@ skipping 13 matching lines @@
 
 private:
     bool hasExplicitLocalCoords() const SK_OVERRIDE { return false; }
 
     GrColor fColor;
 
     typedef GrPrimitiveProcessor INHERITED;
 };
 
 #endif