GrBatchPrototype

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
 #include "GrClipData.h"
 #include "GrClipMaskManager.h"
 #include "GrContext.h"
 #include "GrDrawState.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
 #include "GrTraceMarker.h"
 #include "GrVertexBuffer.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
+class GrBatch;
 class GrClipData;
 class GrDrawTargetCaps;
 class GrPath;
 class GrPathRange;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
     typedef GrPathRange::PathIndexType PathIndexType;
@@ skipping 213 matching lines @@
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
     void drawNonIndexed(GrDrawState*,
                         const GrGeometryProcessor*,
                         GrPrimitiveType type,
                         int startVertex,
                         int vertexCount,
                         const SkRect* devBounds = NULL);
 
+    void batchDraw(GrDrawState*,

[bsalomon, 2015/01/21 21:39:29]

drawBatch? Just seems more consistent

+                   GrBatch*,
+                   GrPrimitiveType,
+                   const SkRect* devBounds = NULL);
+
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the draw state (if possible in the 3D API).  Note, we will never have an inverse fill
      * with stencil path
      */
     void stencilPath(GrDrawState*, const GrPathProcessor*, const GrPath*,GrPathRendering::FillType);
 
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
@@ skipping 245 matching lines @@
                                   // so that should be okay
     };
 
     virtual DrawToken getCurrentDrawToken() { return DrawToken(this, 0); }
 
     /**
      * Used to communicate draws to GPUs / subclasses
      */
     class DrawInfo {
     public:
+        DrawInfo() { fDevBounds = NULL; }
         DrawInfo(const DrawInfo& di) { (*this) = di; }
         DrawInfo& operator =(const DrawInfo& di);
 
         GrPrimitiveType primitiveType() const { return fPrimitiveType; }
         int startVertex() const { return fStartVertex; }
         int startIndex() const { return fStartIndex; }
         int vertexCount() const { return fVertexCount; }
         int indexCount() const { return fIndexCount; }
         int verticesPerInstance() const { return fVerticesPerInstance; }
         int indicesPerInstance() const { return fIndicesPerInstance; }
         int instanceCount() const { return fInstanceCount; }
 
+        void setPrimitiveType(GrPrimitiveType type) { fPrimitiveType = type; }
+        void setStartVertex(int startVertex) { fStartVertex = startVertex; }
+        void setStartIndex(int startIndex) { fStartIndex = startIndex; }
+        void setVertexCount(int vertexCount) { fVertexCount = vertexCount; }
+        void setIndexCount(int indexCount) { fIndexCount = indexCount; }
+        void setVerticesPerInstance(int verticesPerI) { fVerticesPerInstance = verticesPerI; }
+        void setIndicesPerInstance(int indicesPerI) { fIndicesPerInstance = indicesPerI; }
+        void setInstanceCount(int instanceCount) { fInstanceCount = instanceCount; }
+
         bool isIndexed() const { return fIndexCount > 0; }
 #ifdef SK_DEBUG
         bool isInstanced() const; // this version is longer because of asserts
 #else
         bool isInstanced() const { return fInstanceCount > 0; }
 #endif
 
         // adds or remove instances
         void adjustInstanceCount(int instanceOffset);
         // shifts the start vertex
         void adjustStartVertex(int vertexOffset);
         // shifts the start index
         void adjustStartIndex(int indexOffset);
 
         void setDevBounds(const SkRect& bounds) {
             fDevBoundsStorage = bounds;
             fDevBounds = &fDevBoundsStorage;
         }
         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
         void setVertexBuffer(const GrVertexBuffer* vb) {
             fVertexBuffer.reset(vb);
         }
         void setIndexBuffer(const GrIndexBuffer* ib) {
             fIndexBuffer.reset(ib);
         }
         const SkRect* getDevBounds() const { return fDevBounds; }
 
     private:
-        DrawInfo() { fDevBounds = NULL; }
-
         friend class GrDrawTarget;
 
         GrPrimitiveType         fPrimitiveType;
 
         int                     fStartVertex;
         int                     fStartIndex;
         int                     fVertexCount;
         int                     fIndexCount;
 
         int                     fInstanceCount;
@@ skipping 118 matching lines @@
     virtual void releaseReservedIndexSpace() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
     virtual void onDraw(const GrDrawState&,
                         const GrGeometryProcessor*,
                         const DrawInfo&,
                         const GrScissorState&,
                         const GrDeviceCoordTexture* dstCopy) = 0;
+    virtual void onBatchDraw(GrBatch*,
+                             const GrDrawState&,
+                             GrPrimitiveType type,
+                             const GrScissorState&,
+                             const GrDeviceCoordTexture* dstCopy) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
     virtual void onDrawRect(GrDrawState*,
                             GrColor color,
                             const SkMatrix& viewMatrix,
                             const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
     virtual void onStencilPath(const GrDrawState&,
                                const GrPathProcessor*,
@@ skipping 133 matching lines @@
     virtual bool setupClip(GrDrawState*,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif