#include <OpsTask.h>

Inheritance diagram for skgpu::ganesh::OpsTask:

Public Types
enum class	CanDiscardPreviousOps : bool { kYes = true , kNo = false }

Public Member Functions
	OpsTask (GrDrawingManager , GrSurfaceProxyView, GrAuditTrail , sk_sp< GrArenas >)

	~OpsTask () override

OpsTask *	asOpsTask () override

bool	isEmpty () const

bool	usesMSAASurface () const

GrXferBarrierFlags	renderPassXferBarriers () const

void	endFlush (GrDrawingManager *) override

void	onPrePrepare (GrRecordingContext *) override

void	onPrepare (GrOpFlushState *flushState) override

bool	onExecute (GrOpFlushState *flushState) override

void	addSampledTexture (GrSurfaceProxy *proxy)

void	addOp (GrDrawingManager *, GrOp::Owner, GrTextureResolveManager, const GrCaps &)

void	addDrawOp (GrDrawingManager *, GrOp::Owner, bool usesMSAA, const GrProcessorSet::Analysis &, GrAppliedClip &&, const GrDstProxyView &, GrTextureResolveManager, const GrCaps &)

void	discard ()

bool	resetForFullscreenClear (CanDiscardPreviousOps)

void	setColorLoadOp (GrLoadOp op, std::array< float, 4 > color={0, 0, 0, 0})

bool	canMerge (const OpsTask *) const

int	mergeFrom (SkSpan< const sk_sp< GrRenderTask > > tasks)

Public Member Functions inherited from GrRenderTask
	GrRenderTask ()

	SkDEBUGCODE (~GrRenderTask() override;) void makeClosed(GrRecordingContext *)

void	prePrepare (GrRecordingContext *context)

void	prepare (GrOpFlushState *flushState)

bool	execute (GrOpFlushState *flushState)

virtual bool	requiresExplicitCleanup () const

virtual void	endFlush (GrDrawingManager *)

virtual void	disown (GrDrawingManager *)

bool	isClosed () const

void	makeSkippable ()

bool	isSkippable () const

bool	blocksReordering () const

void	addDependency (GrDrawingManager , GrSurfaceProxy dependedOn, skgpu::Mipmapped, GrTextureResolveManager, const GrCaps &caps)

void	addDependenciesFromOtherTask (GrRenderTask *otherTask)

SkSpan< GrRenderTask * >	dependencies ()

SkSpan< GrRenderTask * >	dependents ()

void	replaceDependency (const GrRenderTask toReplace, GrRenderTask replaceWith)

void	replaceDependent (const GrRenderTask toReplace, GrRenderTask replaceWith)

bool	dependsOn (const GrRenderTask *dependedOn) const

uint32_t	uniqueID () const

int	numTargets () const

GrSurfaceProxy *	target (int i) const

virtual skgpu::ganesh::OpsTask *	asOpsTask ()

bool	isUsed (GrSurfaceProxy *proxy) const

virtual void	gatherProxyIntervals (GrResourceAllocator *) const =0

bool	isInstantiated () const

	SK_DECLARE_INTERNAL_LLIST_INTERFACE (GrRenderTask)

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Protected Types
enum class	StencilContent { kDontCare , kUserBitsCleared , kPreserved }

Protected Types inherited from GrRenderTask
enum class	ExpectedOutcome : bool { kTargetUnchanged , kTargetDirty }

enum	Flags { kClosed_Flag = 0x01 , kDisowned_Flag = 0x02 , kSkippable_Flag = 0x04 , kAtlas_Flag = 0x08 , kBlocksReordering_Flag = 0x10 , kWasOutput_Flag = 0x20 , kTempMark_Flag = 0x40 }

Protected Member Functions
void	setInitialStencilContent (StencilContent initialContent)

void	recordOp (GrOp::Owner, bool usesMSAA, GrProcessorSet::Analysis, GrAppliedClip , const GrDstProxyView , const GrCaps &)

ExpectedOutcome	onMakeClosed (GrRecordingContext , SkIRect targetUpdateBounds) override

