Cleanup GrDrawTarget now that all paths lead to GrBatch

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawTarget.h"
 
@@ skipping 18 matching lines @@
 #include "batches/GrStencilPathBatch.h"
 
 #include "SkStrokeRec.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::GrDrawTarget(GrGpu* gpu, GrResourceProvider* resourceProvider)
     : fGpu(SkRef(gpu))
     , fCaps(SkRef(gpu->caps()))
     , fResourceProvider(resourceProvider)
-    , fFlushing(false) {
+    , fFlushing(false)
+    , fLastFlushToken(0) {
 }
 
 GrDrawTarget::~GrDrawTarget() {
     fGpu->unref();
     fCaps->unref();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
@@ skipping 62 matching lines @@
     dstTexture->setOffset(copyRect.fLeft, copyRect.fTop);
     return true;
 }
 
 void GrDrawTarget::flush() {
     if (fFlushing) {
         return;
     }
     fFlushing = true;
 
-    this->onFlush();
+    GrBatchFlushState flushState(fGpu, fResourceProvider, fLastFlushToken);
+
+    // Loop over all batches and generate geometry
+    for (int i = 0; i < fBatches.count(); ++i) {
+        fBatches[i]->prepare(&flushState);
+    }
+
+    // Upload all data to the GPU
+    flushState.preIssueDraws();
+
+    // Draw all the generated geometry.
+    for (int i = 0; i < fBatches.count(); ++i) {
+        fBatches[i]->draw(&flushState);
+    }
+
+    fLastFlushToken = flushState.lastFlushedToken();
 
     fFlushing = false;
     this->reset();
 }
 
+void GrDrawTarget::reset() {
+    fBatches.reset();
+}
+
 void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder, GrDrawBatch* batch) {
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessorState arfps;
     GrPipelineBuilder::AutoRestoreStencil ars;
     if (!this->setupClip(pipelineBuilder, &arfps, &ars, &scissorState, &batch->bounds())) {
         return;
     }
 
     // Batch bounds are tight, so for dev copies
     // TODO move this into setupDstReadIfNecessary when paths are in batch
     SkRect bounds = batch->bounds();
     bounds.outset(0.5f, 0.5f);
 
     GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, batch, &bounds,
                                             this);
 
     if (!pipelineInfo.valid()) {
         return;
     }
     if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
         return;
     }
-    this->onDrawBatch(batch);
+    this->recordBatch(batch);
 }
 
 static const GrStencilSettings& winding_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kIncClamp_StencilOp,
         kIncClamp_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0xFFFF, 0xFFFF, 0xFFFF);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
@@ skipping 44 matching lines @@
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
 
     GrBatch* batch = GrStencilPathBatch::Create(pathProc->viewMatrix(),
                                                 pipelineBuilder.isHWAntialias(),
                                                 stencilSettings, scissorState,
                                                 pipelineBuilder.getRenderTarget(),
                                                 path);
-    this->onDrawBatch(batch);
+    this->recordBatch(batch);
     batch->unref();
 }
 
 void GrDrawTarget::drawPath(const GrPipelineBuilder& pipelineBuilder,
                             const GrPathProcessor* pathProc,
                             const GrPath* path,
                             GrPathRendering::FillType fill) {
     SkASSERT(path);
     SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport());
 
@@ skipping 35 matching lines @@
     GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, batch,
                                             &batch->bounds(), this);
 
     if (!pipelineInfo.valid()) {
         return;
     }
     if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
         return;
     }
 
-    this->onDrawBatch(batch);
+    this->recordBatch(batch);
 }
 
 void GrDrawTarget::drawNonAARect(const GrPipelineBuilder& pipelineBuilder,
                               GrColor color,
                               const SkMatrix& viewMatrix,
                               const SkRect& rect) {
    SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect,
                                                                        nullptr, nullptr));
    this->drawBatch(pipelineBuilder, batch);
 }
