Use texture barriers to read directly from the RT

src/gpu/GrTargetCommands.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTargetCommands.h"
 
 #include "GrColor.h"
@@ skipping 29 matching lines @@
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(info.isInstanced());
 
     const GrIndexBuffer* ib;
     if (!iodb->canConcatToIndexBuffer(&ib)) {
         return 0;
     }
 
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
-    if (Cmd::kDraw_CmdType != fCmdBuffer.back().type()) {
+    CmdBuffer::ReverseIter reverseIter(fCmdBuffer);
+    if (Cmd::kBlendBarrier_CmdType == reverseIter->type()) {
+        // Instanced draw commands can collapse through a blend barrier if they don't overlap.
+        // TODO: We could also collapse through a dst texture setup if they had a dedicated command.
+        SkAssertResult(reverseIter.previous());
+        SkASSERT(Cmd::kBlendBarrier_CmdType != reverseIter->type());
+    }
+
+    if (Cmd::kDraw_CmdType != reverseIter->type()) {
         return 0;
     }
 
-    Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
+    Draw* draw = static_cast<Draw*>(reverseIter.get());
+    bool allowOverlap = (draw == &fCmdBuffer.back());
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.primitiveType() != info.primitiveType() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
         draw->fInfo.vertexBuffer() != info.vertexBuffer() ||
         draw->fInfo.indexBuffer() != ib) {
         return 0;
     }
     if (draw->fInfo.startVertex() + draw->fInfo.vertexCount() != info.startVertex()) {
         return 0;
     }
+    if (!allowOverlap) {
+        if (draw->fInfo.getDevBounds()->isEmpty() || info.getDevBounds()->isEmpty()) {
+            // Draw bounds are unknown.
+            return 0;
+        }
+        SkIRect existingBounds, incomingBounds;
+        draw->fInfo.getDevBounds()->roundOut(&existingBounds);
+        info.getDevBounds()->roundOut(&incomingBounds);
+        if (SkIRect::Intersects(existingBounds, incomingBounds)) {
+            // Draw bounds overlap.
+            return 0;
+        }
+    }
 
     // how many instances can be concat'ed onto draw given the size of the index buffer
     int instancesToConcat = iodb->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->fInfo.instanceCount();
     instancesToConcat = SkTMin(instancesToConcat, info.instanceCount());
 
     draw->fInfo.adjustInstanceCount(instancesToConcat);
 
