Start using RenderTargetProxy (omnibus)

src/gpu/GrRenderTargetOpList.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 "GrRenderTargetOpList.h"
 
 #include "GrAppliedClip.h"
 #include "GrAuditTrail.h"
 #include "GrCaps.h"
 #include "GrRenderTargetContext.h"
 #include "GrGpu.h"
 #include "GrGpuCommandBuffer.h"
 #include "GrPath.h"
 #include "GrPipeline.h"
 #include "GrMemoryPool.h"
 #include "GrPipelineBuilder.h"
 #include "GrRenderTarget.h"
 #include "GrResourceProvider.h"
+#include "GrRenderTargetContextPriv.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSurfacePriv.h"
 #include "GrTexture.h"
 #include "gl/GrGLRenderTarget.h"
 
 #include "SkStrokeRec.h"
 
 #include "batches/GrClearBatch.h"
 #include "batches/GrClearStencilClipBatch.h"
@@ skipping 59 matching lines @@
             const SkRect& clippedBounds = fRecordedBatches[i].fClippedBounds;
             SkDebugf("ClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                      clippedBounds.fLeft, clippedBounds.fTop, clippedBounds.fRight,
                      clippedBounds.fBottom);
         }
     }
 }
 #endif
 
 bool GrRenderTargetOpList::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
-                                                   GrRenderTarget* rt,
+                                                   GrRenderTargetContext* rtc,
                                                    const GrClip& clip,
                                                    const GrPipelineOptimizations& optimizations,
                                                    GrXferProcessor::DstTexture* dstTexture,
                                                    const SkRect& batchBounds) {
     SkRect bounds = batchBounds;
     bounds.outset(0.5f, 0.5f);
 
     if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), optimizations)) {
         return true;
     }
 
+    GrContext* context = rtc->priv().context();
+    GrRenderTarget* rt = rtc->priv().accessRTP()->instantiate(context->textureProvider());
+    if (!rt) {
+        return false;
+    }
+
     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(sk_ref_sp(rtTex));
             dstTexture->setOffset(0, 0);
             return true;
         }
     }
 