Protected Member Functions inherited from GrRenderTask
	SkDEBUGCODE (bool deferredProxiesAreInstantiated() const ;) void addTarget(GrDrawingManager *

void	addTarget (GrDrawingManager *dm, const GrSurfaceProxyView &view)

virtual ExpectedOutcome	onMakeClosed (GrRecordingContext , SkIRect targetUpdateBounds)=0

void	setFlag (uint32_t flag)

void	resetFlag (uint32_t flag)

bool	isSetFlag (uint32_t flag) const

void	setIndex (uint32_t index)

uint32_t	getIndex () const

Friends
class	::OpsTaskTestingAccess

class	skgpu::ganesh::SurfaceDrawContext

Additional Inherited Members
Protected Attributes inherited from GrRenderTask
	sk_sp< GrSurfaceProxy >

skia_private::STArray< 1, sk_sp< GrSurfaceProxy > >	fTargets

skia_private::TArray< GrTextureProxy *, true >	fDeferredProxies

Detailed Description

Definition at line 42 of file OpsTask.h.

Member Enumeration Documentation

◆ CanDiscardPreviousOps

enum class skgpu::ganesh::OpsTask::CanDiscardPreviousOps : bool

strong

Enumerator
kYes
kNo

Definition at line 84 of file OpsTask.h.

                                     : bool {
        kYes = true,
        kNo = false
    };

◆ StencilContent

enum class skgpu::ganesh::OpsTask::StencilContent

strongprotected

Enumerator
kDontCare
kUserBitsCleared
kPreserved

Definition at line 120 of file OpsTask.h.

                              {
        kDontCare,
        kUserBitsCleared,  // User bits: cleared
                           // Clip bit: don't care (Ganesh always pre-clears the clip bit.)
        kPreserved
    };

Constructor & Destructor Documentation

◆ OpsTask()

skgpu::ganesh::OpsTask::OpsTask	(	GrDrawingManager *	drawingMgr,
		GrSurfaceProxyView	view,
		GrAuditTrail *	auditTrail,
		sk_sp< GrArenas >	arenas
	)

Definition at line 392 of file OpsTask.cpp.

        : GrRenderTask()
        , fAuditTrail(auditTrail)
        , fUsesMSAASurface(view.asRenderTargetProxy()->numSamples() > 1)
        , fTargetSwizzle(view.swizzle())
        , fTargetOrigin(view.origin())
        , fArenas{std::move(arenas)}
          SkDEBUGCODE(, fNumClips(0)) {
    this->addTarget(drawingMgr, view.detachProxy());
}

◆ ~OpsTask()

skgpu::ganesh::OpsTask::~OpsTask ( )

override

Definition at line 413 of file OpsTask.cpp.

                  {
    this->deleteOps();
}

Member Function Documentation

◆ addDrawOp()

void skgpu::ganesh::OpsTask::addDrawOp	(	GrDrawingManager *	drawingMgr,
		GrOp::Owner	op,
		bool	usesMSAA,
		const GrProcessorSet::Analysis &	processorAnalysis,
		GrAppliedClip &&	clip,
		const GrDstProxyView &	dstProxyView,
		GrTextureResolveManager	textureResolveManager,
		const GrCaps &	caps
	)

Definition at line 429 of file OpsTask.cpp.

                                                                                           {
    auto addDependency = [&](GrSurfaceProxy* p, skgpu::Mipmapped mipmapped) {
        this->addSampledTexture(p);
        this->addDependency(drawingMgr, p, mipmapped, textureResolveManager, caps);
    };
 
    op->visitProxies(addDependency);
    clip.visitProxies(addDependency);
    if (dstProxyView.proxy()) {
        if (!(dstProxyView.dstSampleFlags() & GrDstSampleFlags::kAsInputAttachment)) {
            this->addSampledTexture(dstProxyView.proxy());
        }
        if (dstProxyView.dstSampleFlags() & GrDstSampleFlags::kRequiresTextureBarrier) {
            fRenderPassXferBarriers |= GrXferBarrierFlags::kTexture;
        }
        addDependency(dstProxyView.proxy(), skgpu::Mipmapped::kNo);
        SkASSERT(!(dstProxyView.dstSampleFlags() & GrDstSampleFlags::kAsInputAttachment) ||
                 dstProxyView.offset().isZero());
    }
 
    if (processorAnalysis.usesNonCoherentHWBlending()) {
        fRenderPassXferBarriers |= GrXferBarrierFlags::kBlend;
    }
 
    this->recordOp(std::move(op), usesMSAA, processorAnalysis, clip.doesClip() ? &clip : nullptr,
                   &dstProxyView, caps);
}

◆ addOp()

void skgpu::ganesh::OpsTask::addOp	(	GrDrawingManager *	drawingMgr,
		GrOp::Owner	op,
		GrTextureResolveManager	textureResolveManager,
		const GrCaps &	caps
	)

Definition at line 417 of file OpsTask.cpp.

                                                                                       {
    auto addDependency = [&](GrSurfaceProxy* p, skgpu::Mipmapped mipmapped) {
        this->addDependency(drawingMgr, p, mipmapped, textureResolveManager, caps);
    };
 
    op->visitProxies(addDependency);
 
    this->recordOp(std::move(op), false/*usesMSAA*/, GrProcessorSet::EmptySetAnalysis(), nullptr,
                   nullptr, caps);
}

◆ addSampledTexture()

void skgpu::ganesh::OpsTask::addSampledTexture ( GrSurfaceProxy * proxy )

inline

Definition at line 67 of file OpsTask.h.

                                                  {
        // This function takes a GrSurfaceProxy because all subsequent uses of the proxy do not
        // require the specifics of GrTextureProxy, so this avoids a number of unnecessary virtual
        // asTextureProxy() calls. However, sampling the proxy implicitly requires that the proxy
        // be a texture. Eventually, when proxies are a unified type with flags, this can just
        // assert that capability.
        SkASSERT(proxy->asTextureProxy());
        fSampledProxies.push_back(proxy);
    }

◆ asOpsTask()

OpsTask * skgpu::ganesh::OpsTask::asOpsTask ( )

inlineoverridevirtual

Reimplemented from GrRenderTask.

Definition at line 48 of file OpsTask.h.

48{ return this; }

◆ canMerge()

bool skgpu::ganesh::OpsTask::canMerge ( const OpsTask * opsTask ) const

Definition at line 678 of file OpsTask.cpp.

                                                   {
    return this->target(0) == opsTask->target(0) &&
           fArenas == opsTask->fArenas &&
           !opsTask->fCannotMergeBackward;
}

◆ discard()

void skgpu::ganesh::OpsTask::discard ( )

Definition at line 773 of file OpsTask.cpp.

                      {
    // Discard calls to in-progress opsTasks are ignored. Calls at the start update the
    // opsTasks' color & stencil load ops.
    if (this->isEmpty()) {
        fColorLoadOp = GrLoadOp::kDiscard;
        fInitialStencilContent = StencilContent::kDontCare;
        fTotalBounds.setEmpty();
    }
}

◆ endFlush()

void skgpu::ganesh::OpsTask::endFlush ( GrDrawingManager * drawingMgr )

overridevirtual

Empties the draw buffer of any queued up draws.

Reimplemented from GrRenderTask.

Definition at line 460 of file OpsTask.cpp.

                                                   {
    fLastClipStackGenID = SK_InvalidUniqueID;
    this->deleteOps();
 
    fDeferredProxies.clear();
    fSampledProxies.clear();
    fAuditTrail = nullptr;
 
    GrRenderTask::endFlush(drawingMgr);
}

◆ isEmpty()

bool skgpu::ganesh::OpsTask::isEmpty ( ) const

inline

Definition at line 50 of file OpsTask.h.

50{ return fOpChains.empty(); }

skia_private::TArray::empty

bool empty() const

Definition: SkTArray.h:199

◆ mergeFrom()

int skgpu::ganesh::OpsTask::mergeFrom ( SkSpan< const sk_sp< GrRenderTask > > tasks )

Definition at line 684 of file OpsTask.cpp.

                                                              {
    int mergedCount = 0;
    for (const sk_sp<GrRenderTask>& task : tasks) {
        auto opsTask = task->asOpsTask();
        if (!opsTask || !this->canMerge(opsTask)) {
            break;
        }
        SkASSERT(fTargetSwizzle == opsTask->fTargetSwizzle);
        SkASSERT(fTargetOrigin == opsTask->fTargetOrigin);
        if (GrLoadOp::kClear == opsTask->fColorLoadOp) {
            // TODO(11903): Go back to actually dropping ops tasks when we are merged with
            // color clear.
            return 0;
        }
        mergedCount += 1;
    }
    if (0 == mergedCount) {
        return 0;
    }
 
    SkSpan<const sk_sp<OpsTask>> mergingNodes(
            reinterpret_cast<const sk_sp<OpsTask>*>(tasks.data()), SkToSizeT(mergedCount));
    int addlDeferredProxyCount = 0;
    int addlProxyCount = 0;
    int addlOpChainCount = 0;
    for (const auto& toMerge : mergingNodes) {
        addlDeferredProxyCount += toMerge->fDeferredProxies.size();
        addlProxyCount += toMerge->fSampledProxies.size();
        addlOpChainCount += toMerge->fOpChains.size();
        fClippedContentBounds.join(toMerge->fClippedContentBounds);
        fTotalBounds.join(toMerge->fTotalBounds);
        fRenderPassXferBarriers |= toMerge->fRenderPassXferBarriers;
        if (fInitialStencilContent == StencilContent::kDontCare) {
            // Propogate the first stencil content that isn't kDontCare.
            //
            // Once the stencil has any kind of initial content that isn't kDontCare, then the
            // inital contents of subsequent opsTasks that get merged in don't matter.
            //
            // (This works because the opsTask all target the same render target and are in
            // painter's order. kPreserved obviously happens automatically with a merge, and kClear
            // is also automatic because the contract is for ops to leave the stencil buffer in a
            // cleared state when finished.)
            fInitialStencilContent = toMerge->fInitialStencilContent;
        }
        fUsesMSAASurface |= toMerge->fUsesMSAASurface;
        SkDEBUGCODE(fNumClips += toMerge->fNumClips);
    }
 
    fLastClipStackGenID = SK_InvalidUniqueID;
    fDeferredProxies.reserve_exact(fDeferredProxies.size() + addlDeferredProxyCount);
    fSampledProxies.reserve_exact(fSampledProxies.size() + addlProxyCount);
    fOpChains.reserve_exact(fOpChains.size() + addlOpChainCount);
    for (const auto& toMerge : mergingNodes) {
        for (GrRenderTask* renderTask : toMerge->dependents()) {
            renderTask->replaceDependency(toMerge.get(), this);
        }
        for (GrRenderTask* renderTask : toMerge->dependencies()) {
            renderTask->replaceDependent(toMerge.get(), this);
        }
        fDeferredProxies.move_back_n(toMerge->fDeferredProxies.size(),
                                     toMerge->fDeferredProxies.data());
        fSampledProxies.move_back_n(toMerge->fSampledProxies.size(),
                                    toMerge->fSampledProxies.data());
        fOpChains.move_back_n(toMerge->fOpChains.size(),
                              toMerge->fOpChains.data());
        toMerge->fDeferredProxies.clear();
        toMerge->fSampledProxies.clear();
        toMerge->fOpChains.clear();
    }
    fMustPreserveStencil = mergingNodes.back()->fMustPreserveStencil;
    return mergedCount;
}

◆ onExecute()

bool skgpu::ganesh::OpsTask::onExecute ( GrOpFlushState * flushState )

overridevirtual

Implements GrRenderTask.

Definition at line 540 of file OpsTask.cpp.

                                                  {
    SkASSERT(this->numTargets() == 1);
    GrRenderTargetProxy* proxy = this->target(0)->asRenderTargetProxy();
    SkASSERT(proxy);
    SK_AT_SCOPE_EXIT(proxy->clearArenas());
 
    if (this->isColorNoOp() || fClippedContentBounds.isEmpty()) {
        return false;
    }
    TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_FUNC);
 
    // Make sure load ops are not kClear if the GPU needs to use draws for clears
    SkASSERT(fColorLoadOp != GrLoadOp::kClear ||
             !flushState->gpu()->caps()->performColorClearsAsDraws());
 
    const GrCaps& caps = *flushState->gpu()->caps();
    GrRenderTarget* renderTarget = proxy->peekRenderTarget();
    SkASSERT(renderTarget);
 
    GrAttachment* stencil = nullptr;
    if (proxy->needsStencil()) {
        SkASSERT(proxy->canUseStencil(caps));
        if (!flushState->resourceProvider()->attachStencilAttachment(renderTarget,
                                                                     fUsesMSAASurface)) {
            SkDebugf("WARNING: failed to attach a stencil buffer. Rendering will be skipped.\n");
            return false;
        }
        stencil = renderTarget->getStencilAttachment(fUsesMSAASurface);
    }
 
    GrLoadOp stencilLoadOp;
    switch (fInitialStencilContent) {
        case StencilContent::kDontCare:
            stencilLoadOp = GrLoadOp::kDiscard;
            break;
        case StencilContent::kUserBitsCleared:
            SkASSERT(!caps.performStencilClearsAsDraws());
            SkASSERT(stencil);
            if (caps.discardStencilValuesAfterRenderPass()) {
                // Always clear the stencil if it is being discarded after render passes. This is
                // also an optimization because we are on a tiler and it avoids loading the values
                // from memory.
                stencilLoadOp = GrLoadOp::kClear;
                break;
            }
            if (!stencil->hasPerformedInitialClear()) {
                stencilLoadOp = GrLoadOp::kClear;
                stencil->markHasPerformedInitialClear();
                break;
            }
            // SurfaceDrawContexts are required to leave the user stencil bits in a cleared state
            // once finished, meaning the stencil values will always remain cleared after the
            // initial clear. Just fall through to reloading the existing (cleared) stencil values
            // from memory.
            [[fallthrough]];
        case StencilContent::kPreserved:
            SkASSERT(stencil);
            stencilLoadOp = GrLoadOp::kLoad;
            break;
    }
 
    // NOTE: If fMustPreserveStencil is set, then we are executing a surfaceDrawContext that split
    // its opsTask.
    //
    // FIXME: We don't currently flag render passes that don't use stencil at all. In that case
    // their store op might be "discard", and we currently make the assumption that a discard will
    // not invalidate what's already in main memory. This is probably ok for now, but certainly
    // something we want to address soon.
    GrStoreOp stencilStoreOp = (caps.discardStencilValuesAfterRenderPass() && !fMustPreserveStencil)
            ? GrStoreOp::kDiscard
            : GrStoreOp::kStore;
 
    GrOpsRenderPass* renderPass = create_render_pass(flushState->gpu(),
                                                     proxy->peekRenderTarget(),
                                                     fUsesMSAASurface,
                                                     stencil,
                                                     fTargetOrigin,
                                                     fClippedContentBounds,
                                                     fColorLoadOp,
                                                     fLoadClearColor,
                                                     stencilLoadOp,
                                                     stencilStoreOp,
                                                     fSampledProxies,
                                                     fRenderPassXferBarriers);
 
    if (!renderPass) {
        return false;
    }
    flushState->setOpsRenderPass(renderPass);
    renderPass->begin();
 
    GrSurfaceProxyView dstView(sk_ref_sp(this->target(0)), fTargetOrigin, fTargetSwizzle);
 
    // Draw all the generated geometry.
    for (const auto& chain : fOpChains) {
        if (!chain.shouldExecute()) {
            continue;
        }
 
        GrOpFlushState::OpArgs opArgs(chain.head(),
                                      dstView,
                                      fUsesMSAASurface,
                                      chain.appliedClip(),
                                      chain.dstProxyView(),
                                      fRenderPassXferBarriers,
                                      fColorLoadOp);
 
        flushState->setOpArgs(&opArgs);
        chain.head()->execute(flushState, chain.bounds());
        flushState->setOpArgs(nullptr);
    }
 
    renderPass->end();
    flushState->gpu()->submit(renderPass);
    flushState->setOpsRenderPass(nullptr);
 
    return true;
}