+    // Join the draw bounds.
+    if (!draw->fInfo.getDevBounds()->isEmpty()) {
+        if (info.getDevBounds()->isEmpty()) {
+            draw->fInfo.setDevBounds(SkRect::MakeEmpty());
+        } else {
+            SkRect newBounds(*draw->fInfo.getDevBounds());
+            newBounds.join(*info.getDevBounds());
+            draw->fInfo.setDevBounds(newBounds);
+        }
+    }
+
+    // Remove the blend barrier, if any.
+    if (Cmd::kBlendBarrier_CmdType == fCmdBuffer.back().type()) {
+        fCmdBuffer.pop_back();

[Mark Kilgard, 2015/04/02 23:02:38]

does something avoid all this checking to eliminate blend barriers if blend
barriers aren't actually necessary?

I'd had to be looking for work to eliminate that doesn't exist

+    }
+
     // update last fGpuCmdMarkers to include any additional trace markers that have been added
     iodb->recordTraceMarkersIfNecessary(draw);
     return instancesToConcat;
 }
 
 GrTargetCommands::Cmd* GrTargetCommands::recordDraw(
                                                   GrInOrderDrawBuffer* iodb,
                                                   const GrGeometryProcessor* gp,
                                                   const GrDrawTarget::DrawInfo& info,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
@@ skipping 23 matching lines @@
 GrTargetCommands::Cmd* GrTargetCommands::recordDrawBatch(
                                                   GrInOrderDrawBuffer* iodb,
                                                   GrBatch* batch,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
     if (!this->setupPipelineAndShouldDraw(iodb, batch, pipelineInfo)) {
         return NULL;
     }
 
     // Check if there is a Batch Draw we can batch with
     if (Cmd::kDrawBatch_CmdType != fCmdBuffer.back().type() || !fDrawBatch) {
+        // TODO: Batch through blend barriers and dst texture setups when there is no overlap.
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
         return fDrawBatch;
     }
 
     SkASSERT(&fCmdBuffer.back() == fDrawBatch);
     if (!fDrawBatch->fBatch->combineIfPossible(batch)) {
         this->closeBatch();
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
     }
 
@@ skipping 18 matching lines @@
     sp->fStencil = stencilSettings;
     return sp;
 }
 
 GrTargetCommands::Cmd* GrTargetCommands::recordDrawPath(
                                                   GrInOrderDrawBuffer* iodb,
                                                   const GrPathProcessor* pathProc,
                                                   const GrPath* path,
                                                   const GrStencilSettings& stencilSettings,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
+    // Path commands don't require a preceeding blend barrier (per the spec).
+    SkASSERT(fCmdBuffer.empty() || Cmd::kBlendBarrier_CmdType != fCmdBuffer.back().type());
+
     this->closeBatch();
 
     // TODO: Only compare the subset of GrPipelineBuilder relevant to path covering?
     if (!this->setupPipelineAndShouldDraw(iodb, pathProc, pipelineInfo)) {
         return NULL;
     }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     dp->fStencilSettings = stencilSettings;
     return dp;
 }
 
 GrTargetCommands::Cmd* GrTargetCommands::recordDrawPaths(
                                                   GrInOrderDrawBuffer* iodb,
                                                   const GrPathProcessor* pathProc,
                                                   const GrPathRange* pathRange,
                                                   const void* indexValues,
                                                   GrDrawTarget::PathIndexType indexType,
                                                   const float transformValues[],
                                                   GrDrawTarget::PathTransformType transformType,
                                                   int count,
                                                   const GrStencilSettings& stencilSettings,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
     SkASSERT(pathRange);
     SkASSERT(indexValues);
     SkASSERT(transformValues);
+
+    // Path commands don't require a preceeding blend barrier (per the spec).
+    SkASSERT(fCmdBuffer.empty() || Cmd::kBlendBarrier_CmdType != fCmdBuffer.back().type());
+
     this->closeBatch();
 
     if (!this->setupPipelineAndShouldDraw(iodb, pathProc, pipelineInfo)) {
         return NULL;
     }
 
     char* savedIndices;
     float* savedTransforms;
     
     iodb->appendIndicesAndTransforms(indexValues, indexType,
                                      transformValues, transformType,
                                      count, &savedIndices, &savedTransforms);
 
     if (Cmd::kDrawPaths_CmdType == fCmdBuffer.back().type()) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
-        // before. Note that stenciling 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.
+        // before. Note that when there is overlap, this is not equivalent to two separate
+        // draw calls. We don't worry about this case because instanced path commands are
+        // only used for text. (It also means we get to combine calls when the blend mode
+        // doesn't allow overlap; a single cover pass is non-overlapping by definition.)
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
             transformType == previous->fTransformType &&
             stencilSettings == previous->fStencilSettings &&
-            path_fill_type_is_winding(stencilSettings) &&
-            !pipelineInfo.willBlendWithDst(pathProc)) {
-                const int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
-                const int xformSize = GrPathRendering::PathTransformSize(transformType);
-                if (&previous->fIndices[previous->fCount*indexBytes] == savedIndices &&
-                    (0 == xformSize ||
-                     &previous->fTransforms[previous->fCount*xformSize] == savedTransforms)) {
-                    // Fold this DrawPaths call into the one previous.
-                    previous->fCount += count;
-                    return NULL;
-                }
+            path_fill_type_is_winding(stencilSettings)) { // Even/odd could cancel on overlap.
+            const int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
+            const int xformSize = GrPathRendering::PathTransformSize(transformType);
+            if (&previous->fIndices[previous->fCount*indexBytes] == savedIndices &&
+                (0 == xformSize ||
+                 &previous->fTransforms[previous->fCount*xformSize] == savedTransforms)) {
+                // Fold this DrawPaths call into the one previous.
+                previous->fCount += count;
+                return NULL;
+            }
         }
     }
 
     DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
     dp->fIndices = savedIndices;
     dp->fIndexType = indexType;
     dp->fTransforms = savedTransforms;
     dp->fTransformType = transformType;
     dp->fCount = count;
     dp->fStencilSettings = stencilSettings;
@@ skipping 167 matching lines @@
 }
 
 void GrTargetCommands::ClearStencilClip::execute(GrGpu* gpu, const SetState*) {
     gpu->clearStencilClip(fRect, fInsideClip, this->renderTarget());
 }
 
 void GrTargetCommands::CopySurface::execute(GrGpu* gpu, const SetState*) {
     gpu->copySurface(this->dst(), this->src(), fSrcRect, fDstPoint);
 }
 
+void GrTargetCommands::BlendBarrier::execute(GrGpu* gpu, const SetState*) {
+    gpu->blendBarrier();
+}
+
 GrTargetCommands::Cmd* GrTargetCommands::recordCopySurface(GrInOrderDrawBuffer* iodb,
                                                            GrSurface* dst,
                                                            GrSurface* src,
                                                            const SkIRect& srcRect,
                                                            const SkIPoint& dstPoint) {
     if (iodb->getGpu()->canCopySurface(dst, src, srcRect, dstPoint)) {
         this->closeBatch();
         CopySurface* cs = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, CopySurface, (dst, src));
         cs->fSrcRect = srcRect;
         cs->fDstPoint = dstPoint;
         return cs;
     }
     return NULL;
 }
 
+GrTargetCommands::Cmd* GrTargetCommands::recordBlendBarrier(GrInOrderDrawBuffer* iodb) {
+    if (!fCmdBuffer.empty() && Cmd::kBlendBarrier_CmdType == fCmdBuffer.back().type()) {
+        return NULL;
+    }
+    this->closeBatch();
+    return GrNEW_APPEND_TO_RECORDER(fCmdBuffer, BlendBarrier, ());
+}
+
 bool GrTargetCommands::setupPipelineAndShouldDraw(GrInOrderDrawBuffer* iodb,
                                                   const GrPrimitiveProcessor* primProc,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
     SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (primProc));
     iodb->setupPipeline(pipelineInfo, ss->pipelineLocation()); 
 
     if (ss->getPipeline()->mustSkip()) {
         fCmdBuffer.pop_back();
         return false;
     }
@@ skipping 31 matching lines @@
         fPrevState->getPipeline()->isEqual(*ss->getPipeline())) {
         fCmdBuffer.pop_back();
     } else {
         this->closeBatch();
         fPrevState = ss;
         iodb->recordTraceMarkersIfNecessary(ss);
     }
     return true;
 }