drawinfo carries bufferinfo

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 "GrBufferAllocPool.h"
@@ skipping 201 matching lines @@
         return 0;
     }
 
     Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GrVertexBuffer* vertexBuffer = poolState.fPoolVertexBuffer;
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
-        draw->vertexBuffer() != vertexBuffer ||
-        draw->indexBuffer() != geomSrc.fIndexBuffer ||
+        draw->fInfo.vertexBuffer() != vertexBuffer ||
+        draw->fInfo.indexBuffer() != geomSrc.fIndexBuffer ||
         draw->fScissorState != scissorState) {
         return 0;
     }
     // info does not yet account for the offset from the start of the pool's VB while the previous
     // draw record does.
     int adjustedStartVertex = poolState.fPoolStartVertex + info.startVertex();
     if (draw->fInfo.startVertex() + draw->fInfo.vertexCount() != adjustedStartVertex) {
         return 0;
     }
 
@@ skipping 19 matching lines @@
             draw->fType = add_trace_bit(draw->fType);
         }
     }
 
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrDrawState& ds,
                                  const DrawInfo& info,
                                  const GrClipMaskManager::ScissorState& scissorState) {
+    SkASSERT(info.vertexBuffer() && (!info.isIndexed() || info.indexBuffer()));
+
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
 
     this->recordStateIfNecessary(ds,
                                  GrGpu::PrimTypeToDrawType(info.primitiveType()),
                                  info.getDstCopy());
 
-    const GrVertexBuffer* vb;
-    if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
-        vb = this->getGeomSrc().fVertexBuffer;
-    } else {
-        vb = poolState.fPoolVertexBuffer;
-    }
-
-    const GrIndexBuffer* ib = NULL;
-    if (info.isIndexed()) {
-        if (kBuffer_GeometrySrcType == this->getGeomSrc().fIndexSrc) {
-            ib = this->getGeomSrc().fIndexBuffer;
-        } else {
-            ib = poolState.fPoolIndexBuffer;
-        }
-    }
-
     Draw* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(ds, info, scissorState);
         if (info.instanceCount() > instancesConcated) {
-            draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState, vb, ib));
+            draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState));
             draw->fInfo.adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
-        draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState, vb, ib));
+        draw = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Draw, (info, scissorState));
     }
     this->recordTraceMarkersIfNecessary();
 
     // Adjust the starting vertex and index when we are using reserved or array sources to
     // compensate for the fact that the data was inserted into a larger vb/ib owned by the pool.
     if (kBuffer_GeometrySrcType != this->getGeomSrc().fVertexSrc) {
         size_t bytes = (info.vertexCount() + info.startVertex()) * ds.getVertexStride();
         poolState.fUsedPoolVertexBytes = SkTMax(poolState.fUsedPoolVertexBytes, bytes);
         draw->fInfo.adjustStartVertex(poolState.fPoolStartVertex);
     }
@@ skipping 119 matching lines @@
 void GrInOrderDrawBuffer::discard(GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     if (!this->caps()->discardRenderTargetSupport()) {
         return;
     }
     Clear* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Clear, (renderTarget));
     clr->fColor = GrColor_ILLEGAL;
     this->recordTraceMarkersIfNecessary();
 }
 
+void GrInOrderDrawBuffer::setDrawBuffers(DrawInfo* info) {
+    GeometryPoolState& poolState = fGeoPoolStateStack.back();
+    if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
+        info->setVertexBuffer(this->getGeomSrc().fVertexBuffer);
+    } else {
+        info->setVertexBuffer(poolState.fPoolVertexBuffer);
+    }
+
+    if (info->isIndexed()) {
+        if (kBuffer_GeometrySrcType == this->getGeomSrc().fIndexSrc) {
+            info->setIndexBuffer(this->getGeomSrc().fIndexBuffer);
+        } else {
+            info->setIndexBuffer(poolState.fPoolIndexBuffer);
+        }
+    }
+}
+
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
 
     fCmdBuffer.reset();
     fLastState = NULL;
     fVertexPool.reset();
     fIndexPool.reset();
     reset_data_buffer(&fPathIndexBuffer, kPathIdxBufferMinReserve);
@@ skipping 59 matching lines @@
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     this->reset();
     ++fDrawID;
 }
 
 void GrInOrderDrawBuffer::Draw::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState* optState) {
     if (!optState) {
         return;
     }
-    GrGpu* dstGpu = buf->fDstGpu;
-    dstGpu->setVertexSourceToBuffer(this->vertexBuffer(), optState->getVertexStride());
-    if (fInfo.isIndexed()) {
-        dstGpu->setIndexSourceToBuffer(this->indexBuffer());
-    }
-    dstGpu->draw(*optState, fInfo, fScissorState);
+    buf->fDstGpu->draw(*optState, fInfo, fScissorState);
 }
 
 void GrInOrderDrawBuffer::StencilPath::execute(GrInOrderDrawBuffer* buf,
                                                const GrOptDrawState* optState) {
     if (!optState) {
         return;
     }
     buf->fDstGpu->stencilPath(*optState, this->path(), fScissorState, fStencilSettings);
 }
 
@@ skipping 260 matching lines @@
 
 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);
     }
 }