@@ skipping 54 matching lines @@
         if (rect == &rtRect) {
             this->discard(renderTarget);
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setRenderTarget(renderTarget);
 
         this->drawNonAARect(pipelineBuilder, color, SkMatrix::I(), *rect);
     } else {
         GrBatch* batch = new GrClearBatch(*rect, color, renderTarget);
-        this->onDrawBatch(batch);
+        this->recordBatch(batch);
         batch->unref();
     }
 }
 
 void GrDrawTarget::discard(GrRenderTarget* renderTarget) {
     if (this->caps()->discardRenderTargetSupport()) {
         GrBatch* batch = new GrDiscardBatch(renderTarget);
-        this->onDrawBatch(batch);
+        this->recordBatch(batch);
         batch->unref();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawTarget::copySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) {
     GrBatch* batch = GrCopySurfaceBatch::Create(dst, src, srcRect, dstPoint);
     if (batch) {
-        this->onDrawBatch(batch);
+        this->recordBatch(batch);
         batch->unref();
     }
 }
 
+template <class Left, class Right> static bool intersect(const Left& a, const Right& b) {
+    SkASSERT(a.fLeft <= a.fRight && a.fTop <= a.fBottom &&
+             b.fLeft <= b.fRight && b.fTop <= b.fBottom);
+    return a.fLeft < b.fRight && b.fLeft < a.fRight && a.fTop < b.fBottom && b.fTop < a.fBottom;
+}
+
+void GrDrawTarget::recordBatch(GrBatch* batch) {
+    // Check if there is a Batch Draw we can batch with by linearly searching back until we either
+    // 1) check every draw
+    // 2) intersect with something
+    // 3) find a 'blocker'
+    // Experimentally we have found that most batching occurs within the first 10 comparisons.
+    static const int kMaxLookback = 10;
+
+    GrBATCH_INFO("Re-Recording (%s, B%u)\n"
+        "\tBounds (%f, %f, %f, %f)\n",
+        batch->name(),
+        batch->uniqueID(),
+        batch->bounds().fLeft, batch->bounds().fRight,
+        batch->bounds().fTop, batch->bounds().fBottom);
+    GrBATCH_INFO(SkTabString(batch->dumpInfo(), 1).c_str());
+    GrBATCH_INFO("\tOutcome:\n");    
+    int maxCandidates = SkTMin(kMaxLookback, fBatches.count());
+    if (maxCandidates) {
+        int i = 0;
+        while (true) {
+            GrBatch* candidate = fBatches.fromBack(i);
+            // We cannot continue to search backwards if the render target changes
+            if (candidate->renderTargetUniqueID() != batch->renderTargetUniqueID()) {
+                GrBATCH_INFO("\t\tBreaking because of (%s, B%u) Rendertarget\n",
+                    candidate->name(), candidate->uniqueID());
+                break;
+            }
+            if (candidate->combineIfPossible(batch, *this->caps())) {
+                GrBATCH_INFO("\t\tCombining with (%s, B%u)\n", candidate->name(),
+                    candidate->uniqueID());
+                return;
+            }
+            // Stop going backwards if we would cause a painter's order violation.
+            if (intersect(candidate->bounds(), batch->bounds())) {
+                GrBATCH_INFO("\t\tIntersects with (%s, B%u)\n", candidate->name(),
+                    candidate->uniqueID());
+                break;
+            }
+            ++i;
+            if (i == maxCandidates) {
+                GrBATCH_INFO("\t\tReached max lookback or beginning of batch array %d\n", i);
+                break;
+            }
+        }
+    } else {
+        GrBATCH_INFO("\t\tFirstBatch\n");
+    }
+    fBatches.push_back().reset(SkRef(batch));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::PipelineInfo::PipelineInfo(const GrPipelineBuilder* pipelineBuilder,
                                          const GrScissorState* scissor,
                                          const GrDrawBatch* batch,
                                          const SkRect* devBounds,
                                          GrDrawTarget* target) {
     fArgs.fPipelineBuilder = pipelineBuilder;
     fArgs.fCaps = target->caps();
     fArgs.fScissor = scissor;
@@ skipping 26 matching lines @@
 }
 
 void GrClipTarget::purgeResources() {
     // The clip mask manager can rebuild all its clip masks so just
     // get rid of them all.
     fClipMaskManager->purgeResources();
 };
 
 void GrClipTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = new GrClearStencilClipBatch(rect, insideClip, rt);
-    this->onDrawBatch(batch);
+    this->recordBatch(batch);
     batch->unref();
 }