GrBatchPrototype

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 248 matching lines @@
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
         draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info));
     }
     this->recordTraceMarkersIfNecessary();
 }
 
+void GrInOrderDrawBuffer::onBatchDraw(GrBatch* batch,
+                                      const GrDrawState& ds,
+                                      GrPrimitiveType type,
+                                      const GrScissorState& scissorState,
+                                      const GrDeviceCoordTexture* dstCopy) {
+    if (!this->recordStateAndShouldDraw(batch, ds, GrGpu::PrimTypeToDrawType(type), scissorState,
+                                        dstCopy)) {
+        return;
+    }
+
+    // Check if there is a Batch Draw we can batch with
+    if (kBatchDraw != strip_trace_bit(fCmdBuffer.back().fType)) {
+        GrNEW_APPEND_TO_RECORDER(fCmdBuffer, BatchDraw, (batch));
+        return;
+    }
+
+    BatchDraw* draw = static_cast<BatchDraw*>(&fCmdBuffer.back());
+    if (draw->fBatch->canMakeEqual(*batch)) {

[bsalomon, 2015/01/20 16:14:03]

probably want to rename these... canMerge? canCombine? Also, should the query
and merger happen in one function? i.e. bool combineIfPossible(*batch).

+        draw->fBatch->makeEqual(batch);
+        return;
+    } else {
+        GrNEW_APPEND_TO_RECORDER(fCmdBuffer, BatchDraw, (batch));
+    }
+    this->recordTraceMarkersIfNecessary();
+}
+
 void GrInOrderDrawBuffer::onStencilPath(const GrDrawState& ds,
                                         const GrPathProcessor* pathProc,
                                         const GrPath* path,
                                         const GrScissorState& scissorState,
                                         const GrStencilSettings& stencilSettings) {
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath,
                                                (path, ds.getRenderTarget()));
     sp->fScissor = scissorState;
     sp->fUseHWAA = ds.isHWAntialias();
     sp->fViewMatrix = pathProc->viewMatrix();
@@ skipping 148 matching lines @@
         if (cmd_has_trace_marker(iter->fType)) {
             traceString = fGpuCmdMarkers[currCmdMarker].toString();
             newMarker.fMarker = traceString.c_str();
             this->getGpu()->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
 
         if (kSetState_Cmd == strip_trace_bit(iter->fType)) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
             currentOptState = &ss->fState;
-            currentOptState->finalize(this->getGpu());
+            // Batch draws will finalize later.  TODO remove this when we use batch everywhere
+            if (currentOptState->getPrimitiveProcessor()) {
+                currentOptState->finalize(this->getGpu());
+            }
         } else {
             iter->execute(this, currentOptState);
         }
 
         if (cmd_has_trace_marker(iter->fType)) {
             this->getGpu()->removeGpuTraceMarker(&newMarker);
         }
     }
 
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
@@ skipping 24 matching lines @@
 
 void GrInOrderDrawBuffer::DrawPaths::execute(GrInOrderDrawBuffer* buf,
                                              const GrOptDrawState* optState) {
     SkASSERT(optState);
     buf->getGpu()->drawPaths(*optState, this->pathRange(),
                             &buf->fPathIndexBuffer[fIndicesLocation], fIndexType,
                             &buf->fPathTransformBuffer[fTransformsLocation], fTransformType,
                             fCount, fStencilSettings);
 }
 
+void GrInOrderDrawBuffer::BatchDraw::execute(GrInOrderDrawBuffer* buf,
+                                             const GrOptDrawState* optState) {
+    SkASSERT(optState);
+    fBatch->generateGeometry(buf->getGpu(), buf->getVertexAllocPool(), buf->getIndexAllocPool(),
+                             const_cast<GrOptDrawState*>(optState));
+    fBatch->draw(buf->getGpu(), const_cast<GrOptDrawState*>(optState));
+}
+
 void GrInOrderDrawBuffer::SetState::execute(GrInOrderDrawBuffer*, const GrOptDrawState*) {}
 
 void GrInOrderDrawBuffer::Clear::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState*) {
     if (GrColor_ILLEGAL == fColor) {
         buf->getGpu()->discard(this->renderTarget());
     } else {
         buf->getGpu()->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
@@ skipping 21 matching lines @@
 }
 
 bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds,
                                                    const GrPrimitiveProcessor* primProc,
                                                    GrGpu::DrawType drawType,
                                                    const GrScissorState& scissor,
                                                    const GrDeviceCoordTexture* dstCopy) {
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
                                             (ds, primProc, *this->getGpu()->caps(), scissor,
                                              dstCopy, drawType));
+    return recordStateAndShouldDraw(ss);
+}
+
+bool GrInOrderDrawBuffer::recordStateAndShouldDraw(GrBatch* batch,
+                                                   const GrDrawState& ds,
+                                                   GrGpu::DrawType drawType,
+                                                   const GrScissorState& scissor,
+                                                   const GrDeviceCoordTexture* dstCopy) {
+    // TODO this gets much simpler when we have batches everywhere.
+    // If the previous command is also a set state, then we check to see if it has a Batch.  If so,
+    // and we can make the two batches equal, and we can combine the states, then we make them equal
+    SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
+                                            (batch, ds, *this->getGpu()->caps(), scissor,
+                                             dstCopy, drawType));
+    return recordStateAndShouldDraw(ss);
+}
+
+bool GrInOrderDrawBuffer::recordStateAndShouldDraw(SetState* ss) {
     if (ss->fState.mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
     if (fPrevState && fPrevState->combineIfPossible(ss->fState)) {
         fCmdBuffer.pop_back();
     } else {
         fPrevState = &ss->fState;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }