Simplify installation of pipeling into GrDrawBatch in GrDrawTarget.h

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 33 matching lines @@
     fGpu->unref();
     fCaps->unref();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
                                            const GrProcOptInfo& colorPOI,
                                            const GrProcOptInfo& coveragePOI,
                                            GrXferProcessor::DstTexture* dstTexture,
-                                           const SkRect* drawBounds) {
+                                           const SkRect& batchBounds) {
+    SkRect bounds = batchBounds;
+    bounds.outset(0.5f, 0.5f);
+
     if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), colorPOI, coveragePOI)) {
         return true;
     }
 
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
 
     if (this->caps()->textureBarrierSupport()) {
         if (GrTexture* rtTex = rt->asTexture()) {
             // The render target is a texture, so we can read from it directly in the shader. The XP
             // will be responsible to detect this situation and request a texture barrier.
             dstTexture->setTexture(rtTex);
             dstTexture->setOffset(0, 0);
             return true;
         }
     }
 
     SkIRect copyRect;
     pipelineBuilder.clip().getConservativeBounds(rt, &copyRect);
 
-    if (drawBounds) {
-        SkIRect drawIBounds;
-        drawBounds->roundOut(&drawIBounds);
-        if (!copyRect.intersect(drawIBounds)) {
+    SkIRect drawIBounds;
+    bounds.roundOut(&drawIBounds);
+    if (!copyRect.intersect(drawIBounds)) {
 #ifdef SK_DEBUG
-            GrCapsDebugf(fCaps, "Missed an early reject. "
-                         "Bailing on draw from setupDstReadIfNecessary.\n");
+        GrCapsDebugf(fCaps, "Missed an early reject. "
+                        "Bailing on draw from setupDstReadIfNecessary.\n");
 #endif
-            return false;
-        }
-    } else {
-#ifdef SK_DEBUG
-        //SkDebugf("No dev bounds when dst copy is made.\n");
-#endif
+        return false;
     }
 
     // MSAA consideration: When there is support for reading MSAA samples in the shader we could
     // have per-sample dst values by making the copy multisampled.
     GrSurfaceDesc desc;
     if (!this->getGpu()->initCopySurfaceDstDesc(rt, &desc)) {
         desc.fOrigin = kDefault_GrSurfaceOrigin;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fConfig = rt->config();
     }
 
-
     desc.fWidth = copyRect.width();
     desc.fHeight = copyRect.height();
 
     static const uint32_t kFlags = 0;
     SkAutoTUnref<GrTexture> copy(fResourceProvider->createApproxTexture(desc, kFlags));
 
     if (!copy) {
         SkDebugf("Failed to create temporary copy of destination texture.\n");
         return false;
     }
@@ skipping 37 matching lines @@
 
 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()) {
+    GrPipeline::CreateArgs args;
+    if (!this->installPipelineInDrawBatch(&pipelineBuilder, &scissorState, batch)) {
         return;
     }
-    if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
-        return;
-    }
+
     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 94 matching lines @@
         return;
     }
 
     // Ensure the render target has a stencil buffer and get the stencil settings.
     GrStencilSettings stencilSettings;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* sb = rt->renderTargetPriv().attachStencilAttachment();
     this->getPathStencilSettingsForFilltype(fill, sb, &stencilSettings);
     batch->setStencilSettings(stencilSettings);
 
-    GrDrawTarget::PipelineInfo pipelineInfo(&pipelineBuilder, &scissorState, batch,
-                                            &batch->bounds(), this);
-
-    if (!pipelineInfo.valid()) {
-        return;
-    }
-    if (!batch->installPipeline(pipelineInfo.pipelineCreateArgs())) {
+    GrPipeline::CreateArgs args;
+    if (!this->installPipelineInDrawBatch(&pipelineBuilder, &scissorState, batch)) {
         return;
     }
 
     this->recordBatch(batch);
 }
 
 void GrDrawTarget::drawNonAARect(const GrPipelineBuilder& pipelineBuilder,
                               GrColor color,
                               const SkMatrix& viewMatrix,
                               const SkRect& rect) {
@@ skipping 142 matching lines @@
             }
         }
     } 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;
-    fArgs.fColorPOI = fArgs.fPipelineBuilder->colorProcInfo(batch);
-    fArgs.fCoveragePOI = fArgs.fPipelineBuilder->coverageProcInfo(batch);
-    if (!target->setupDstReadIfNecessary(*fArgs.fPipelineBuilder, fArgs.fColorPOI,
-                                         fArgs.fCoveragePOI, &fArgs.fDstTexture, devBounds)) {
-        fArgs.fPipelineBuilder = nullptr;
+bool GrDrawTarget::installPipelineInDrawBatch(const GrPipelineBuilder* pipelineBuilder,
+                                              const GrScissorState* scissor,
+                                              GrDrawBatch* batch) {
+    GrPipeline::CreateArgs args;
+    args.fPipelineBuilder = pipelineBuilder;
+    args.fCaps = this->caps();
+    args.fScissor = scissor;
+    args.fColorPOI = pipelineBuilder->colorProcInfo(batch);
+    args.fCoveragePOI = pipelineBuilder->coverageProcInfo(batch);
+    if (!this->setupDstReadIfNecessary(*pipelineBuilder, args.fColorPOI,
+                                       args.fCoveragePOI, &args.fDstTexture,
+                                       batch->bounds())) {
+        return false;
     }
+
+    if (!batch->installPipeline(args)) {
+        return false;
+    }
+
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 GrClipTarget::GrClipTarget(GrContext* context)
     : INHERITED(context->getGpu(), context->resourceProvider())
     , fContext(context) {
     fClipMaskManager.reset(new GrClipMaskManager(this));
 }
 
 
@@ skipping 13 matching lines @@
     // 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->recordBatch(batch);
     batch->unref();
 }