◆ onMakeClosed()

GrRenderTask::ExpectedOutcome skgpu::ganesh::OpsTask::onMakeClosed	(	GrRecordingContext *	rContext,
		SkIRect *	targetUpdateBounds
	)

overrideprotectedvirtual

Implements GrRenderTask.

Definition at line 1057 of file OpsTask.cpp.

                                                                                 {
    this->forwardCombine(*rContext->priv().caps());
    if (!this->isColorNoOp()) {
        GrSurfaceProxy* proxy = this->target(0);
        // Use the entire backing store bounds since the GPU doesn't clip automatically to the
        // logical dimensions.
        SkRect clippedContentBounds = proxy->backingStoreBoundsRect();
        // TODO: If we can fix up GLPrograms test to always intersect the target proxy bounds
        // then we can simply assert here that the bounds intersect.
        if (clippedContentBounds.intersect(fTotalBounds)) {
            clippedContentBounds.roundOut(&fClippedContentBounds);
            *targetUpdateBounds = GrNativeRect::MakeIRectRelativeTo(
                    fTargetOrigin,
                    this->target(0)->backingStoreDimensions().height(),
                    fClippedContentBounds);
            return ExpectedOutcome::kTargetDirty;
        }
    }
    return ExpectedOutcome::kTargetUnchanged;
}

