Create GrOptDrawState before recording draw in GrInOrderDrawBuffer

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"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
-#include "GrOptDrawState.h"
 #include "GrTemplates.h"
 #include "GrTextStrike.h"
 #include "GrTexture.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrGpu* gpu,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
     : INHERITED(gpu->getContext())
     , fCmdBuffer(kCmdBufferInitialSizeInBytes)
     , fLastState(NULL)
@@ skipping 230 matching lines @@
     }
 
     return instancesToConcat;
 }
 
 void GrInOrderDrawBuffer::onDraw(const GrDrawState& ds,
                                  const DrawInfo& info,
                                  const GrClipMaskManager::ScissorState& scissorState) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
 
-    this->recordStateIfNecessary(ds,
-                                 GrGpu::PrimTypeToDrawType(info.primitiveType()),
-                                 info.getDstCopy());
+    if (!this->recordStateAndShouldDraw(ds,
+                                       GrGpu::PrimTypeToDrawType(info.primitiveType()),

[egdaniel, 2014/11/19 15:00:36]

align

[bsalomon, 2014/11/19 15:09:38]

Done.

+                                       info.getDstCopy())) {
+        return;
+    }
 
     const GrVertexBuffer* vb;
     if (kBuffer_GeometrySrcType == this->getGeomSrc().fVertexSrc) {
         vb = this->getGeomSrc().fVertexBuffer;
     } else {
         vb = poolState.fPoolVertexBuffer;
     }
 
     const GrIndexBuffer* ib = NULL;
     if (info.isIndexed()) {
@@ skipping 31 matching lines @@
         poolState.fUsedPoolIndexBytes = SkTMax(poolState.fUsedPoolIndexBytes, bytes);
         draw->fInfo.adjustStartIndex(poolState.fPoolStartIndex);
     }
 }
 
 void GrInOrderDrawBuffer::onStencilPath(const GrDrawState& ds,
                                         const GrPath* path,
                                         const GrClipMaskManager::ScissorState& scissorState,
                                         const GrStencilSettings& stencilSettings) {
     // Only compare the subset of GrDrawState relevant to path stenciling?
-    this->recordStateIfNecessary(ds, GrGpu::kStencilPath_DrawType, NULL);
+    if (!this->recordStateAndShouldDraw(ds, GrGpu::kStencilPath_DrawType, NULL)) {
+        return;
+    }
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath, (path));
     sp->fScissorState = scissorState;
     sp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPath(const GrDrawState& ds,
                                      const GrPath* path,
                                      const GrClipMaskManager::ScissorState& scissorState,
                                      const GrStencilSettings& stencilSettings,
                                      const GrDeviceCoordTexture* dstCopy) {
     // TODO: Only compare the subset of GrDrawState relevant to path covering?
-    this->recordStateIfNecessary(ds, GrGpu::kDrawPath_DrawType, dstCopy);
+    if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, dstCopy)) {
+        return;
+    }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     if (dstCopy) {
         dp->fDstCopy = *dstCopy;
     }
     dp->fScissorState = scissorState;
     dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds,
                                       const GrPathRange* pathRange,
                                       const uint32_t indices[],
                                       int count,
                                       const float transforms[],
                                       PathTransformType transformsType,
                                       const GrClipMaskManager::ScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
                                       const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transforms);
 
-    this->recordStateIfNecessary(ds, GrGpu::kDrawPaths_DrawType, dstCopy);
+    if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, dstCopy)) {
+        return;
+    }
 
     uint32_t* savedIndices = fPathIndexBuffer.append(count, indices);
     float* savedTransforms = fPathTransformBuffer.append(count *
                                  GrPathRendering::PathTransformSize(transformsType), transforms);
 
     if (kDrawPaths_Cmd == strip_trace_bit(fCmdBuffer.back().fType)) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stencilling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
@@ skipping 65 matching lines @@
     clr->fColor = GrColor_ILLEGAL;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
 
     fCmdBuffer.reset();
-    fLastState = NULL;
+    fLastState.reset(NULL);
     fVertexPool.reset();
     fIndexPool.reset();
     reset_data_buffer(&fPathIndexBuffer, kPathIdxBufferMinReserve);
     reset_data_buffer(&fPathTransformBuffer, kPathXformBufferMinReserve);
     fGpuCmdMarkers.reset();
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
@@ skipping 12 matching lines @@
     fFlushing = true;
 
     fVertexPool.unmap();
     fIndexPool.unmap();
 
     CmdBuffer::Iter iter(fCmdBuffer);
 
     int currCmdMarker = 0;
     fDstGpu->saveActiveTraceMarkers();
 
