Combine similar DrawPaths calls 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"
@@ skipping 14 matching lines @@
     , fIndexPool(*indexPool)
     , fFlushing(false)
     , fDrawID(0) {
 
     fDstGpu->ref();
     fCaps.reset(SkRef(fDstGpu->caps()));
 
     SkASSERT(vertexPool);
     SkASSERT(indexPool);
 
+    fPathIndexBuffer.setReserve(kPathIdxBufferMinReserve);
+    fPathTransformBuffer.setReserve(kPathXformBufferMinReserve);
+
     GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fUsedPoolIndexBytes = 0;
 #ifdef SK_DEBUG
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
     poolState.fPoolStartVertex = ~0;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
     poolState.fPoolStartIndex = ~0;
 #endif
     this->reset();
@@ skipping 49 matching lines @@
     if (hasLocalCoords) {
         drawState->setVertexAttribs<kRectAttribs>(3, 2 * sizeof(SkPoint) + sizeof(SkColor));
     } else {
         drawState->setVertexAttribs<kRectAttribs>(2, sizeof(SkPoint) + sizeof(SkColor));
     }
     if (0xFF == GrColorUnpackA(color)) {
         drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
     }
 }
 
+static bool path_fill_type_is_winding(const GrStencilSettings& pathStencilSettings) {
+    static const GrStencilSettings::Face pathFace = GrStencilSettings::kFront_Face;
+    bool isWinding = kInvert_StencilOp != pathStencilSettings.passOp(pathFace);
+    if (isWinding) {
+        // Double check that it is in fact winding.
+        SkASSERT(kIncClamp_StencilOp == pathStencilSettings.passOp(pathFace));
+        SkASSERT(kIncClamp_StencilOp == pathStencilSettings.failOp(pathFace));
+        SkASSERT(0x1 != pathStencilSettings.writeMask(pathFace));
+        SkASSERT(!pathStencilSettings.isTwoSided());
+    }
+    return isWinding;
+}
+
+static bool draw_uses_dst_color(const GrDrawState& drawState) {
+    GrBlendCoeff dstBlendCoeff = drawState.getDstBlendCoeff();
+    if (kZero_GrBlendCoeff != dstBlendCoeff &&
+        (kISA_GrBlendCoeff != dstBlendCoeff || !drawState.srcAlphaWillBeOne())) {
+        return true;
+    }
+
+    return drawState.willEffectReadDstColor();

[Chris Dalton, 2014/11/11 22:34:40]

My understanding is that this should work. srcAlphaWillBeOne() takes coverage
into account, and willEffectReadDstColor() should cover the case where a shader
reads the dst directly for blending.

But it would be great if I can get a confirmation.

+}
+
+template<typename T> static void reset_data_buffer(SkTDArray<T>* buffer, int minReserve) {
+    // Assume the next time this buffer fills up it will use approximately the same amount
+    // of space as last time. Only resize if we're using less than a third of the
+    // allocated space, and leave enough for 50% growth over last time.
+    if (3 * buffer->count() < buffer->reserved() && buffer->reserved() > minReserve) {
+        int reserve = SkTMax(minReserve, buffer->count() * 3 / 2);
+        buffer->reset();
+        buffer->setReserve(reserve);
+    } else {
+        buffer->rewind();
+    }
+}
+
 enum {
     kTraceCmdBit = 0x80,
     kCmdMask = 0x7f,
 };
 
 static inline uint8_t add_trace_bit(uint8_t cmd) { return cmd | kTraceCmdBit; }
 
 static inline uint8_t strip_trace_bit(uint8_t cmd) { return cmd & kCmdMask; }
 
 static inline bool cmd_has_trace_marker(uint8_t cmd) { return SkToBool(cmd & kTraceCmdBit); }
@@ skipping 212 matching lines @@
                                       PathTransformType transformsType,
                                       const GrClipMaskManager::ScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
                                       const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(pathRange);
     SkASSERT(indices);
     SkASSERT(transforms);
 
     this->recordStateIfNecessary();
 
-    int sizeOfIndices = sizeof(uint32_t) * count;
-    int sizeOfTransforms = sizeof(float) * count *
-                           GrPathRendering::PathTransformSize(transformsType);
+    uint32_t* savedIndices = fPathIndexBuffer.append(count, indices);
+    float* savedTransforms = fPathTransformBuffer.append(count *
+                                 GrPathRendering::PathTransformSize(transformsType), transforms);
 
-    DrawPaths* dp = GrNEW_APPEND_WITH_DATA_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange),
-                                                       sizeOfIndices + sizeOfTransforms);
-    memcpy(dp->indices(), indices, sizeOfIndices);
+    if (kDrawPaths_Cmd == 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
+        // places. For now the winding numbers are only an issue if the fill is even/odd,
+        // because DrawPaths is currently only used for glyphs, and glyphs in the same
+        // font tend to all wind in the same direction.
+        DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
+        if (pathRange == previous->pathRange() &&
+            transformsType == previous->fTransformsType &&
+            scissorState == previous->fScissorState &&
+            stencilSettings == previous->fStencilSettings &&
+            path_fill_type_is_winding(stencilSettings) &&
+            !draw_uses_dst_color(this->getDrawState())) {
+            // Fold this DrawPaths call into the one previous.
+            previous->fCount += count;
+            return;
+        }
+    }
+
+    DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
+    dp->fIndicesLocation = savedIndices - fPathIndexBuffer.begin();
     dp->fCount = count;
