GrBatchPrototype

src/gpu/GrBatchBuffer.h

Index: src/gpu/GrBatchBuffer.h
diff --git a/src/gpu/GrBatchBuffer.h b/src/gpu/GrBatchBuffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..490b39a4cc218298ff9e00ef6cee688e2ed0b18d
--- /dev/null
+++ b/src/gpu/GrBatchBuffer.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBatchBuffer_DEFINED
+#define GrBatchBuffer_DEFINED
+
+#include "GrPendingProgramElement.h"
+#include "GrGpu.h"
+#include "GrTRecorder.h"
+
+/*
+ * GrBatchBuffer is a simple class which lets GrDrawTarget subclasses defer flushing of batched

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

I'm not crazy about this name

GrBatchTarget?

Probably more useful to explain in terms of how it interacts with GrBatch rather
than GrDT.

"GrBatch instances use this object to allocate space for their geometry and to
issue the draws that render their batch."?

+ * Geometry for performance reasons.
+ */
+
+class GrBatchBuffer : public SkNoncopyable {
+public:
+    GrBatchBuffer(GrGpu* gpu,
+                  GrVertexBufferAllocPool* vpool,
+                  GrIndexBufferAllocPool* ipool)
+        : fGpu(gpu)
+        , fVertexPool(vpool)
+        , fIndexPool(ipool)
+        , fFlushBuffer(kFlushBufferInitialSizeInBytes) {}
+
+    typedef GrDrawTarget::DrawInfo DrawInfo;
+    void initDraw(const GrPrimitiveProcessor* primProc, const GrOptDrawState* optState) {
+        GrNEW_APPEND_TO_RECORDER(fFlushBuffer, BufferedFlush, (primProc, optState));
+    }
+
+    void draw(const GrDrawTarget::DrawInfo& draw) {
+        fFlushBuffer.back().fDraws.push_back(draw);
+    }
+    void flush();
+
+    // TODO This goes away when everything uses batch
+    GrBatchTracker* currentBatchTracker() {
+        SkASSERT(!fFlushBuffer.empty());
+        return &fFlushBuffer.back().fBatchTracker;
+    }
+
+    GrVertexBufferAllocPool* vertexPool() { return fVertexPool; }
+    GrIndexBufferAllocPool* indexPool() { return fIndexPool; }
+
+private:
+    GrGpu* fGpu;
+    GrVertexBufferAllocPool* fVertexPool;
+    GrIndexBufferAllocPool* fIndexPool;
+
+    typedef void* TBufferAlign; // This wouldn't be enough align if a command used long double.
+
+    struct BufferedFlush {
+        BufferedFlush(const GrPrimitiveProcessor* primProc, const GrOptDrawState* optState)
+            : fPrimitiveProcessor(primProc)
+            , fOptState(optState)
+            , fDraws(kDrawRecorderInitialSizeInBytes) {}
+        typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
+        ProgramPrimitiveProcessor fPrimitiveProcessor;
+        const GrOptDrawState* fOptState;
+        GrBatchTracker fBatchTracker;
+        SkSTArray<4, DrawInfo, true> fDraws;
+    };
+
+    enum {
+        kFlushBufferInitialSizeInBytes = 8 * sizeof(BufferedFlush),
+        kDrawRecorderInitialSizeInBytes = 8 * sizeof(DrawInfo),
+    };
+
+    typedef GrTRecorder<BufferedFlush, TBufferAlign> FlushBuffer;
+
+    FlushBuffer fFlushBuffer;
+};
+
+#endif