◆ onPrepare()

void skgpu::ganesh::OpsTask::onPrepare ( GrOpFlushState * flushState )

overridevirtual

Together these two functions flush all queued up draws to GrCommandBuffer. The return value of onExecute() indicates whether any commands were actually issued to the GPU.

Reimplemented from GrRenderTask.

Definition at line 496 of file OpsTask.cpp.

                                                  {
    SkASSERT(this->target(0)->peekRenderTarget());
    SkASSERT(this->isClosed());
    // TODO: remove the check for discard here once reduced op splitting is turned on. Currently we
    // can end up with OpsTasks that only have a discard load op and no ops. For vulkan validation
    // we need to keep that discard and not drop it. Once we have reduce op list splitting enabled
    // we shouldn't end up with OpsTasks with only discard.
    if (this->isColorNoOp() ||
        (fClippedContentBounds.isEmpty() && fColorLoadOp != GrLoadOp::kDiscard)) {
        return;
    }
    TRACE_EVENT0_ALWAYS("skia.gpu", TRACE_FUNC);
 
    flushState->setSampledProxyArray(&fSampledProxies);
    GrSurfaceProxyView dstView(sk_ref_sp(this->target(0)), fTargetOrigin, fTargetSwizzle);
    // Loop over the ops that haven't yet been prepared.
    for (const auto& chain : fOpChains) {
        if (chain.shouldExecute()) {
            GrOpFlushState::OpArgs opArgs(chain.head(),
                                          dstView,
                                          fUsesMSAASurface,
                                          chain.appliedClip(),
                                          chain.dstProxyView(),
                                          fRenderPassXferBarriers,
                                          fColorLoadOp);
 
            flushState->setOpArgs(&opArgs);
 
            // Temporary debugging helper: for debugging prePrepare w/o going through DDLs
            // Delete once most of the GrOps have an onPrePrepare.
            // chain.head()->prePrepare(flushState->gpu()->getContext(), &this->target(0),
            //                          chain.appliedClip());
 
            // GrOp::prePrepare may or may not have been called at this point
            chain.head()->prepare(flushState);
            flushState->setOpArgs(nullptr);
        }
    }
    flushState->setSampledProxyArray(nullptr);
}

◆ onPrePrepare()

void skgpu::ganesh::OpsTask::onPrePrepare ( GrRecordingContext * context )

overridevirtual

Reimplemented from GrRenderTask.

Definition at line 471 of file OpsTask.cpp.

                                                      {
    SkASSERT(this->isClosed());
    // TODO: remove the check for discard here once reduced op splitting is turned on. Currently we
    // can end up with OpsTasks that only have a discard load op and no ops. For vulkan validation
    // we need to keep that discard and not drop it. Once we have reduce op list splitting enabled
    // we shouldn't end up with OpsTasks with only discard.
    if (this->isColorNoOp() ||
        (fClippedContentBounds.isEmpty() && fColorLoadOp != GrLoadOp::kDiscard)) {
        return;
    }
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    GrSurfaceProxyView dstView(sk_ref_sp(this->target(0)), fTargetOrigin, fTargetSwizzle);
    for (const auto& chain : fOpChains) {
        if (chain.shouldExecute()) {
            chain.head()->prePrepare(context,
                                     dstView,
                                     chain.appliedClip(),
                                     chain.dstProxyView(),
                                     fRenderPassXferBarriers,
                                     fColorLoadOp);
        }
    }
}

◆ recordOp()

void skgpu::ganesh::OpsTask::recordOp	(	GrOp::Owner	op,
		bool	usesMSAA,
		GrProcessorSet::Analysis	processorAnalysis,
		GrAppliedClip *	clip,
		const GrDstProxyView *	dstProxyView,
		const GrCaps &	caps
	)

protected

Definition at line 955 of file OpsTask.cpp.

                                                                                     {
    GrSurfaceProxy* proxy = this->target(0);
#ifdef SK_DEBUG
    op->validate();
    SkASSERT(processorAnalysis.requiresDstTexture() == (dstProxyView && dstProxyView->proxy()));
    SkASSERT(proxy);
    // A closed OpsTask should never receive new/more ops
    SkASSERT(!this->isClosed());
    // Ensure we can support dynamic msaa if the caller is trying to trigger it.
    if (proxy->asRenderTargetProxy()->numSamples() == 1 && usesMSAA) {
        SkASSERT(caps.supportsDynamicMSAA(proxy->asRenderTargetProxy()));
    }
#endif
 
    if (!op->bounds().isFinite()) {
        return;
    }
 
    fUsesMSAASurface |= usesMSAA;
 
    // Account for this op's bounds before we attempt to combine.
    // NOTE: The caller should have already called "op->setClippedBounds()" by now, if applicable.
    fTotalBounds.join(op->bounds());
 
    // Check if there is an op we can combine with by linearly searching back until we either
    // 1) check every op
    // 2) intersect with something
    // 3) find a 'blocker'
    GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), proxy->uniqueID());
    GrOP_INFO("opsTask: %d Recording (%s, opID: %u)\n"
              "\tBounds [L: %.2f, T: %.2f R: %.2f B: %.2f]\n",
               this->uniqueID(),
               op->name(),
               op->uniqueID(),
               op->bounds().fLeft, op->bounds().fTop,
               op->bounds().fRight, op->bounds().fBottom);
    GrOP_INFO(SkTabString(op->dumpInfo(), 1).c_str());
    GrOP_INFO("\tOutcome:\n");
    int maxCandidates = std::min(kMaxOpChainDistance, fOpChains.size());
    if (maxCandidates) {
        int i = 0;
        while (true) {
            OpChain& candidate = fOpChains.fromBack(i);
            op = candidate.appendOp(std::move(op), processorAnalysis, dstProxyView, clip, caps,
                                    fArenas->arenaAlloc(), fAuditTrail);
            if (!op) {
                return;
            }
            // Stop going backwards if we would cause a painter's order violation.
            if (!can_reorder(candidate.bounds(), op->bounds())) {
                GrOP_INFO("\t\tBackward: Intersects with chain (%s, head opID: %u)\n",
                          candidate.head()->name(), candidate.head()->uniqueID());
                break;
            }
            if (++i == maxCandidates) {
                GrOP_INFO("\t\tBackward: Reached max lookback or beginning of op array %d\n", i);
                break;
            }
        }
    } else {
        GrOP_INFO("\t\tBackward: FirstOp\n");
    }
    if (clip) {
        clip = fArenas->arenaAlloc()->make<GrAppliedClip>(std::move(*clip));
        SkDEBUGCODE(fNumClips++;)
    }
    fOpChains.emplace_back(std::move(op), processorAnalysis, clip, dstProxyView);
}

◆ renderPassXferBarriers()

GrXferBarrierFlags skgpu::ganesh::OpsTask::renderPassXferBarriers ( ) const

inline

Definition at line 52 of file OpsTask.h.

52{ return fRenderPassXferBarriers; }

◆ resetForFullscreenClear()

bool skgpu::ganesh::OpsTask::resetForFullscreenClear ( CanDiscardPreviousOps canDiscardPreviousOps )

Definition at line 757 of file OpsTask.cpp.

                                                                                 {
    if (CanDiscardPreviousOps::kYes == canDiscardPreviousOps || this->isEmpty()) {
        this->deleteOps();
        fDeferredProxies.clear();
        fSampledProxies.clear();
 
        // If the opsTask is using a render target which wraps a vulkan command buffer, we can't do
        // a clear load since we cannot change the render pass that we are using. Thus we fall back
        // to making a clear op in this case.
        return !this->target(0)->asRenderTargetProxy()->wrapsVkSecondaryCB();
    }
 
    // Could not empty the task, so an op must be added to handle the clear
    return false;
}

◆ setColorLoadOp()

void skgpu::ganesh::OpsTask::setColorLoadOp	(	GrLoadOp	op,
		std::array< float, 4 >	color = `{0, 0, 0, 0}`
	)

Definition at line 659 of file OpsTask.cpp.

                                                                  {
    fColorLoadOp = op;
    fLoadClearColor = color;
    if (GrLoadOp::kClear == fColorLoadOp) {
        GrSurfaceProxy* proxy = this->target(0);
        SkASSERT(proxy);
        fTotalBounds = proxy->backingStoreBoundsRect();
    }
}

◆ setInitialStencilContent()

void skgpu::ganesh::OpsTask::setInitialStencilContent ( StencilContent initialContent )

inlineprotected

Definition at line 136 of file OpsTask.h.

                                                                 {
        fInitialStencilContent = initialContent;
    }

◆ usesMSAASurface()

bool skgpu::ganesh::OpsTask::usesMSAASurface ( ) const

inline

Definition at line 51 of file OpsTask.h.

51{ return fUsesMSAASurface; }

Friends And Related Function Documentation

◆ ::OpsTaskTestingAccess

friend class ::OpsTaskTestingAccess

friend

Definition at line 264 of file OpsTask.h.

◆ skgpu::ganesh::SurfaceDrawContext

friend class skgpu::ganesh::SurfaceDrawContext

friend

Definition at line 270 of file OpsTask.h.

The documentation for this class was generated from the following files:

third_party/skia/src/gpu/ganesh/ops/OpsTask.h
third_party/skia/src/gpu/ganesh/ops/OpsTask.cpp

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ CanDiscardPreviousOps

◆ StencilContent

Constructor & Destructor Documentation

◆ OpsTask()

◆ ~OpsTask()

Member Function Documentation

◆ addDrawOp()

◆ addOp()

◆ addSampledTexture()

◆ asOpsTask()

◆ canMerge()

◆ discard()

◆ endFlush()

◆ isEmpty()

◆ mergeFrom()

◆ onExecute()

◆ onMakeClosed()

◆ onPrepare()

◆ onPrePrepare()

◆ recordOp()

◆ renderPassXferBarriers()

◆ resetForFullscreenClear()

◆ setColorLoadOp()

◆ setInitialStencilContent()

◆ usesMSAASurface()

Friends And Related Function Documentation

◆ ::OpsTaskTestingAccess

◆ skgpu::ganesh::SurfaceDrawContext