@@ skipping 54 matching lines @@
         fInstancedRendering->beginFlush(flushState->resourceProvider());
     }
 }
 
 bool GrRenderTargetOpList::drawBatches(GrBatchFlushState* flushState) {
     if (0 == fRecordedBatches.count()) {
         return false;
     }
     // Draw all the generated geometry.
     SkRandom random;
-    GrRenderTarget* currentRT = nullptr;
+    GrRenderTargetProxy* currentRTP = nullptr;
     std::unique_ptr<GrGpuCommandBuffer> commandBuffer;
     for (int i = 0; i < fRecordedBatches.count(); ++i) {
         if (!fRecordedBatches[i].fBatch) {
             continue;
         }
-        if (fRecordedBatches[i].fBatch->renderTarget() != currentRT) {
+        if (fRecordedBatches[i].fBatch->rtp() != currentRTP) {
             if (commandBuffer) {
                 commandBuffer->end();
                 commandBuffer->submit();
                 commandBuffer.reset();
             }
-            currentRT = fRecordedBatches[i].fBatch->renderTarget();
-            if (currentRT) {
+            currentRTP = fRecordedBatches[i].fBatch->rtp();
+            if (currentRTP) {
                 static const GrGpuCommandBuffer::LoadAndStoreInfo kBasicLoadStoreInfo
                     { GrGpuCommandBuffer::LoadOp::kLoad,GrGpuCommandBuffer::StoreOp::kStore,
                       GrColor_ILLEGAL };
-                commandBuffer.reset(fGpu->createCommandBuffer(currentRT,
+                commandBuffer.reset(fGpu->createCommandBuffer(nullptr, //currentRT,
                                                               kBasicLoadStoreInfo,   // Color
                                                               kBasicLoadStoreInfo)); // Stencil
             }
             flushState->setCommandBuffer(commandBuffer.get());
         }
         if (fDrawBatchBounds) {
             const SkRect& bounds = fRecordedBatches[i].fClippedBounds;
             SkIRect ibounds;
             bounds.roundOut(&ibounds);
+#if 0
             // In multi-draw buffer all the batches use the same render target and we won't need to
             // get the batchs bounds.
             if (GrRenderTarget* rt = fRecordedBatches[i].fBatch->renderTarget()) {
                 fGpu->drawDebugWireRect(rt, ibounds, 0xFF000000 | random.nextU());
             }
+#endif
         }
         fRecordedBatches[i].fBatch->draw(flushState, fRecordedBatches[i].fClippedBounds);
     }
     if (commandBuffer) {
         commandBuffer->end();
         commandBuffer->submit();
         flushState->setCommandBuffer(nullptr);
     }
 
     fGpu->finishOpList();
@@ skipping 102 matching lines @@
     }
     args.fOpts.fColorPOI.completeCalculations(
         sk_sp_address_as_pointer_address(pipelineBuilder.fColorFragmentProcessors.begin()),
         pipelineBuilder.numColorFragmentProcessors());
     args.fOpts.fCoveragePOI.completeCalculations(
         sk_sp_address_as_pointer_address(pipelineBuilder.fCoverageFragmentProcessors.begin()),
         pipelineBuilder.numCoverageFragmentProcessors());
     args.fScissor = &appliedClip.scissorState();
     args.fWindowRectsState = &appliedClip.windowRectsState();
     args.fHasStencilClip = appliedClip.hasStencilClip();
-    if (!this->setupDstReadIfNecessary(pipelineBuilder, renderTargetContext->accessRenderTarget(),
+    if (!this->setupDstReadIfNecessary(pipelineBuilder, renderTargetContext,
                                        clip, args.fOpts,
                                        &args.fDstTexture, batch->bounds())) {
         return;
     }
 
     if (!batch->installPipeline(args)) {
         return;
     }
 
 #ifdef ENABLE_MDB
@@ skipping 33 matching lines @@
         SkDebugf("ERROR creating stencil attachment. Draw skipped.\n");
         return;
     }
 
     GrBatch* batch = GrStencilPathBatch::Create(viewMatrix,
                                                 useHWAA,
                                                 path->getFillType(),
                                                 appliedClip.hasStencilClip(),
                                                 stencilAttachment->bits(),
                                                 appliedClip.scissorState(),
-                                                renderTargetContext->accessRenderTarget(),
+                                                fRenderTargetProxy,
                                                 path);
     this->recordBatch(batch, appliedClip.clippedDrawBounds());
     batch->unref();
 }
 
 void GrRenderTargetOpList::addBatch(sk_sp<GrBatch> batch) {
     this->recordBatch(batch.get(), batch->bounds());
 }
 
-void GrRenderTargetOpList::fullClear(GrRenderTarget* renderTarget, GrColor color) {
+void GrRenderTargetOpList::fullClear(GrRenderTargetProxy* rtp, GrColor color) {
     // Currently this just inserts or updates the last clear batch. However, once in MDB this can
     // remove all the previously recorded batches and change the load op to clear with supplied
     // color.
     if (fLastFullClearBatch &&
-        fLastFullClearBatch->renderTargetUniqueID() == renderTarget->uniqueID()) {
+        fLastFullClearBatch->renderTargetUniqueID() == rtp->uniqueID()) {
         // As currently implemented, fLastFullClearBatch should be the last batch because we would
         // have cleared it when another batch was recorded.
         SkASSERT(fRecordedBatches.back().fBatch.get() == fLastFullClearBatch);
         fLastFullClearBatch->setColor(color);
         return;
     }
-    sk_sp<GrClearBatch> batch(GrClearBatch::Make(GrFixedClip::Disabled(), color, renderTarget));
+    sk_sp<GrClearBatch> batch(GrClearBatch::Make(GrFixedClip::Disabled(), color, rtp));
     if (batch.get() == this->recordBatch(batch.get(), batch->bounds())) {
         fLastFullClearBatch = batch.get();
     }
 }
 
-void GrRenderTargetOpList::discard(GrRenderTarget* renderTarget) {
+void GrRenderTargetOpList::discard(GrRenderTargetProxy* rtp) {
     // Currently this just inserts a discard batch. However, once in MDB this can remove all the
     // previously recorded batches and change the load op to discard.
     if (this->caps()->discardRenderTargetSupport()) {
-        GrBatch* batch = new GrDiscardBatch(renderTarget);
+        GrBatch* batch = new GrDiscardBatch(rtp);
         this->recordBatch(batch, batch->bounds());
         batch->unref();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrRenderTargetOpList::copySurface(GrSurface* dst,
                                        GrSurface* src,
                                        const SkIRect& srcRect,
@@ skipping 129 matching lines @@
                 break;
             }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrRenderTargetOpList::clearStencilClip(const GrFixedClip& clip,
                                             bool insideStencilMask,
-                                            GrRenderTarget* rt) {
-    GrBatch* batch = new GrClearStencilClipBatch(clip, insideStencilMask, rt);
+                                            GrRenderTargetProxy* rtp) {
+    GrBatch* batch = new GrClearStencilClipBatch(clip, insideStencilMask, rtp);
     this->recordBatch(batch, batch->bounds());
     batch->unref();
 }