-    memcpy(dp->transforms(), transforms, sizeOfTransforms);
+    dp->fTransformsLocation = savedTransforms - fPathTransformBuffer.begin();
     dp->fTransformsType = transformsType;
     dp->fScissorState = scissorState;
     dp->fStencilSettings = stencilSettings;
     if (dstCopy) {
         dp->fDstCopy = *dstCopy;
     }
 
     this->recordTraceMarkersIfNecessary();
 }
 
@@ skipping 44 matching lines @@
 
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
 
     fCmdBuffer.reset();
     fLastState = NULL;
     fVertexPool.reset();
     fIndexPool.reset();
+    reset_data_buffer(&fPathIndexBuffer, kPathIdxBufferMinReserve);
+    reset_data_buffer(&fPathTransformBuffer, kPathXformBufferMinReserve);
     fGpuCmdMarkers.reset();
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
     this->getContext()->getFontCache()->updateTextures();
 
@@ skipping 26 matching lines @@
             fDstGpu->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
 
         SkDEBUGCODE(bool isDraw = kDraw_Cmd == strip_trace_bit(iter->fType) ||
                                   kStencilPath_Cmd == strip_trace_bit(iter->fType) ||
                                   kDrawPath_Cmd == strip_trace_bit(iter->fType) ||
                                   kDrawPaths_Cmd == strip_trace_bit(iter->fType));
         SkASSERT(!isDraw || fDstGpu->drawState() != prevDrawState);
 
-        iter->execute(fDstGpu);
+        iter->execute(this);
 
         if (cmd_has_trace_marker(iter->fType)) {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
 
     fDstGpu->restoreActiveTraceMarkers();
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     fDstGpu->setDrawState(prevDrawState);
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
-void GrInOrderDrawBuffer::Draw::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::Draw::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     gpu->setVertexSourceToBuffer(this->vertexBuffer());
     if (fInfo.isIndexed()) {
         gpu->setIndexSourceToBuffer(this->indexBuffer());
     }
     gpu->draw(fInfo, fScissorState);
 }
 
-void GrInOrderDrawBuffer::StencilPath::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::StencilPath::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     gpu->stencilPath(this->path(), fScissorState, fStencilSettings);
 }
 
-void GrInOrderDrawBuffer::DrawPath::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::DrawPath::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     gpu->drawPath(this->path(), fScissorState, fStencilSettings,
-                         fDstCopy.texture() ? &fDstCopy : NULL);
+                  fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
-void GrInOrderDrawBuffer::DrawPaths::execute(GrGpu* gpu) {
-    gpu->drawPaths(this->pathRange(), this->indices(), fCount, this->transforms(),
-                          fTransformsType, fScissorState, fStencilSettings,
-                          fDstCopy.texture() ? &fDstCopy : NULL);
+void GrInOrderDrawBuffer::DrawPaths::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
+    gpu->drawPaths(this->pathRange(), buf->pathIndexBuffer() + fIndicesLocation, fCount,
+                   buf->pathTransformBuffer() + fTransformsLocation, fTransformsType,
+                   fScissorState, fStencilSettings, fDstCopy.texture() ? &fDstCopy : NULL);
 }
 
-void GrInOrderDrawBuffer::SetState::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::SetState::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     gpu->setDrawState(&fState);
 }
 
-void GrInOrderDrawBuffer::Clear::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::Clear::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     if (GrColor_ILLEGAL == fColor) {
         gpu->discard(this->renderTarget());
     } else {
         gpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
-void GrInOrderDrawBuffer::ClearStencilClip::execute(GrGpu* gpu) {
-        gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
+void GrInOrderDrawBuffer::ClearStencilClip::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
+    gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
 }
 
-void GrInOrderDrawBuffer::CopySurface::execute(GrGpu* gpu) {
+void GrInOrderDrawBuffer::CopySurface::execute(GrInOrderDrawBuffer* buf) {
+    GrGpu* gpu = buf->dstGpu();
     gpu->copySurface(this->dst(), this->src(), fSrcRect, fDstPoint);
 }
 
 bool GrInOrderDrawBuffer::copySurface(GrSurface* dst,
                                       GrSurface* src,
                                       const SkIRect& srcRect,
                                       const SkIPoint& dstPoint) {
     if (fDstGpu->canCopySurface(dst, src, srcRect, dstPoint)) {
         CopySurface* cs = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, CopySurface, (dst, src));
         cs->fSrcRect = srcRect;
@@ skipping 203 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);
     }
 }