-    // Gpu no longer maintains the current drawstate, so we track the setstate calls below.
-    // NOTE: we always record a new drawstate at flush boundaries
+    // Updated every time we find a set state cmd to reflect the current state in the playback
+    // stream.
     SkAutoTUnref<const GrOptDrawState> currentOptState;
 
     while (iter.next()) {
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
         if (cmd_has_trace_marker(iter->fType)) {
             traceString = fGpuCmdMarkers[currCmdMarker].toString();
             newMarker.fMarker = traceString.c_str();
             fDstGpu->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
 
         if (kSetState_Cmd == strip_trace_bit(iter->fType)) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
-            currentOptState.reset(GrOptDrawState::Create(ss->fState,
-                                                         fDstGpu,
-                                                         &ss->fDstCopy,
-                                                         ss->fDrawType));
+            currentOptState.reset(SkRef(ss->fState.get()));
         } else {
             iter->execute(this, currentOptState.get());
         }
 
         if (cmd_has_trace_marker(iter->fType)) {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
 
     fDstGpu->restoreActiveTraceMarkers();
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     this->reset();
     ++fDrawID;
 }
 
 void GrInOrderDrawBuffer::Draw::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState* optState) {
     if (!optState) {
         return;
     }

[joshualitt, 2014/11/19 14:55:35]

Are these checks still necessary?

[bsalomon, 2014/11/19 15:04:43]

oh nice, catch. No, they're not.

     GrGpu* dstGpu = buf->fDstGpu;
     dstGpu->setVertexSourceToBuffer(this->vertexBuffer(), optState->getVertexStride());
     if (fInfo.isIndexed()) {
         dstGpu->setIndexSourceToBuffer(this->indexBuffer());
     }
     dstGpu->draw(*optState, fInfo, fScissorState);
 }
 
 void GrInOrderDrawBuffer::StencilPath::execute(GrInOrderDrawBuffer* buf,
                                                const GrOptDrawState* optState) {
@@ skipping 216 matching lines @@
     // is now unreleasable because data may have been appended later in the
     // pool.
     if (kReserved_GeometrySrcType == restoredState.fVertexSrc) {
         poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) * restoredState.fIndexCount;
     }
 }
 
-void GrInOrderDrawBuffer::recordStateIfNecessary(const GrDrawState& ds,
-                                                 GrGpu::DrawType drawType,
-                                                 const GrDeviceCoordTexture* dstCopy) {
-    if (!fLastState) {
-        SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (ds));
-        fLastState = &ss->fState;
+bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds,
+                                                   GrGpu::DrawType drawType,
+                                                   const GrDeviceCoordTexture* dstCopy) {
+    SkAutoTUnref<GrOptDrawState> optState(GrOptDrawState::Create(ds, fDstGpu, dstCopy, drawType));
+    if (!optState) {
+        return false;
+    }
+    if (!fLastState || *optState != *fLastState) {
+        SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (optState));
+        fLastState.reset(SkRef(optState.get()));
         if (dstCopy) {
             ss->fDstCopy = *dstCopy;
         }
         ss->fDrawType = drawType;
-        this->convertDrawStateToPendingExec(fLastState);
         this->recordTraceMarkersIfNecessary();
-        return;
     }
-    switch (GrDrawState::CombineIfPossible(*fLastState, ds, *this->caps())) {
-        case GrDrawState::kIncompatible_CombinedState: {
-            SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (ds));
-            fLastState = &ss->fState;
-            if (dstCopy) {
-                ss->fDstCopy = *dstCopy;
-            }
-            ss->fDrawType = drawType;
-            this->convertDrawStateToPendingExec(fLastState);
-            this->recordTraceMarkersIfNecessary();
-            break;
-        }
-        case GrDrawState::kA_CombinedState:
-        case GrDrawState::kAOrB_CombinedState: // Treat the same as kA.
-            break;
-        case GrDrawState::kB_CombinedState:
-            // prev has already been converted to pending execution. That is a one-way ticket.
-            // So here we just destruct the previous state and reinit with a new copy of curr.
-            // Note that this goes away when we move GrIODB over to taking optimized snapshots
-            // of draw states.
-            fLastState->~GrDrawState();
-            SkNEW_PLACEMENT_ARGS(fLastState, GrDrawState, (ds));
-            this->convertDrawStateToPendingExec(fLastState);
-            break;
-    }
+    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);
     }
 }