diff options
41 files changed, 526 insertions, 428 deletions
diff --git a/gyp/gpu.gypi b/gyp/gpu.gypi index 3a2ad20b54..315de8bd4e 100644 --- a/gyp/gpu.gypi +++ b/gyp/gpu.gypi @@ -101,8 +101,6 @@ '<(skia_src_path)/gpu/GrPathRenderingDrawContext.h', '<(skia_src_path)/gpu/GrDrawingManager.cpp', '<(skia_src_path)/gpu/GrDrawingManager.h', - '<(skia_src_path)/gpu/GrDrawTarget.cpp', - '<(skia_src_path)/gpu/GrDrawTarget.h', '<(skia_src_path)/gpu/GrFixedClip.cpp', '<(skia_src_path)/gpu/GrFixedClip.h', '<(skia_src_path)/gpu/GrFragmentProcessor.cpp', @@ -124,6 +122,8 @@ '<(skia_src_path)/gpu/GrMemoryPool.h', '<(skia_src_path)/gpu/GrMesh.h', '<(skia_src_path)/gpu/GrNonAtomicRef.h', + '<(skia_src_path)/gpu/GrOpList.cpp', + '<(skia_src_path)/gpu/GrOpList.h', '<(skia_src_path)/gpu/GrOvalRenderer.cpp', '<(skia_src_path)/gpu/GrOvalRenderer.h', '<(skia_src_path)/gpu/GrPaint.cpp', @@ -168,6 +168,8 @@ '<(skia_src_path)/gpu/GrRenderTargetProxy.cpp', '<(skia_src_path)/gpu/GrReducedClip.cpp', '<(skia_src_path)/gpu/GrReducedClip.h', + '<(skia_src_path)/gpu/GrRenderTargetOpList.cpp', + '<(skia_src_path)/gpu/GrRenderTargetOpList.h', '<(skia_src_path)/gpu/GrResourceCache.cpp', '<(skia_src_path)/gpu/GrResourceCache.h', '<(skia_src_path)/gpu/GrResourceHandle.h', diff --git a/include/gpu/GrDrawContext.h b/include/gpu/GrDrawContext.h index 72de15deae..6e9056dd02 100644 --- a/include/gpu/GrDrawContext.h +++ b/include/gpu/GrDrawContext.h @@ -24,12 +24,12 @@ class GrDrawBatch; class GrDrawContextPriv; class GrDrawPathBatchBase; class GrDrawingManager; -class GrDrawTarget; class GrFixedClip; class GrPaint; class GrPathProcessor; class GrPipelineBuilder; class GrRenderTarget; +class GrRenderTargetOpList; class GrStyle; class GrSurface; struct GrUserStencilSettings; @@ -366,7 +366,7 @@ private: friend class GrDrawingManager; // for ctor friend class GrDrawContextPriv; - friend class GrTestTarget; // for access to getDrawTarget + friend class GrTestTarget; // for access to getOpList friend class GrSWMaskHelper; // for access to drawBatch // All the path renderers currently make their own batches @@ -412,17 +412,17 @@ private: const GrStyle& style); // This entry point allows the GrTextContext-derived classes to add their batches to - // the drawTarget. + // the GrOpList. void drawBatch(const GrPipelineBuilder& pipelineBuilder, const GrClip&, GrDrawBatch* batch); - GrDrawTarget* getDrawTarget(); + GrRenderTargetOpList* getOpList(); GrDrawingManager* fDrawingManager; sk_sp<GrRenderTarget> fRenderTarget; - // In MDB-mode the drawTarget can be closed by some other drawContext that has picked - // it up. For this reason, the drawTarget should only ever be accessed via 'getDrawTarget'. - GrDrawTarget* fDrawTarget; + // In MDB-mode the GrOpList can be closed by some other drawContext that has picked + // it up. For this reason, the GrOpList should only ever be accessed via 'getOpList'. + GrRenderTargetOpList* fOpList; GrContext* fContext; GrInstancedPipelineInfo fInstancedPipelineInfo; diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h index 364a886408..d3cfa86086 100644 --- a/include/gpu/GrGpuResource.h +++ b/include/gpu/GrGpuResource.h @@ -23,7 +23,7 @@ class SkTraceMemoryDump; * * Gpu resources can have three types of refs: * 1) Normal ref (+ by ref(), - by unref()): These are used by code that is issuing draw calls - * that read and write the resource via GrDrawTarget and by any object that must own a + * that read and write the resource via GrOpList and by any object that must own a * GrGpuResource and is itself owned (directly or indirectly) by Skia-client code. * 2) Pending read (+ by addPendingRead(), - by completedRead()): GrContext has scheduled a read * of the resource by the GPU as a result of a skia API call but hasn't executed it yet. diff --git a/include/gpu/GrGpuResourceRef.h b/include/gpu/GrGpuResourceRef.h index 4511adce68..13adbee242 100644 --- a/include/gpu/GrGpuResourceRef.h +++ b/include/gpu/GrGpuResourceRef.h @@ -63,7 +63,7 @@ private: execution. It can only be called once. */ void markPendingIO() const; - /** Called when the program element/draw state is no longer owned by GrDrawTarget-client code. + /** Called when the program element/draw state is no longer owned by GrOpList-client code. This lets the cache know that the drawing code will no longer schedule additional reads or writes to the resource using the program element or draw state. It can only be called once. */ diff --git a/include/gpu/GrRenderTarget.h b/include/gpu/GrRenderTarget.h index 1f87787d45..445846fbb1 100644 --- a/include/gpu/GrRenderTarget.h +++ b/include/gpu/GrRenderTarget.h @@ -12,9 +12,9 @@ #include "SkRect.h" class GrCaps; -class GrDrawTarget; -class GrStencilAttachment; +class GrRenderTargetOpList; class GrRenderTargetPriv; +class GrStencilAttachment; /** * GrRenderTarget represents a 2D buffer of pixels that can be rendered to. @@ -115,8 +115,9 @@ public: GrRenderTargetPriv renderTargetPriv(); const GrRenderTargetPriv renderTargetPriv() const; - void setLastDrawTarget(GrDrawTarget* dt); - GrDrawTarget* getLastDrawTarget() { return fLastDrawTarget; } + GrRenderTargetOpList* getLastRenderTargetOpList() { + return (GrRenderTargetOpList*) this->getLastOpList(); + } protected: enum class Flags { @@ -129,7 +130,6 @@ protected: GrRenderTarget(GrGpu*, const GrSurfaceDesc&, Flags = Flags::kNone, GrStencilAttachment* = nullptr); - ~GrRenderTarget() override; // override of GrResource void onAbandon() override; @@ -150,14 +150,6 @@ private: SkIRect fResolveRect; - // The last drawTarget that wrote to or is currently going to write to this renderTarget - // The drawTarget can be closed (e.g., no draw context is currently bound - // to this renderTarget). - // This back-pointer is required so that we can add a dependancy between - // the drawTarget used to create the current contents of this renderTarget - // and the drawTarget of a destination renderTarget to which this one is being drawn. - GrDrawTarget* fLastDrawTarget; - typedef GrSurface INHERITED; }; diff --git a/include/gpu/GrSurface.h b/include/gpu/GrSurface.h index ac5c5fa1bb..0ac4bf3b12 100644 --- a/include/gpu/GrSurface.h +++ b/include/gpu/GrSurface.h @@ -14,6 +14,7 @@ #include "SkImageInfo.h" #include "SkRect.h" +class GrOpList; class GrRenderTarget; class GrSurfacePriv; class GrTexture; @@ -127,6 +128,9 @@ public: static size_t WorstCaseSize(const GrSurfaceDesc& desc); + void setLastOpList(GrOpList* opList); + GrOpList* getLastOpList() { return fLastOpList; } + protected: // Methods made available via GrSurfacePriv bool savePixels(const char* filename); @@ -142,12 +146,9 @@ protected: , fDesc(desc) , fReleaseProc(NULL) , fReleaseCtx(NULL) - {} - - ~GrSurface() override { - // check that invokeReleaseProc has been called (if needed) - SkASSERT(NULL == fReleaseProc); + , fLastOpList(nullptr) { } + ~GrSurface() override; GrSurfaceDesc fDesc; @@ -165,6 +166,14 @@ private: ReleaseProc fReleaseProc; ReleaseCtx fReleaseCtx; + // The last opList that wrote to or is currently going to write to this surface + // The opList can be closed (e.g., no draw or copy context is currently bound + // to this renderTarget or texture). + // This back-pointer is required so that we can add a dependancy between + // the opList used to create the current contents of this surface + // and the opList of a destination surface to which this one is being drawn or copied. + GrOpList* fLastOpList; + typedef GrGpuResource INHERITED; }; diff --git a/include/private/GrRenderTargetProxy.h b/include/private/GrRenderTargetProxy.h index e4bc70f212..59fed598e1 100644 --- a/include/private/GrRenderTargetProxy.h +++ b/include/private/GrRenderTargetProxy.h @@ -28,8 +28,6 @@ public: SkBackingFit, SkBudgeted); static sk_sp<GrRenderTargetProxy> Make(const GrCaps&, sk_sp<GrRenderTarget>); - ~GrRenderTargetProxy() override; - // TODO: add asTextureProxy variants GrRenderTargetProxy* asRenderTargetProxy() override { return this; } const GrRenderTargetProxy* asRenderTargetProxy() const override { return this; } @@ -60,9 +58,6 @@ public: */ int numColorSamples() const { return this->isMixedSampled() ? 0 : fDesc.fSampleCnt; } - void setLastDrawTarget(GrDrawTarget* dt); - GrDrawTarget* getLastDrawTarget() { return fLastDrawTarget; } - GrRenderTargetPriv::Flags testingOnly_getFlags() const; private: @@ -83,14 +78,6 @@ private: // rendertarget's info here. GrRenderTargetPriv::Flags fFlags; - // The last drawTarget that wrote to or is currently going to write to this renderTarget - // The drawTarget can be closed (e.g., no draw context is currently bound - // to this renderTarget). - // This back-pointer is required so that we can add a dependancy between - // the drawTarget used to create the current contents of this renderTarget - // and the drawTarget of a destination renderTarget to which this one is being drawn. - GrDrawTarget* fLastDrawTarget; - typedef GrSurfaceProxy INHERITED; }; diff --git a/include/private/GrSurfaceProxy.h b/include/private/GrSurfaceProxy.h index 69656fe4f5..4e2ad3bf14 100644 --- a/include/private/GrSurfaceProxy.h +++ b/include/private/GrSurfaceProxy.h @@ -11,6 +11,7 @@ #include "GrGpuResource.h" #include "SkRect.h" +class GrOpList; class GrTextureProxy; class GrRenderTargetProxy; @@ -51,13 +52,17 @@ public: */ SkBudgeted isBudgeted() const { return fBudgeted; } + void setLastOpList(GrOpList* opList); + GrOpList* getLastOpList() { return fLastOpList; } + protected: // Deferred version GrSurfaceProxy(const GrSurfaceDesc& desc, SkBackingFit fit, SkBudgeted budgeted) : fDesc(desc) , fFit(fit) , fBudgeted(budgeted) - , fUniqueID(GrGpuResource::CreateUniqueID()) { + , fUniqueID(GrGpuResource::CreateUniqueID()) + , fLastOpList(nullptr) { } // Wrapped version @@ -66,10 +71,12 @@ protected: : fDesc(desc) , fFit(fit) , fBudgeted(budgeted) - , fUniqueID(uniqueID) { + , fUniqueID(uniqueID) + , fLastOpList(nullptr) { } - virtual ~GrSurfaceProxy() {} + virtual ~GrSurfaceProxy(); + // For wrapped resources, 'fDesc' will always be filled in from the wrapped resource. const GrSurfaceDesc fDesc; @@ -83,6 +90,14 @@ private: void notifyAllCntsAreZero(CntType) const { delete this; } bool notifyRefCountIsZero() const { return true; } + // The last opList that wrote to or is currently going to write to this surface + // The opList can be closed (e.g., no draw context is currently bound + // to this renderTarget). + // This back-pointer is required so that we can add a dependancy between + // the opList used to create the current contents of this surface + // and the opList of a destination surface to which this one is being drawn or copied. + GrOpList* fLastOpList; + typedef GrIORef<GrSurfaceProxy> INHERITED; // to access notifyAllCntsAreZero and notifyRefCntIsZero. diff --git a/src/core/SkTTopoSort.h b/src/core/SkTTopoSort.h index 35b85eeb81..21c80696e7 100644 --- a/src/core/SkTTopoSort.h +++ b/src/core/SkTTopoSort.h @@ -76,7 +76,7 @@ bool SkTTopoSort_Visit(T* node, SkTDArray<T*>* result) { // // TODO: potentially add a version that takes a seed node and just outputs that // node and all the nodes on which it depends. This could be used to partially -// flush a drawTarget DAG. +// flush a GrOpList DAG. template <typename T, typename Traits = T> bool SkTTopoSort(SkTDArray<T*>* graph) { SkTDArray<T*> result; diff --git a/src/gpu/GrBatchFlushState.h b/src/gpu/GrBatchFlushState.h index 89c5292eea..794bc60da4 100644 --- a/src/gpu/GrBatchFlushState.h +++ b/src/gpu/GrBatchFlushState.h @@ -15,7 +15,7 @@ class GrGpuCommandBuffer; class GrResourceProvider; -/** Tracks the state across all the GrBatches in a GrDrawTarget flush. */ +/** Tracks the state across all the GrBatches in a GrOpList flush. */ class GrBatchFlushState { public: GrBatchFlushState(GrGpu*, GrResourceProvider*); diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 176d5da59b..a0884f9274 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -90,17 +90,17 @@ void GrContext::initCommon(const GrContextOptions& options) { fDidTestPMConversions = false; - GrDrawTarget::Options dtOptions; - dtOptions.fClipBatchToBounds = options.fClipBatchToBounds; - dtOptions.fDrawBatchBounds = options.fDrawBatchBounds; - dtOptions.fMaxBatchLookback = options.fMaxBatchLookback; - dtOptions.fMaxBatchLookahead = options.fMaxBatchLookahead; + GrRenderTargetOpList::Options rtOpListOptions; + rtOpListOptions.fClipBatchToBounds = options.fClipBatchToBounds; + rtOpListOptions.fDrawBatchBounds = options.fDrawBatchBounds; + rtOpListOptions.fMaxBatchLookback = options.fMaxBatchLookback; + rtOpListOptions.fMaxBatchLookahead = options.fMaxBatchLookahead; GrPathRendererChain::Options prcOptions; prcOptions.fDisableDistanceFieldRenderer = options.fDisableDistanceFieldPaths; prcOptions.fAllowPathMaskCaching = options.fAllowPathMaskCaching; prcOptions.fDisableAllPathRenderers = options.fForceSWPathMasks; - fDrawingManager.reset(new GrDrawingManager(this, dtOptions, prcOptions, options.fImmediateMode, - &fSingleOwner)); + fDrawingManager.reset(new GrDrawingManager(this, rtOpListOptions, prcOptions, + options.fImmediateMode, &fSingleOwner)); // GrBatchFontCache will eventually replace GrFontCache fBatchFontCache = new GrBatchFontCache(this); diff --git a/src/gpu/GrDrawContext.cpp b/src/gpu/GrDrawContext.cpp index 3060062653..54de4f0ba2 100644 --- a/src/gpu/GrDrawContext.cpp +++ b/src/gpu/GrDrawContext.cpp @@ -69,10 +69,10 @@ bool GrDrawContext::wasAbandoned() const { return fDrawingManager->wasAbandoned(); } -// In MDB mode the reffing of the 'getLastDrawTarget' call's result allows in-progress -// drawTargets to be picked up and added to by drawContexts lower in the call -// stack. When this occurs with a closed drawTarget, a new one will be allocated -// when the drawContext attempts to use it (via getDrawTarget). +// In MDB mode the reffing of the 'getLastOpList' call's result allows in-progress +// GrOpLists to be picked up and added to by drawContexts lower in the call +// stack. When this occurs with a closed GrOpList, a new one will be allocated +// when the drawContext attempts to use it (via getOpList). GrDrawContext::GrDrawContext(GrContext* context, GrDrawingManager* drawingMgr, sk_sp<GrRenderTarget> rt, @@ -82,7 +82,7 @@ GrDrawContext::GrDrawContext(GrContext* context, GrSingleOwner* singleOwner) : fDrawingManager(drawingMgr) , fRenderTarget(std::move(rt)) - , fDrawTarget(SkSafeRef(fRenderTarget->getLastDrawTarget())) + , fOpList(SkSafeRef(fRenderTarget->getLastRenderTargetOpList())) , fContext(context) , fInstancedPipelineInfo(fRenderTarget.get()) , fColorSpace(std::move(colorSpace)) @@ -106,26 +106,26 @@ void GrDrawContext::validate() const { SkASSERT(fRenderTarget); ASSERT_OWNED_RESOURCE(fRenderTarget); - if (fDrawTarget && !fDrawTarget->isClosed()) { - SkASSERT(fRenderTarget->getLastDrawTarget() == fDrawTarget); + if (fOpList && !fOpList->isClosed()) { + SkASSERT(fRenderTarget->getLastOpList() == fOpList); } } #endif GrDrawContext::~GrDrawContext() { ASSERT_SINGLE_OWNER - SkSafeUnref(fDrawTarget); + SkSafeUnref(fOpList); } -GrDrawTarget* GrDrawContext::getDrawTarget() { +GrRenderTargetOpList* GrDrawContext::getOpList() { ASSERT_SINGLE_OWNER SkDEBUGCODE(this->validate();) - if (!fDrawTarget || fDrawTarget->isClosed()) { - fDrawTarget = fDrawingManager->newDrawTarget(fRenderTarget.get()); + if (!fOpList || fOpList->isClosed()) { + fOpList = fDrawingManager->newOpList(fRenderTarget.get()); } - return fDrawTarget; + return fOpList; } bool GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const SkIPoint& dstPoint) { @@ -134,7 +134,7 @@ bool GrDrawContext::copySurface(GrSurface* src, const SkIRect& srcRect, const Sk SkDEBUGCODE(this->validate();) GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::copySurface"); - return this->getDrawTarget()->copySurface(fRenderTarget.get(), src, srcRect, dstPoint); + return this->getOpList()->copySurface(fRenderTarget.get(), src, srcRect, dstPoint); } void GrDrawContext::drawText(const GrClip& clip, const GrPaint& grPaint, @@ -191,7 +191,7 @@ void GrDrawContext::discard() { GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::discard"); AutoCheckFlush acf(fDrawingManager); - this->getDrawTarget()->discard(fRenderTarget.get()); + this->getOpList()->discard(fRenderTarget.get()); } void GrDrawContext::clear(const SkIRect* rect, @@ -245,13 +245,13 @@ void GrDrawContext::internalClear(const GrFixedClip& clip, this->drawRect(clip, paint, SkMatrix::I(), clearRect); } else if (isFull) { - this->getDrawTarget()->fullClear(this->accessRenderTarget(), color); + this->getOpList()->fullClear(this->accessRenderTarget(), color); } else { sk_sp<GrBatch> batch(GrClearBatch::Make(clip, color, this->accessRenderTarget())); if (!batch) { return; } - this->getDrawTarget()->addBatch(std::move(batch)); + this->getOpList()->addBatch(std::move(batch)); } } @@ -396,7 +396,7 @@ bool GrDrawContext::drawFilledRect(const GrClip& clip, bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); batch.reset(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); @@ -405,7 +405,7 @@ bool GrDrawContext::drawFilledRect(const GrClip& clip, if (ss) { pipelineBuilder.setUserStencil(ss); } - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return true; } } @@ -423,7 +423,7 @@ bool GrDrawContext::drawFilledRect(const GrClip& clip, if (ss) { pipelineBuilder.setUserStencil(ss); } - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return true; } } @@ -549,7 +549,7 @@ void GrDrawContext::drawRect(const GrClip& clip, snapToPixelCenters); } - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -567,15 +567,15 @@ void GrDrawContextPriv::clearStencilClip(const GrFixedClip& clip, bool insideSte GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContextPriv::clearStencilClip"); AutoCheckFlush acf(fDrawContext->fDrawingManager); - fDrawContext->getDrawTarget()->clearStencilClip(clip, insideStencilMask, - fDrawContext->accessRenderTarget()); + fDrawContext->getOpList()->clearStencilClip(clip, insideStencilMask, + fDrawContext->accessRenderTarget()); } void GrDrawContextPriv::stencilPath(const GrClip& clip, bool useHWAA, const SkMatrix& viewMatrix, const GrPath* path) { - fDrawContext->getDrawTarget()->stencilPath(fDrawContext, clip, useHWAA, viewMatrix, path); + fDrawContext->getOpList()->stencilPath(fDrawContext, clip, useHWAA, viewMatrix, path); } void GrDrawContextPriv::stencilRect(const GrClip& clip, @@ -646,13 +646,13 @@ void GrDrawContext::fillRectToRect(const GrClip& clip, bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); SkAutoTUnref<GrDrawBatch> batch(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), croppedLocalRect, paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -705,13 +705,13 @@ void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip, bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); SkAutoTUnref<GrDrawBatch> batch(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), localMatrix, paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -726,7 +726,7 @@ void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip, SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix, croppedRect)); GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } @@ -776,7 +776,7 @@ void GrDrawContext::drawVertices(const GrClip& clip, colors, texCoords, bounds)); GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } /////////////////////////////////////////////////////////////////////////////// @@ -799,7 +799,7 @@ void GrDrawContext::drawAtlas(const GrClip& clip, xform, texRect, colors)); GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } /////////////////////////////////////////////////////////////////////////////// @@ -838,13 +838,13 @@ void GrDrawContext::drawRRect(const GrClip& origClip, if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() && stroke.isFillStyle()) { - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); SkAutoTUnref<GrDrawBatch> batch(ir->recordRRect(rrect, viewMatrix, paint.getColor(), paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, *clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, *clip, batch); return; } } @@ -860,7 +860,7 @@ void GrDrawContext::drawRRect(const GrClip& origClip, shaderCaps)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, *clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, *clip, batch); return; } } @@ -881,13 +881,13 @@ bool GrDrawContext::drawFilledDRRect(const GrClip& clip, if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { bool useHWAA; - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); SkAutoTUnref<GrDrawBatch> batch(ir->recordDRRect(origOuter, origInner, viewMatrix, paintIn.getColor(), paintIn.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (batch) { GrPipelineBuilder pipelineBuilder(paintIn, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return true; } } @@ -997,7 +997,7 @@ void GrDrawContext::drawRegion(const GrClip& clip, SkAutoTUnref<GrDrawBatch> batch(GrRegionBatch::Create(paint.getColor(), viewMatrix, region)); GrPipelineBuilder pipelineBuilder(paint, false); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } void GrDrawContext::drawOval(const GrClip& clip, @@ -1022,13 +1022,13 @@ void GrDrawContext::drawOval(const GrClip& clip, if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() && stroke.isFillStyle()) { - InstancedRendering* ir = this->getDrawTarget()->instancedRendering(); + InstancedRendering* ir = this->getOpList()->instancedRendering(); SkAutoTUnref<GrDrawBatch> batch(ir->recordOval(oval, viewMatrix, paint.getColor(), paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -1042,7 +1042,7 @@ void GrDrawContext::drawOval(const GrClip& clip, shaderCaps)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -1074,7 +1074,7 @@ void GrDrawContext::drawArc(const GrClip& clip, shaderCaps)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -1104,7 +1104,7 @@ void GrDrawContext::drawImageLattice(const GrClip& clip, std::move(iter), dst)); GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } void GrDrawContext::prepareForExternalIO() { @@ -1134,7 +1134,7 @@ void GrDrawContext::drawNonAAFilledRect(const GrClip& clip, if (ss) { pipelineBuilder.setUserStencil(ss); } - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } bool GrDrawContext::readPixels(const SkImageInfo& dstInfo, void* dstBuffer, size_t dstRowBytes, @@ -1246,7 +1246,7 @@ void GrDrawContext::drawPath(const GrClip& clip, paint.getColor(), viewMatrix, rects)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } return; } @@ -1263,7 +1263,7 @@ void GrDrawContext::drawPath(const GrClip& clip, shaderCaps)); if (batch) { GrPipelineBuilder pipelineBuilder(paint, useHWAA); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); return; } } @@ -1433,5 +1433,5 @@ void GrDrawContext::drawBatch(const GrPipelineBuilder& pipelineBuilder, const Gr SkDEBUGCODE(this->validate();) GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch"); - this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch); + this->getOpList()->drawBatch(pipelineBuilder, this, clip, batch); } diff --git a/src/gpu/GrDrawContextPriv.h b/src/gpu/GrDrawContextPriv.h index 63eae12a06..a48e4681d6 100644 --- a/src/gpu/GrDrawContextPriv.h +++ b/src/gpu/GrDrawContextPriv.h @@ -9,7 +9,7 @@ #define GrDrawContextPriv_DEFINED #include "GrDrawContext.h" -#include "GrDrawTarget.h" +#include "GrRenderTargetOpList.h" #include "GrPathRendering.h" class GrFixedClip; @@ -22,7 +22,7 @@ struct GrUserStencilSettings; class GrDrawContextPriv { public: gr_instanced::InstancedRendering* accessInstancedRendering() const { - return fDrawContext->getDrawTarget()->instancedRendering(); + return fDrawContext->getOpList()->instancedRendering(); } void clear(const GrFixedClip&, const GrColor, bool canIgnoreClip); diff --git a/src/gpu/GrDrawingManager.cpp b/src/gpu/GrDrawingManager.cpp index 5e9b68d88f..0fe173dac3 100644 --- a/src/gpu/GrDrawingManager.cpp +++ b/src/gpu/GrDrawingManager.cpp @@ -9,7 +9,6 @@ #include "GrContext.h" #include "GrDrawContext.h" -#include "GrDrawTarget.h" #include "GrPathRenderingDrawContext.h" #include "GrResourceProvider.h" #include "GrSoftwarePathRenderer.h" @@ -17,25 +16,21 @@ #include "SkSurface_Gpu.h" #include "SkTTopoSort.h" -#include "instanced/InstancedRendering.h" - #include "text/GrAtlasTextContext.h" #include "text/GrStencilAndCoverTextContext.h" -using gr_instanced::InstancedRendering; - void GrDrawingManager::cleanup() { - for (int i = 0; i < fDrawTargets.count(); ++i) { - fDrawTargets[i]->makeClosed(); // no drawTarget should receive a new command after this - fDrawTargets[i]->clearRT(); + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->makeClosed(); // no opList should receive a new command after this + fOpLists[i]->clearTarget(); - // We shouldn't need to do this, but it turns out some clients still hold onto drawtargets + // We shouldn't need to do this, but it turns out some clients still hold onto opLists // after a cleanup - fDrawTargets[i]->reset(); - fDrawTargets[i]->unref(); + fOpLists[i]->reset(); + fOpLists[i]->unref(); } - fDrawTargets.reset(); + fOpLists.reset(); delete fPathRendererChain; fPathRendererChain = nullptr; @@ -48,11 +43,8 @@ GrDrawingManager::~GrDrawingManager() { void GrDrawingManager::abandon() { fAbandoned = true; - for (int i = 0; i < fDrawTargets.count(); ++i) { - if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { - InstancedRendering* ir = fDrawTargets[i]->instancedRendering(); - ir->resetGpuResources(InstancedRendering::ResetType::kAbandon); - } + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->abandonGpuResources(); } this->cleanup(); } @@ -62,17 +54,14 @@ void GrDrawingManager::freeGpuResources() { delete fPathRendererChain; fPathRendererChain = nullptr; SkSafeSetNull(fSoftwarePathRenderer); - for (int i = 0; i < fDrawTargets.count(); ++i) { - if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { - InstancedRendering* ir = fDrawTargets[i]->instancedRendering(); - ir->resetGpuResources(InstancedRendering::ResetType::kDestroy); - } + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->freeGpuResources(); } } void GrDrawingManager::reset() { - for (int i = 0; i < fDrawTargets.count(); ++i) { - fDrawTargets[i]->reset(); + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->reset(); } fFlushState.reset(); } @@ -84,48 +73,48 @@ void GrDrawingManager::internalFlush(GrResourceCache::FlushType type) { fFlushing = true; bool flushed = false; SkDEBUGCODE(bool result =) - SkTTopoSort<GrDrawTarget, GrDrawTarget::TopoSortTraits>(&fDrawTargets); + SkTTopoSort<GrOpList, GrOpList::TopoSortTraits>(&fOpLists); SkASSERT(result); - for (int i = 0; i < fDrawTargets.count(); ++i) { - fDrawTargets[i]->prepareBatches(&fFlushState); + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->prepareBatches(&fFlushState); } // Enable this to print out verbose batching information #if 0 - for (int i = 0; i < fDrawTargets.count(); ++i) { - SkDEBUGCODE(fDrawTargets[i]->dump();) + for (int i = 0; i < fOpLists.count(); ++i) { + SkDEBUGCODE(fOpLists[i]->dump();) } #endif // Upload all data to the GPU fFlushState.preIssueDraws(); - for (int i = 0; i < fDrawTargets.count(); ++i) { - if (fDrawTargets[i]->drawBatches(&fFlushState)) { + for (int i = 0; i < fOpLists.count(); ++i) { + if (fOpLists[i]->drawBatches(&fFlushState)) { flushed = true; } } SkASSERT(fFlushState.nextDrawToken() == fFlushState.nextTokenToFlush()); - for (int i = 0; i < fDrawTargets.count(); ++i) { - fDrawTargets[i]->reset(); + for (int i = 0; i < fOpLists.count(); ++i) { + fOpLists[i]->reset(); #ifdef ENABLE_MDB - fDrawTargets[i]->unref(); + fOpLists[i]->unref(); #endif } #ifndef ENABLE_MDB - // When MDB is disabled we keep reusing the same drawTarget - if (fDrawTargets.count()) { - SkASSERT(fDrawTargets.count() == 1); + // When MDB is disabled we keep reusing the same GrOpList + if (fOpLists.count()) { + SkASSERT(fOpLists.count() == 1); // Clear out this flag so the topological sort's SkTTopoSort_CheckAllUnmarked check // won't bark - fDrawTargets[0]->resetFlag(GrDrawTarget::kWasOutput_Flag); + fOpLists[0]->resetFlag(GrOpList::kWasOutput_Flag); } #else - fDrawTargets.reset(); + fOpLists.reset(); #endif fFlushState.reset(); @@ -153,28 +142,33 @@ void GrDrawingManager::prepareSurfaceForExternalIO(GrSurface* surface) { } } -GrDrawTarget* GrDrawingManager::newDrawTarget(GrRenderTarget* rt) { +GrRenderTargetOpList* GrDrawingManager::newOpList(GrRenderTarget* rt) { SkASSERT(fContext); #ifndef ENABLE_MDB - // When MDB is disabled we always just return the single drawTarget - if (fDrawTargets.count()) { - SkASSERT(fDrawTargets.count() == 1); - // In the non-MDB-world the same drawTarget gets reused for multiple render targets. + // When MDB is disabled we always just return the single GrOpList + if (fOpLists.count()) { + SkASSERT(fOpLists.count() == 1); + // In the non-MDB-world the same GrOpList gets reused for multiple render targets. // Update this pointer so all the asserts are happy - rt->setLastDrawTarget(fDrawTargets[0]); + rt->setLastOpList(fOpLists[0]); // DrawingManager gets the creation ref - this ref is for the caller - return SkRef(fDrawTargets[0]); + + // TODO: although this is true right now it isn't cool + return SkRef((GrRenderTargetOpList*) fOpLists[0]); } #endif - GrDrawTarget* dt = new GrDrawTarget(rt, fContext->getGpu(), fContext->resourceProvider(), - fContext->getAuditTrail(), fOptionsForDrawTargets); + GrRenderTargetOpList* opList = new GrRenderTargetOpList(rt, + fContext->getGpu(), + fContext->resourceProvider(), + fContext->getAuditTrail(), + fOptionsForOpLists); - *fDrawTargets.append() = dt; + *fOpLists.append() = opList; // DrawingManager gets the creation ref - this ref is for the caller - return SkRef(dt); + return SkRef(opList); } GrAtlasTextContext* GrDrawingManager::getAtlasTextContext() { diff --git a/src/gpu/GrDrawingManager.h b/src/gpu/GrDrawingManager.h index 9fced38163..838bb9b75e 100644 --- a/src/gpu/GrDrawingManager.h +++ b/src/gpu/GrDrawingManager.h @@ -9,23 +9,24 @@ #define GrDrawingManager_DEFINED #include "text/GrAtlasTextContext.h" -#include "GrDrawTarget.h" #include "GrBatchFlushState.h" #include "GrPathRendererChain.h" #include "GrPathRenderer.h" +#include "GrRenderTargetOpList.h" #include "GrResourceCache.h" #include "SkTDArray.h" + class GrContext; class GrDrawContext; class GrSingleOWner; class GrSoftwarePathRenderer; // The GrDrawingManager allocates a new GrDrawContext for each GrRenderTarget -// but all of them still land in the same GrDrawTarget! +// but all of them still land in the same GrOpList! // // In the future this class will allocate a new GrDrawContext for -// each GrRenderTarget/GrDrawTarget and manage the DAG. +// each GrRenderTarget/GrOpList and manage the DAG. class GrDrawingManager { public: ~GrDrawingManager(); @@ -37,9 +38,9 @@ public: sk_sp<SkColorSpace>, const SkSurfaceProps*); - // The caller automatically gets a ref on the returned drawTarget. It must + // The caller automatically gets a ref on the returned opList. It must // be balanced by an unref call. - GrDrawTarget* newDrawTarget(GrRenderTarget* rt); + GrRenderTargetOpList* newOpList(GrRenderTarget* rt); GrContext* getContext() { return fContext; } @@ -63,11 +64,12 @@ public: void prepareSurfaceForExternalIO(GrSurface*); private: - GrDrawingManager(GrContext* context, const GrDrawTarget::Options& optionsForDrawTargets, + GrDrawingManager(GrContext* context, + const GrRenderTargetOpList::Options& optionsForOpLists, const GrPathRendererChain::Options& optionsForPathRendererChain, bool isImmediateMode, GrSingleOwner* singleOwner) : fContext(context) - , fOptionsForDrawTargets(optionsForDrawTargets) + , fOptionsForOpLists(optionsForOpLists) , fOptionsForPathRendererChain(optionsForPathRendererChain) , fSingleOwner(singleOwner) , fAbandoned(false) @@ -91,14 +93,14 @@ private: static const int kNumDFTOptions = 2; // DFT or no DFT GrContext* fContext; - GrDrawTarget::Options fOptionsForDrawTargets; + GrRenderTargetOpList::Options fOptionsForOpLists; GrPathRendererChain::Options fOptionsForPathRendererChain; // In debug builds we guard against improper thread handling GrSingleOwner* fSingleOwner; bool fAbandoned; - SkTDArray<GrDrawTarget*> fDrawTargets; + SkTDArray<GrOpList*> fOpLists; SkAutoTDelete<GrAtlasTextContext> fAtlasTextContext; diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h index b8703dc68e..ba7ed6f47e 100644 --- a/src/gpu/GrGpu.h +++ b/src/gpu/GrGpu.h @@ -331,7 +331,7 @@ public: ResetTimestamp getResetTimestamp() const { return fResetTimestamp; } // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst - // take place at the GrDrawTarget level and this function implement faster copy paths. The rect + // take place at the GrOpList level and this function implement faster copy paths. The rect // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the // src/dst bounds and non-empty. bool copySurface(GrSurface* dst, @@ -360,16 +360,16 @@ public: // multisample information itself. const MultisampleSpecs& getMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&); - // Creates a GrGpuCommandBuffer in which the GrDrawTarget can send draw commands to instead of + // Creates a GrGpuCommandBuffer in which the GrOpList can send draw commands to instead of // directly to the Gpu object. virtual GrGpuCommandBuffer* createCommandBuffer( GrRenderTarget* target, const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo, const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) = 0; - // Called by drawtarget when flushing. + // Called by GrOpList when flushing. // Provides a hook for post-flush actions (e.g. PLS reset and Vulkan command buffer submits). - virtual void finishDrawTarget() {} + virtual void finishOpList() {} virtual GrFence SK_WARN_UNUSED_RESULT insertFence() const = 0; virtual bool waitFence(GrFence, uint64_t timeout = 1000) const = 0; diff --git a/src/gpu/GrOpList.cpp b/src/gpu/GrOpList.cpp new file mode 100644 index 0000000000..ac7f1b274d --- /dev/null +++ b/src/gpu/GrOpList.cpp @@ -0,0 +1,71 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "GrOpList.h" + +#include "GrRenderTarget.h" +#include "GrRenderTargetOpList.h" +#include "GrSurface.h" + +GrOpList::GrOpList(GrSurface* surface) + : fFlags(0) + , fTarget(surface) { + + surface->setLastOpList(this); + +#ifdef SK_DEBUG + static int debugID = 0; + fDebugID = debugID++; +#endif +} + +GrOpList::~GrOpList() { + if (fTarget && this == fTarget->getLastOpList()) { + fTarget->setLastOpList(nullptr); + } +} + +// Add a GrOpList-based dependency +void GrOpList::addDependency(GrOpList* dependedOn) { + SkASSERT(!dependedOn->dependsOn(this)); // loops are bad + + if (this->dependsOn(dependedOn)) { + return; // don't add duplicate dependencies + } + + *fDependencies.push() = dependedOn; +} + +// Convert from a GrSurface-based dependency to a GrOpList one +void GrOpList::addDependency(GrSurface* dependedOn) { + if (dependedOn->getLastOpList()) { + // If it is still receiving dependencies, this GrOpList shouldn't be closed + SkASSERT(!this->isClosed()); + + GrOpList* opList = dependedOn->getLastOpList(); + if (opList == this) { + // self-read - presumably for dst reads + } else { + this->addDependency(opList); + + // Can't make it closed in the self-read case + opList->makeClosed(); + } + } +} + +#ifdef SK_DEBUG +void GrOpList::dump() const { + SkDebugf("--------------------------------------------------------------\n"); + SkDebugf("node: %d -> RT: %d\n", fDebugID, fTarget ? fTarget->uniqueID() : -1); + SkDebugf("relies On (%d): ", fDependencies.count()); + for (int i = 0; i < fDependencies.count(); ++i) { + SkDebugf("%d, ", fDependencies[i]->fDebugID); + } + SkDebugf("\n"); +} +#endif diff --git a/src/gpu/GrOpList.h b/src/gpu/GrOpList.h new file mode 100644 index 0000000000..4af85128b6 --- /dev/null +++ b/src/gpu/GrOpList.h @@ -0,0 +1,124 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef GrOpList_DEFINED +#define GrOpList_DEFINED + +#include "SkRefCnt.h" +#include "SkTDArray.h" + +//#define ENABLE_MDB 1 + +class GrBatchFlushState; +class GrSurface; + +class GrOpList : public SkRefCnt { +public: + GrOpList(GrSurface* surface); + ~GrOpList() override; + + virtual void prepareBatches(GrBatchFlushState* flushState) = 0; + virtual bool drawBatches(GrBatchFlushState* flushState) = 0; + + virtual void makeClosed() { + // We only close GrOpLists when MDB is enabled. When MDB is disabled there is only + // ever one GrOpLists and all calls will be funnelled into it. +#ifdef ENABLE_MDB + this->setFlag(kClosed_Flag); +#endif + } + + // TODO: it seems a bit odd that GrOpList has nothing to clear on reset + virtual void reset() = 0; + + // TODO: in an MDB world, where the OpLists don't allocate GPU resources, it seems like + // these could go away + virtual void abandonGpuResources() = 0; + virtual void freeGpuResources() = 0; + + // TODO: this entry point is only needed in the non-MDB world. Remove when + // we make the switch to MDB + void clearTarget() { fTarget = nullptr; } + + bool isClosed() const { return this->isSetFlag(kClosed_Flag); } + + /* + * Notify this GrOpList that it relies on the contents of 'dependedOn' + */ + void addDependency(GrSurface* dependedOn); + + /* + * Does this opList depend on 'dependedOn'? + */ + bool dependsOn(GrOpList* dependedOn) const { + return fDependencies.find(dependedOn) >= 0; + } + + /* + * Dump out the GrOpList dependency DAG + */ + SkDEBUGCODE(virtual void dump() const;) + +private: + friend class GrDrawingManager; // for resetFlag & TopoSortTraits + + enum Flags { + kClosed_Flag = 0x01, //!< This GrOpList can't accept any more batches + + kWasOutput_Flag = 0x02, //!< Flag for topological sorting + kTempMark_Flag = 0x04, //!< Flag for topological sorting + }; + + void setFlag(uint32_t flag) { + fFlags |= flag; + } + + void resetFlag(uint32_t flag) { + fFlags &= ~flag; + } + + bool isSetFlag(uint32_t flag) const { + return SkToBool(fFlags & flag); + } + + struct TopoSortTraits { + static void Output(GrOpList* dt, int /* index */) { + dt->setFlag(GrOpList::kWasOutput_Flag); + } + static bool WasOutput(const GrOpList* dt) { + return dt->isSetFlag(GrOpList::kWasOutput_Flag); + } + static void SetTempMark(GrOpList* dt) { + dt->setFlag(GrOpList::kTempMark_Flag); + } + static void ResetTempMark(GrOpList* dt) { + dt->resetFlag(GrOpList::kTempMark_Flag); + } + static bool IsTempMarked(const GrOpList* dt) { + return dt->isSetFlag(GrOpList::kTempMark_Flag); + } + static int NumDependencies(const GrOpList* dt) { + return dt->fDependencies.count(); + } + static GrOpList* Dependency(GrOpList* dt, int index) { + return dt->fDependencies[index]; + } + }; + + void addDependency(GrOpList* dependedOn); + + SkDEBUGCODE(int fDebugID;) + uint32_t fFlags; + GrSurface* fTarget; + + // 'this' GrOpList relies on the output of the GrOpLists in 'fDependencies' + SkTDArray<GrOpList*> fDependencies; + + typedef SkRefCnt INHERITED; +}; + +#endif diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h index 37cc3f9863..3ac18144e0 100644 --- a/src/gpu/GrPathRenderer.h +++ b/src/gpu/GrPathRenderer.h @@ -22,7 +22,7 @@ class GrFixedClip; struct GrPoint; /** - * Base class for drawing paths into a GrDrawTarget. + * Base class for drawing paths into a GrOpList. * * Derived classes can use stages GrPaint::kTotalStages through GrPipelineBuilder::kNumStages-1. * The stages before GrPaint::kTotalStages are reserved for setting up the draw (i.e., textures and diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp index d9ebcf85f9..5e658fcc87 100644 --- a/src/gpu/GrPipeline.cpp +++ b/src/gpu/GrPipeline.cpp @@ -9,10 +9,10 @@ #include "GrCaps.h" #include "GrDrawContext.h" -#include "GrDrawTarget.h" #include "GrGpu.h" #include "GrPipelineBuilder.h" #include "GrProcOptInfo.h" +#include "GrRenderTargetOpList.h" #include "GrRenderTargetPriv.h" #include "GrXferProcessor.h" @@ -178,8 +178,8 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args, static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) { GrFragmentProcessor::TextureAccessIter iter(proc); while (const GrTextureAccess* access = iter.next()) { - SkASSERT(rt->getLastDrawTarget()); - rt->getLastDrawTarget()->addDependency(access->getTexture()); + SkASSERT(rt->getLastOpList()); + rt->getLastOpList()->addDependency(access->getTexture()); } } @@ -192,8 +192,8 @@ void GrPipeline::addDependenciesTo(GrRenderTarget* rt) const { for (int i = 0; i < xfer.numTextures(); ++i) { GrTexture* texture = xfer.textureAccess(i).getTexture(); - SkASSERT(rt->getLastDrawTarget()); - rt->getLastDrawTarget()->addDependency(texture); + SkASSERT(rt->getLastOpList()); + rt->getLastOpList()->addDependency(texture); } } diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h index 845044f720..6330de18d9 100644 --- a/src/gpu/GrPipeline.h +++ b/src/gpu/GrPipeline.h @@ -105,8 +105,8 @@ public: /////////////////////////////////////////////////////////////////////////// /// @name GrFragmentProcessors - // Make the renderTarget's drawTarget (if it exists) be dependent on any - // drawTargets in this pipeline + // Make the renderTarget's GrOpList (if it exists) be dependent on any + // GrOpLists in this pipeline void addDependenciesTo(GrRenderTarget* rt) const; int numColorFragmentProcessors() const { return fNumColorProcessors; } diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h index 0c33eb344f..cb69756b69 100644 --- a/src/gpu/GrPipelineBuilder.h +++ b/src/gpu/GrPipelineBuilder.h @@ -311,7 +311,10 @@ private: FragmentProcessorArray fCoverageFragmentProcessors; friend class GrPipeline; - friend class GrDrawTarget; + // This gives the GrRenderTargetOpList raw access to fColorFragmentProcessors & + // fCoverageFragmentProcessors + // TODO: that access seems a little dodgy + friend class GrRenderTargetOpList; }; #endif diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h index 00b4df01ed..561f54be03 100644 --- a/src/gpu/GrPrimitiveProcessor.h +++ b/src/gpu/GrPrimitiveProcessor.h @@ -171,7 +171,7 @@ public: const Attribute& getAttrib(int index) const { return fAttribs[index]; } // Returns the vertex stride of the GP. A common use case is to request geometry from a - // drawtarget based off of the stride, and to populate this memory using an implicit array of + // GrOpList based off of the stride, and to populate this memory using an implicit array of // structs. In this case, it is best to assert the vertexstride == sizeof(VertexStruct). size_t getVertexStride() const { return fVertexStride; } diff --git a/src/gpu/GrRenderTarget.cpp b/src/gpu/GrRenderTarget.cpp index 2053a166e5..d28b2b4191 100644 --- a/src/gpu/GrRenderTarget.cpp +++ b/src/gpu/GrRenderTarget.cpp @@ -11,8 +11,8 @@ #include "GrContext.h" #include "GrContextPriv.h" #include "GrDrawContext.h" -#include "GrDrawTarget.h" #include "GrGpu.h" +#include "GrRenderTargetOpList.h" #include "GrRenderTargetPriv.h" #include "GrStencilAttachment.h" @@ -21,20 +21,12 @@ GrRenderTarget::GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc, Flags flag : INHERITED(gpu, desc) , fStencilAttachment(stencil) , fMultisampleSpecsID(0) - , fFlags(flags) - , fLastDrawTarget(nullptr) { + , fFlags(flags) { SkASSERT(!(fFlags & Flags::kMixedSampled) || fDesc.fSampleCnt > 0); SkASSERT(!(fFlags & Flags::kWindowRectsSupport) || gpu->caps()->maxWindowRectangles() > 0); fResolveRect.setLargestInverted(); } -GrRenderTarget::~GrRenderTarget() { - if (fLastDrawTarget) { - fLastDrawTarget->clearRT(); - } - SkSafeUnref(fLastDrawTarget); -} - void GrRenderTarget::discard() { // go through context so that all necessary flushing occurs GrContext* context = this->getContext(); @@ -85,24 +77,12 @@ void GrRenderTarget::onAbandon() { SkSafeSetNull(fStencilAttachment); // The contents of this renderTarget are gone/invalid. It isn't useful to point back - // the creating drawTarget. - this->setLastDrawTarget(nullptr); + // the creating opList. + this->setLastOpList(nullptr); INHERITED::onAbandon(); } -void GrRenderTarget::setLastDrawTarget(GrDrawTarget* dt) { - if (fLastDrawTarget) { - // The non-MDB world never closes so we can't check this condition -#ifdef ENABLE_MDB - SkASSERT(fLastDrawTarget->isClosed()); -#endif - fLastDrawTarget->clearRT(); - } - - SkRefCnt_SafeAssign(fLastDrawTarget, dt); -} - /////////////////////////////////////////////////////////////////////////////// bool GrRenderTargetPriv::attachStencilAttachment(GrStencilAttachment* stencil) { diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrRenderTargetOpList.cpp index 5b2530fa5a..0dbb7772eb 100644 --- a/src/gpu/GrDrawTarget.cpp +++ b/src/gpu/GrRenderTargetOpList.cpp @@ -5,7 +5,7 @@ * found in the LICENSE file. */ -#include "GrDrawTarget.h" +#include "GrRenderTargetOpList.h" #include "GrAppliedClip.h" #include "GrAuditTrail.h" @@ -38,20 +38,22 @@ #include "instanced/InstancedRendering.h" +using gr_instanced::InstancedRendering; + //////////////////////////////////////////////////////////////////////////////// // Experimentally we have found that most batching occurs within the first 10 comparisons. static const int kDefaultMaxBatchLookback = 10; static const int kDefaultMaxBatchLookahead = 10; -GrDrawTarget::GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider* resourceProvider, - GrAuditTrail* auditTrail, const Options& options) - : fLastFullClearBatch(nullptr) +GrRenderTargetOpList::GrRenderTargetOpList(GrRenderTarget* rt, GrGpu* gpu, + GrResourceProvider* resourceProvider, + GrAuditTrail* auditTrail, const Options& options) + : INHERITED(rt) + , fLastFullClearBatch(nullptr) , fGpu(SkRef(gpu)) , fResourceProvider(resourceProvider) - , fAuditTrail(auditTrail) - , fFlags(0) - , fRenderTarget(rt) { + , fAuditTrail(auditTrail) { // TODO: Stop extracting the context (currently needed by GrClip) fContext = fGpu->getContext(); @@ -65,63 +67,18 @@ GrDrawTarget::GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider* r if (GrCaps::InstancedSupport::kNone != this->caps()->instancedSupport()) { fInstancedRendering.reset(fGpu->createInstancedRendering()); } - - rt->setLastDrawTarget(this); - -#ifdef SK_DEBUG - static int debugID = 0; - fDebugID = debugID++; -#endif } -GrDrawTarget::~GrDrawTarget() { - if (fRenderTarget && this == fRenderTarget->getLastDrawTarget()) { - fRenderTarget->setLastDrawTarget(nullptr); - } - +GrRenderTargetOpList::~GrRenderTargetOpList() { fGpu->unref(); } //////////////////////////////////////////////////////////////////////////////// -// Add a GrDrawTarget-based dependency -void GrDrawTarget::addDependency(GrDrawTarget* dependedOn) { - SkASSERT(!dependedOn->dependsOn(this)); // loops are bad - - if (this->dependsOn(dependedOn)) { - return; // don't add duplicate dependencies - } - - *fDependencies.push() = dependedOn; -} - -// Convert from a GrSurface-based dependency to a GrDrawTarget one -void GrDrawTarget::addDependency(GrSurface* dependedOn) { - if (dependedOn->asRenderTarget() && dependedOn->asRenderTarget()->getLastDrawTarget()) { - // If it is still receiving dependencies, this DT shouldn't be closed - SkASSERT(!this->isClosed()); - - GrDrawTarget* dt = dependedOn->asRenderTarget()->getLastDrawTarget(); - if (dt == this) { - // self-read - presumably for dst reads - } else { - this->addDependency(dt); - - // Can't make it closed in the self-read case - dt->makeClosed(); - } - } -} - #ifdef SK_DEBUG -void GrDrawTarget::dump() const { - SkDebugf("--------------------------------------------------------------\n"); - SkDebugf("node: %d -> RT: %d\n", fDebugID, fRenderTarget ? fRenderTarget->uniqueID() : -1); - SkDebugf("relies On (%d): ", fDependencies.count()); - for (int i = 0; i < fDependencies.count(); ++i) { - SkDebugf("%d, ", fDependencies[i]->fDebugID); - } - SkDebugf("\n"); +void GrRenderTargetOpList::dump() const { + INHERITED::dump(); + SkDebugf("batches (%d):\n", fRecordedBatches.count()); for (int i = 0; i < fRecordedBatches.count(); ++i) { SkDebugf("*******************************\n"); @@ -140,12 +97,12 @@ void GrDrawTarget::dump() const { } #endif -bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder, - GrRenderTarget* rt, - const GrClip& clip, - const GrPipelineOptimizations& optimizations, - GrXferProcessor::DstTexture* dstTexture, - const SkRect& batchBounds) { +bool GrRenderTargetOpList::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder, + GrRenderTarget* rt, + const GrClip& clip, + const GrPipelineOptimizations& optimizations, + GrXferProcessor::DstTexture* dstTexture, + const SkRect& batchBounds) { SkRect bounds = batchBounds; bounds.outset(0.5f, 0.5f); @@ -202,11 +159,11 @@ bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuil return true; } -void GrDrawTarget::prepareBatches(GrBatchFlushState* flushState) { - // Semi-usually the drawTargets are already closed at this point, but sometimes Ganesh - // needs to flush mid-draw. In that case, the SkGpuDevice's drawTargets won't be closed - // but need to be flushed anyway. Closing such drawTargets here will mean new - // drawTargets will be created to replace them if the SkGpuDevice(s) write to them again. +void GrRenderTargetOpList::prepareBatches(GrBatchFlushState* flushState) { + // Semi-usually the GrOpLists are already closed at this point, but sometimes Ganesh + // needs to flush mid-draw. In that case, the SkGpuDevice's GrOpLists won't be closed + // but need to be flushed anyway. Closing such GrOpLists here will mean new + // GrOpLists will be created to replace them if the SkGpuDevice(s) write to them again. this->makeClosed(); // Loop over the batches that haven't yet generated their geometry @@ -221,7 +178,7 @@ void GrDrawTarget::prepareBatches(GrBatchFlushState* flushState) { } } -bool GrDrawTarget::drawBatches(GrBatchFlushState* flushState) { +bool GrRenderTargetOpList::drawBatches(GrBatchFlushState* flushState) { if (0 == fRecordedBatches.count()) { return false; } @@ -268,11 +225,11 @@ bool GrDrawTarget::drawBatches(GrBatchFlushState* flushState) { flushState->setCommandBuffer(nullptr); } - fGpu->finishDrawTarget(); + fGpu->finishOpList(); return true; } -void GrDrawTarget::reset() { +void GrRenderTargetOpList::reset() { fLastFullClearBatch = nullptr; fRecordedBatches.reset(); if (fInstancedRendering) { @@ -280,6 +237,20 @@ void GrDrawTarget::reset() { } } +void GrRenderTargetOpList::abandonGpuResources() { + if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { + InstancedRendering* ir = this->instancedRendering(); + ir->resetGpuResources(InstancedRendering::ResetType::kAbandon); + } +} + +void GrRenderTargetOpList::freeGpuResources() { + if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { + InstancedRendering* ir = this->instancedRendering(); + ir->resetGpuResources(InstancedRendering::ResetType::kDestroy); + } +} + static void batch_bounds(SkRect* bounds, const GrBatch* batch) { *bounds = batch->bounds(); if (batch->hasZeroArea()) { @@ -306,10 +277,10 @@ static void batch_bounds(SkRect* bounds, const GrBatch* batch) { } } -void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder, - GrDrawContext* drawContext, - const GrClip& clip, - GrDrawBatch* batch) { +void GrRenderTargetOpList::drawBatch(const GrPipelineBuilder& pipelineBuilder, + GrDrawContext* drawContext, + const GrClip& clip, + GrDrawBatch* batch) { // Setup clip SkRect bounds; batch_bounds(&bounds, batch); @@ -377,17 +348,17 @@ void GrDrawTarget::drawBatch(const GrPipelineBuilder& pipelineBuilder, } #ifdef ENABLE_MDB - SkASSERT(fRenderTarget); - batch->pipeline()->addDependenciesTo(fRenderTarget); + SkASSERT(fSurface); + batch->pipeline()->addDependenciesTo(fSurface); #endif this->recordBatch(batch, appliedClip.clippedDrawBounds()); } -void GrDrawTarget::stencilPath(GrDrawContext* drawContext, - const GrClip& clip, - bool useHWAA, - const SkMatrix& viewMatrix, - const GrPath* path) { +void GrRenderTargetOpList::stencilPath(GrDrawContext* drawContext, + const GrClip& clip, + bool useHWAA, + const SkMatrix& viewMatrix, + const GrPath* path) { // TODO: extract portions of checkDraw that are relevant to path stenciling. SkASSERT(path); SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport()); @@ -426,11 +397,11 @@ void GrDrawTarget::stencilPath(GrDrawContext* drawContext, batch->unref(); } -void GrDrawTarget::addBatch(sk_sp<GrBatch> batch) { +void GrRenderTargetOpList::addBatch(sk_sp<GrBatch> batch) { this->recordBatch(batch.get(), batch->bounds()); } -void GrDrawTarget::fullClear(GrRenderTarget* renderTarget, GrColor color) { +void GrRenderTargetOpList::fullClear(GrRenderTarget* renderTarget, 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. @@ -448,7 +419,7 @@ void GrDrawTarget::fullClear(GrRenderTarget* renderTarget, GrColor color) { } } -void GrDrawTarget::discard(GrRenderTarget* renderTarget) { +void GrRenderTargetOpList::discard(GrRenderTarget* renderTarget) { // 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()) { @@ -460,10 +431,10 @@ void GrDrawTarget::discard(GrRenderTarget* renderTarget) { //////////////////////////////////////////////////////////////////////////////// -bool GrDrawTarget::copySurface(GrSurface* dst, - GrSurface* src, - const SkIRect& srcRect, - const SkIPoint& dstPoint) { +bool GrRenderTargetOpList::copySurface(GrSurface* dst, + GrSurface* src, + const SkIRect& srcRect, + const SkIPoint& dstPoint) { GrBatch* batch = GrCopySurfaceBatch::Create(dst, src, srcRect, dstPoint); if (!batch) { return false; @@ -491,8 +462,8 @@ static void join(SkRect* out, const SkRect& a, const SkRect& b) { out->fBottom = SkTMax(a.fBottom, b.fBottom); } -GrBatch* GrDrawTarget::recordBatch(GrBatch* batch, const SkRect& clippedBounds) { - // A closed drawTarget should never receive new/more batches +GrBatch* GrRenderTargetOpList::recordBatch(GrBatch* batch, const SkRect& clippedBounds) { + // A closed GrOpList should never receive new/more batches SkASSERT(!this->isClosed()); // Check if there is a Batch Draw we can batch with by linearly searching back until we either @@ -552,7 +523,7 @@ GrBatch* GrDrawTarget::recordBatch(GrBatch* batch, const SkRect& clippedBounds) return batch; } -void GrDrawTarget::forwardCombine() { +void GrRenderTargetOpList::forwardCombine() { if (fMaxBatchLookahead <= 0) { return; } @@ -600,9 +571,9 @@ void GrDrawTarget::forwardCombine() { /////////////////////////////////////////////////////////////////////////////// -void GrDrawTarget::clearStencilClip(const GrFixedClip& clip, - bool insideStencilMask, - GrRenderTarget* rt) { +void GrRenderTargetOpList::clearStencilClip(const GrFixedClip& clip, + bool insideStencilMask, + GrRenderTarget* rt) { GrBatch* batch = new GrClearStencilClipBatch(clip, insideStencilMask, rt); this->recordBatch(batch, batch->bounds()); batch->unref(); diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrRenderTargetOpList.h index 35de239150..080ff69ce4 100644 --- a/src/gpu/GrDrawTarget.h +++ b/src/gpu/GrRenderTargetOpList.h @@ -5,11 +5,12 @@ * found in the LICENSE file. */ -#ifndef GrDrawTarget_DEFINED -#define GrDrawTarget_DEFINED +#ifndef GrRenderTargetOpList_DEFINED +#define GrRenderTargetOpList_DEFINED #include "GrClip.h" #include "GrContext.h" +#include "GrOpList.h" #include "GrPathProcessor.h" #include "GrPrimitiveProcessor.h" #include "GrPathRendering.h" @@ -27,8 +28,6 @@ #include "SkTypes.h" #include "SkXfermode.h" -//#define ENABLE_MDB 1 - class GrAuditTrail; class GrBatch; class GrClearBatch; @@ -38,9 +37,9 @@ class GrPath; class GrDrawPathBatchBase; class GrPipelineBuilder; -class GrDrawTarget final : public SkRefCnt { +class GrRenderTargetOpList final : public GrOpList { public: - /** Options for GrDrawTarget behavior. */ + /** Options for GrRenderTargetOpList behavior. */ struct Options { Options () : fClipBatchToBounds(false) @@ -53,54 +52,32 @@ public: int fMaxBatchLookahead; }; - GrDrawTarget(GrRenderTarget*, GrGpu*, GrResourceProvider*, GrAuditTrail*, const Options&); + GrRenderTargetOpList(GrRenderTarget*, GrGpu*, GrResourceProvider*, + GrAuditTrail*, const Options&); + + ~GrRenderTargetOpList() override; - ~GrDrawTarget() override; + void makeClosed() override { + INHERITED::makeClosed(); - void makeClosed() { fLastFullClearBatch = nullptr; - // We only close drawTargets When MDB is enabled. When MDB is disabled there is only - // ever one drawTarget and all calls will be funnelled into it. -#ifdef ENABLE_MDB - this->setFlag(kClosed_Flag); -#endif this->forwardCombine(); } - bool isClosed() const { return this->isSetFlag(kClosed_Flag); } - - // TODO: this entry point is only needed in the non-MDB world. Remove when - // we make the switch to MDB - void clearRT() { fRenderTarget = nullptr; } - - /* - * Notify this drawTarget that it relies on the contents of 'dependedOn' - */ - void addDependency(GrSurface* dependedOn); - - /* - * Does this drawTarget depend on 'dependedOn'? - */ - bool dependsOn(GrDrawTarget* dependedOn) const { - return fDependencies.find(dependedOn) >= 0; - } - - /* - * Dump out the drawTarget dependency DAG - */ - SkDEBUGCODE(void dump() const;) - /** * Empties the draw buffer of any queued up draws. */ - void reset(); + void reset() override; + + void abandonGpuResources() override; + void freeGpuResources() override; /** * Together these two functions flush all queued up draws to GrCommandBuffer. The return value * of drawBatches() indicates whether any commands were actually issued to the GPU. */ - void prepareBatches(GrBatchFlushState* flushState); - bool drawBatches(GrBatchFlushState* flushState); + void prepareBatches(GrBatchFlushState* flushState) override; + bool drawBatches(GrBatchFlushState* flushState) override; /** * Gets the capabilities of the draw target. @@ -150,53 +127,11 @@ public: return fInstancedRendering; } + SkDEBUGCODE(void dump() const override;) + private: - friend class GrDrawingManager; // for resetFlag & TopoSortTraits friend class GrDrawContextPriv; // for clearStencilClip - enum Flags { - kClosed_Flag = 0x01, //!< This drawTarget can't accept any more batches - - kWasOutput_Flag = 0x02, //!< Flag for topological sorting - kTempMark_Flag = 0x04, //!< Flag for topological sorting - }; - - void setFlag(uint32_t flag) { - fFlags |= flag; - } - - void resetFlag(uint32_t flag) { - fFlags &= ~flag; - } - - bool isSetFlag(uint32_t flag) const { - return SkToBool(fFlags & flag); - } - - struct TopoSortTraits { - static void Output(GrDrawTarget* dt, int /* index */) { - dt->setFlag(GrDrawTarget::kWasOutput_Flag); - } - static bool WasOutput(const GrDrawTarget* dt) { - return dt->isSetFlag(GrDrawTarget::kWasOutput_Flag); - } - static void SetTempMark(GrDrawTarget* dt) { - dt->setFlag(GrDrawTarget::kTempMark_Flag); - } - static void ResetTempMark(GrDrawTarget* dt) { - dt->resetFlag(GrDrawTarget::kTempMark_Flag); - } - static bool IsTempMarked(const GrDrawTarget* dt) { - return dt->isSetFlag(GrDrawTarget::kTempMark_Flag); - } - static int NumDependencies(const GrDrawTarget* dt) { - return dt->fDependencies.count(); - } - static GrDrawTarget* Dependency(GrDrawTarget* dt, int index) { - return dt->fDependencies[index]; - } - }; - // Returns the batch that the input batch was combined with or the input batch if it wasn't // combined. GrBatch* recordBatch(GrBatch*, const SkRect& clippedBounds); @@ -212,8 +147,6 @@ private: GrXferProcessor::DstTexture*, const SkRect& batchBounds); - void addDependency(GrDrawTarget* dependedOn); - // Used only by drawContextPriv. void clearStencilClip(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*); @@ -229,13 +162,6 @@ private: GrResourceProvider* fResourceProvider; GrAuditTrail* fAuditTrail; - SkDEBUGCODE(int fDebugID;) - uint32_t fFlags; - - // 'this' drawTarget relies on the output of the drawTargets in 'fDependencies' - SkTDArray<GrDrawTarget*> fDependencies; - GrRenderTarget* fRenderTarget; - bool fClipBatchToBounds; bool fDrawBatchBounds; int fMaxBatchLookback; @@ -243,7 +169,7 @@ private: SkAutoTDelete<gr_instanced::InstancedRendering> fInstancedRendering; - typedef SkRefCnt INHERITED; + typedef GrOpList INHERITED; }; #endif diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp index fa6bd26577..5ea43d63d0 100644 --- a/src/gpu/GrRenderTargetProxy.cpp +++ b/src/gpu/GrRenderTargetProxy.cpp @@ -8,8 +8,9 @@ #include "GrRenderTargetProxy.h" #include "GrCaps.h" -#include "GrDrawTarget.h" #include "GrGpuResourcePriv.h" +#include "GrRenderTargetOpList.h" +#include "GrTextureProvider.h" // Deferred version // TODO: we can probably munge the 'desc' in both the wrapped and deferred @@ -18,8 +19,7 @@ GrRenderTargetProxy::GrRenderTargetProxy(const GrCaps& caps, const GrSurfaceDesc SkBackingFit fit, SkBudgeted budgeted) : INHERITED(desc, fit, budgeted) , fTarget(nullptr) - , fFlags(GrRenderTargetPriv::Flags::kNone) - , fLastDrawTarget(nullptr) { + , fFlags(GrRenderTargetPriv::Flags::kNone) { // Since we know the newly created render target will be internal, we are able to precompute // what the flags will ultimately end up being. if (caps.usesMixedSamples() && fDesc.fSampleCnt > 0) { @@ -35,15 +35,7 @@ GrRenderTargetProxy::GrRenderTargetProxy(const GrCaps& caps, sk_sp<GrRenderTarge : INHERITED(rt->desc(), SkBackingFit::kExact, rt->resourcePriv().isBudgeted(), rt->uniqueID()) , fTarget(std::move(rt)) - , fFlags(fTarget->renderTargetPriv().flags()) - , fLastDrawTarget(nullptr) { -} - -GrRenderTargetProxy::~GrRenderTargetProxy() { - if (fLastDrawTarget) { - fLastDrawTarget->clearRT(); - } - SkSafeUnref(fLastDrawTarget); + , fFlags(fTarget->renderTargetPriv().flags()) { } GrRenderTarget* GrRenderTargetProxy::instantiate(GrTextureProvider* texProvider) { @@ -73,18 +65,6 @@ GrRenderTarget* GrRenderTargetProxy::instantiate(GrTextureProvider* texProvider) return fTarget.get(); } -void GrRenderTargetProxy::setLastDrawTarget(GrDrawTarget* dt) { - if (fLastDrawTarget) { - // The non-MDB world never closes so we can't check this condition -#ifdef ENABLE_MDB - SkASSERT(fLastDrawTarget->isClosed()); -#endif - fLastDrawTarget->clearRT(); - } - - SkRefCnt_SafeAssign(fLastDrawTarget, dt); -} - sk_sp<GrRenderTargetProxy> GrRenderTargetProxy::Make(const GrCaps& caps, const GrSurfaceDesc& desc, SkBackingFit fit, diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h index b4d72d5338..4c90cddd4d 100644 --- a/src/gpu/GrResourceProvider.h +++ b/src/gpu/GrResourceProvider.h @@ -96,7 +96,7 @@ public: enum Flags { /** If the caller intends to do direct reads/writes to/from the CPU then this flag must be - * set when accessing resources during a GrDrawTarget flush. This includes the execution of + * set when accessing resources during a GrOpList flush. This includes the execution of * GrBatch objects. The reason is that these memory operations are done immediately and * will occur out of order WRT the operations being flushed. * Make this automatic: https://bug.skia.org/4156 diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp index 3c9368e67f..9fe00ded5d 100644 --- a/src/gpu/GrSurface.cpp +++ b/src/gpu/GrSurface.cpp @@ -7,6 +7,7 @@ #include "GrSurface.h" #include "GrContext.h" +#include "GrOpList.h" #include "GrSurfacePriv.h" #include "SkBitmap.h" @@ -14,6 +15,16 @@ #include "SkImageEncoder.h" #include <stdio.h> +GrSurface::~GrSurface() { + if (fLastOpList) { + fLastOpList->clearTarget(); + } + SkSafeUnref(fLastOpList); + + // check that invokeReleaseProc has been called (if needed) + SkASSERT(NULL == fReleaseProc); +} + size_t GrSurface::WorstCaseSize(const GrSurfaceDesc& desc) { size_t size; @@ -195,3 +206,15 @@ void GrSurface::onAbandon() { this->invokeReleaseProc(); this->INHERITED::onAbandon(); } + +void GrSurface::setLastOpList(GrOpList* opList) { + if (fLastOpList) { + // The non-MDB world never closes so we can't check this condition +#ifdef ENABLE_MDB + SkASSERT(fLastOpList->isClosed()); +#endif + fLastOpList->clearTarget(); + } + + SkRefCnt_SafeAssign(fLastOpList, opList); +} diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp index f5c401f670..9cd84ed4c6 100644 --- a/src/gpu/GrSurfaceProxy.cpp +++ b/src/gpu/GrSurfaceProxy.cpp @@ -7,3 +7,23 @@ #include "GrSurfaceProxy.h" +#include "GrOpList.h" + +GrSurfaceProxy::~GrSurfaceProxy() { + if (fLastOpList) { + fLastOpList->clearTarget(); + } + SkSafeUnref(fLastOpList); +} + +void GrSurfaceProxy::setLastOpList(GrOpList* opList) { + if (fLastOpList) { + // The non-MDB world never closes so we can't check this condition +#ifdef ENABLE_MDB + SkASSERT(fLastOpList->isClosed()); +#endif + fLastOpList->clearTarget(); + } + + SkRefCnt_SafeAssign(fLastOpList, opList); +} diff --git a/src/gpu/GrTracing.h b/src/gpu/GrTracing.h index 273aa65989..1f2a04ace4 100644 --- a/src/gpu/GrTracing.h +++ b/src/gpu/GrTracing.h @@ -57,7 +57,7 @@ private: /** * GR_CREATE_TRACE_MARKER will place begin and end trace markers for both * cpu and gpu (if gpu tracing enabled) for the current scope. - * name is of type const char* and target is of type GrDrawTarget* + * name is of type const char* and target is of type GrOpList* */ #define GR_CREATE_TRACE_MARKER(name, target) \ /* Chromium tracing */ \ diff --git a/src/gpu/GrUserStencilSettings.h b/src/gpu/GrUserStencilSettings.h index 32fb1396f9..18002591ec 100644 --- a/src/gpu/GrUserStencilSettings.h +++ b/src/gpu/GrUserStencilSettings.h @@ -13,12 +13,12 @@ /** * Gr uses the stencil buffer to implement complex clipping inside the - * GrDrawTarget class. The GrDrawTarget makes a subset of the stencil buffer + * GrOpList class. The GrOpList makes a subset of the stencil buffer * bits available for other uses by external code (user bits). Client code can - * modify these bits. GrDrawTarget will ignore ref, mask, and writemask bits + * modify these bits. GrOpList will ignore ref, mask, and writemask bits * provided by clients that fall outside the user range. * - * When code outside the GrDrawTarget class uses the stencil buffer the contract + * When code outside the GrOpList class uses the stencil buffer the contract * is as follows: * * > Normal stencil funcs allow the client to pass / fail regardless of the diff --git a/src/gpu/batches/GrDrawBatch.h b/src/gpu/batches/GrDrawBatch.h index 5f37b7b000..e675f5fc4d 100644 --- a/src/gpu/batches/GrDrawBatch.h +++ b/src/gpu/batches/GrDrawBatch.h @@ -42,7 +42,7 @@ private: }; /** - * Base class for GrBatches that draw. These batches have a GrPipeline installed by GrDrawTarget. + * Base class for GrBatches that draw. These batches have a GrPipeline installed by GrOpList. */ class GrDrawBatch : public GrBatch { public: diff --git a/src/gpu/batches/GrTessellatingPathRenderer.cpp b/src/gpu/batches/GrTessellatingPathRenderer.cpp index 57eac3c4b2..cb4f2c79ed 100644 --- a/src/gpu/batches/GrTessellatingPathRenderer.cpp +++ b/src/gpu/batches/GrTessellatingPathRenderer.cpp @@ -12,7 +12,6 @@ #include "GrBatchTest.h" #include "GrClip.h" #include "GrDefaultGeoProcFactory.h" -#include "GrDrawTarget.h" #include "GrMesh.h" #include "GrPathUtils.h" #include "GrPipelineBuilder.h" diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 1e8049727b..3a32e2b67d 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -2238,7 +2238,7 @@ void GrGLGpu::clearStencilClip(const GrFixedClip& clip, #else // we could just clear the clip bit but when we go through // ANGLE a partial stencil mask will cause clears to be - // turned into draws. Our contract on GrDrawTarget says that + // turned into draws. Our contract on GrOpList says that // changing the clip between stencil passes may or may not // zero the client's clip bits. So we just clear the whole thing. static const GrGLint clipStencilMask = ~0; @@ -2616,7 +2616,7 @@ GrGpuCommandBuffer* GrGLGpu::createCommandBuffer( return new GrGLGpuCommandBuffer(this, static_cast<GrGLRenderTarget*>(target)); } -void GrGLGpu::finishDrawTarget() { +void GrGLGpu::finishOpList() { if (fPLSHasBeenUsed) { /* There is an ARM driver bug where if we use PLS, and then draw a frame which does not * use PLS, it leaves garbage all over the place. As a workaround, we use PLS in a diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h index 7ba79b2eea..0160835c6e 100644 --- a/src/gpu/gl/GrGLGpu.h +++ b/src/gpu/gl/GrGLGpu.h @@ -142,7 +142,7 @@ public: void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override; - void finishDrawTarget() override; + void finishOpList() override; GrFence SK_WARN_UNUSED_RESULT insertFence() const override; bool waitFence(GrFence, uint64_t timeout) const override; diff --git a/src/gpu/text/GrStencilAndCoverTextContext.h b/src/gpu/text/GrStencilAndCoverTextContext.h index 0f6735e133..c87041a9e4 100644 --- a/src/gpu/text/GrStencilAndCoverTextContext.h +++ b/src/gpu/text/GrStencilAndCoverTextContext.h @@ -25,7 +25,7 @@ class SkSurfaceProps; /* * This class implements text rendering using stencil and cover path rendering - * (by the means of GrDrawTarget::drawPath). + * (by the means of GrOpList::drawPath). */ class GrStencilAndCoverTextContext { public: diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp index 0eb8241a94..b13e16282e 100644 --- a/src/gpu/vk/GrVkGpu.cpp +++ b/src/gpu/vk/GrVkGpu.cpp @@ -1323,7 +1323,7 @@ void GrVkGpu::addImageMemoryBarrier(VkPipelineStageFlags srcStageMask, barrier); } -void GrVkGpu::finishDrawTarget() { +void GrVkGpu::finishOpList() { // Submit the current command buffer to the Queue this->submitCommandBuffer(kSkip_SyncQueue); } diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h index 273f28c5db..77eb24215c 100644 --- a/src/gpu/vk/GrVkGpu.h +++ b/src/gpu/vk/GrVkGpu.h @@ -139,7 +139,7 @@ public: GrVkRenderTarget*, const SkIRect& bounds); - void finishDrawTarget() override; + void finishOpList() override; GrFence SK_WARN_UNUSED_RESULT insertFence() const override; bool waitFence(GrFence, uint64_t timeout) const override; diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp index 2e17902519..60c10e8226 100644 --- a/tools/gpu/GrTest.cpp +++ b/tools/gpu/GrTest.cpp @@ -65,9 +65,9 @@ void GrTestTarget::init(GrContext* ctx, sk_sp<GrDrawContext> drawContext) { void GrContext::getTestTarget(GrTestTarget* tar, sk_sp<GrDrawContext> drawContext) { this->flush(); SkASSERT(drawContext); - // We could create a proxy GrDrawTarget that passes through to fGpu until ~GrTextTarget() and + // We could create a proxy GrOpList that passes through to fGpu until ~GrTextTarget() and // then disconnects. This would help prevent test writers from mixing using the returned - // GrDrawTarget and regular drawing. We could also assert or fail in GrContext drawing methods + // GrOpList and regular drawing. We could also assert or fail in GrContext drawing methods // until ~GrTestTarget(). tar->init(this, std::move(drawContext)); } @@ -252,7 +252,7 @@ void GrDrawContextPriv::testingOnly_drawBatch(const GrPaint& paint, pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag, true); } - fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, GrNoClip(), batch); + fDrawContext->getOpList()->drawBatch(pipelineBuilder, fDrawContext, GrNoClip(), batch); } #undef ASSERT_SINGLE_OWNER diff --git a/tools/gpu/GrTest.h b/tools/gpu/GrTest.h index 7b05a05146..86333b4f6c 100644 --- a/tools/gpu/GrTest.h +++ b/tools/gpu/GrTest.h @@ -20,8 +20,8 @@ namespace GrTest { }; /** TODO Please do not use this if you can avoid it. We are in the process of deleting it. - Allows a test to temporarily draw to a GrDrawTarget owned by a GrContext. Tests that use this - should be careful not to mix using the GrDrawTarget directly and drawing via SkCanvas or + Allows a test to temporarily draw to a GrOpList owned by a GrContext. Tests that use this + should be careful not to mix using the GrOpList directly and drawing via SkCanvas or GrContext. In the future this object may provide some guards to prevent this. */ class GrTestTarget { public: |