#include <AtlasRenderTask.h>

Inheritance diagram for skgpu::ganesh::AtlasRenderTask:

Public Member Functions
	AtlasRenderTask (GrRecordingContext *, sk_sp< GrArenas >, std::unique_ptr< GrDynamicAtlas >)

const GrTextureProxy *	atlasProxy () const

GrSurfaceProxyView	readView (const GrCaps &caps) const

bool	addPath (const SkMatrix &, const SkPath &, SkIPoint pathDevTopLeft, int widthInAtlas, int heightInAtlas, bool transposedInAtlas, SkIPoint16 *locationInAtlas)

bool	instantiate (GrOnFlushResourceProvider *onFlushRP, sk_sp< GrTexture > backingTexture=nullptr)

Public Member Functions inherited from skgpu::ganesh::OpsTask
	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	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

bool	isUsed (GrSurfaceProxy *proxy) const

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

Private Member Functions
ExpectedOutcome	onMakeClosed (GrRecordingContext , SkIRect targetUpdateBounds) override

bool	onExecute (GrOpFlushState *flushState) override

Additional Inherited Members
Public Types inherited from skgpu::ganesh::OpsTask
enum class	CanDiscardPreviousOps : bool { kYes = true , kNo = false }

Protected Types inherited from skgpu::ganesh::OpsTask
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 inherited from skgpu::ganesh::OpsTask
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)

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

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 28 of file AtlasRenderTask.h.

Constructor & Destructor Documentation

◆ AtlasRenderTask()

skgpu::ganesh::AtlasRenderTask::AtlasRenderTask	(	GrRecordingContext *	rContext,
		sk_sp< GrArenas >	arenas,
		std::unique_ptr< GrDynamicAtlas >	dynamicAtlas
	)

Definition at line 24 of file AtlasRenderTask.cpp.

        : OpsTask(rContext->priv().drawingManager(),
                  dynamicAtlas->writeView(*rContext->priv().caps()),
                  rContext->priv().auditTrail(),
                  std::move(arenas))
        , fDynamicAtlas(std::move(dynamicAtlas)) {
}

Member Function Documentation

◆ addPath()

bool skgpu::ganesh::AtlasRenderTask::addPath	(	const SkMatrix &	viewMatrix,
		const SkPath &	path,
		SkIPoint	pathDevTopLeft,
		int	widthInAtlas,
		int	heightInAtlas,
		bool	transposedInAtlas,
		SkIPoint16 *	locationInAtlas
	)

Definition at line 34 of file AtlasRenderTask.cpp.

                                                                                   {
    SkASSERT(!this->isClosed());
    SkASSERT(this->isEmpty());
    SkASSERT(!fDynamicAtlas->isInstantiated());  // Paths can't be added after instantiate().
 
    if (!fDynamicAtlas->addRect(widthInAtlas, heightInAtlas, locationInAtlas)) {
        return false;
    }
 
    SkMatrix pathToAtlasMatrix = viewMatrix;
    if (transposedInAtlas) {
        std::swap(pathToAtlasMatrix[0], pathToAtlasMatrix[3]);
        std::swap(pathToAtlasMatrix[1], pathToAtlasMatrix[4]);
        float tx=pathToAtlasMatrix.getTranslateX(), ty=pathToAtlasMatrix.getTranslateY();
        pathToAtlasMatrix.setTranslateX(ty - pathDevTopLeft.y() + locationInAtlas->x());
        pathToAtlasMatrix.setTranslateY(tx - pathDevTopLeft.x() + locationInAtlas->y());
    } else {
        pathToAtlasMatrix.postTranslate(locationInAtlas->x() - pathDevTopLeft.x(),
                                        locationInAtlas->y() - pathDevTopLeft.y());
    }
 
    if (GrFillRuleForSkPath(path) == GrFillRule::kNonzero) {
        fWindingPathList.add(&fPathDrawAllocator, pathToAtlasMatrix, path);
    } else {
        fEvenOddPathList.add(&fPathDrawAllocator, pathToAtlasMatrix, path);
    }
    return true;
}

◆ atlasProxy()

const GrTextureProxy * skgpu::ganesh::AtlasRenderTask::atlasProxy ( ) const

inline

Definition at line 34 of file AtlasRenderTask.h.

34{ return fDynamicAtlas->textureProxy(); }

◆ instantiate()

bool skgpu::ganesh::AtlasRenderTask::instantiate	(	GrOnFlushResourceProvider *	onFlushRP,
		sk_sp< GrTexture >	backingTexture = `nullptr`
	)

inline

Definition at line 45 of file AtlasRenderTask.h.

                                                                              {
        SkASSERT(this->isClosed());
        return fDynamicAtlas->instantiate(onFlushRP, std::move(backingTexture));
    }

◆ onExecute()

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

overrideprivatevirtual

Implements GrRenderTask.

Definition at line 180 of file AtlasRenderTask.cpp.

                                                          {
    if (!this->OpsTask::onExecute(flushState)) {
        return false;
    }
    if (this->target(0)->requiresManualMSAAResolve()) {
        // Since atlases don't get closed until they are done being built, the drawingManager
        // doesn't detect that they need an MSAA resolve. Do it here manually.
        auto nativeRect = GrNativeRect::MakeIRectRelativeTo(
                GrDynamicAtlas::kTextureOrigin,
                this->target(0)->backingStoreDimensions().height(),
                SkIRect::MakeSize(fDynamicAtlas->drawBounds()));
        flushState->gpu()->resolveRenderTarget(this->target(0)->peekRenderTarget(), nativeRect);
    }
    return true;
}

◆ onMakeClosed()

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

overrideprivatevirtual

Implements GrRenderTask.

Definition at line 65 of file AtlasRenderTask.cpp.

                                                                                         {
    // We don't add our ops until now, at which point we know the atlas is done being built.
    SkASSERT(this->isEmpty());
    SkASSERT(!fDynamicAtlas->isInstantiated());  // Instantiation happens after makeClosed().
 
    const GrCaps& caps = *rContext->priv().caps();
 
    // Set our dimensions now. OpsTask will need them when we add our ops.
    this->target(0)->priv().setLazyDimensions(fDynamicAtlas->drawBounds());
    this->target(0)->asRenderTargetProxy()->setNeedsStencil();
    SkRect drawRect = target(0)->getBoundsRect();
 
    // Clear the atlas.
    if (caps.performColorClearsAsDraws() || caps.performStencilClearsAsDraws()) {
        this->setColorLoadOp(GrLoadOp::kDiscard);
        this->setInitialStencilContent(StencilContent::kDontCare);
 
        constexpr static GrUserStencilSettings kClearStencil(
            GrUserStencilSettings::StaticInit<
                0x0000,
                GrUserStencilTest::kAlways,
                0xffff,
                GrUserStencilOp::kReplace,
                GrUserStencilOp::kReplace,
                0xffff>());
 
        this->stencilAtlasRect(rContext, drawRect, SK_PMColor4fTRANSPARENT, &kClearStencil);
    } else {
        this->setColorLoadOp(GrLoadOp::kClear);
        this->setInitialStencilContent(StencilContent::kUserBitsCleared);
    }
 
    // Add ops to stencil the atlas paths.
    for (const auto* pathList : {&fWindingPathList, &fEvenOddPathList}) {
        if (pathList->pathCount() > 0) {
            auto op = GrOp::Make<PathStencilCoverOp>(
                    rContext,
                    pathList->pathDrawList(),
                    pathList->totalCombinedPathVerbCnt(),
                    pathList->pathCount(),
                    GrPaint(),
                    GrAAType::kMSAA,
                    FillPathFlags::kStencilOnly,
                    drawRect);
            this->addAtlasDrawOp(std::move(op), caps);
        }
    }
 
    // Finally, draw a fullscreen rect to cover our stencilled paths.
    const GrUserStencilSettings* stencil;
    if (caps.discardStencilValuesAfterRenderPass()) {
        constexpr static GrUserStencilSettings kTestStencil(
            GrUserStencilSettings::StaticInit<
                0x0000,
                GrUserStencilTest::kNotEqual,
                0xffff,
                GrUserStencilOp::kKeep,
                GrUserStencilOp::kKeep,
                0xffff>());
 
        // This is the final op in the task. Since Ganesh is planning to discard the stencil values
        // anyway, there is no need to reset the stencil values back to 0.
        stencil = &kTestStencil;
    } else {
        constexpr static GrUserStencilSettings kTestAndResetStencil(
            GrUserStencilSettings::StaticInit<
                0x0000,
                GrUserStencilTest::kNotEqual,
                0xffff,
                GrUserStencilOp::kZero,
                GrUserStencilOp::kKeep,
                0xffff>());
 
        // Outset the cover rect to make extra sure we clear every stencil value touched by the
        // atlas.
        drawRect.outset(1, 1);
        stencil = &kTestAndResetStencil;
    }
    this->stencilAtlasRect(rContext, drawRect, SK_PMColor4fWHITE, stencil);
 
    this->OpsTask::onMakeClosed(rContext, targetUpdateBounds);
 
    // Don't mark msaa dirty. Since this op defers being closed, the drawing manager's dirty
    // tracking doesn't work anyway. We will just resolve msaa manually during onExecute.
    return ExpectedOutcome::kTargetUnchanged;
}

◆ readView()

GrSurfaceProxyView skgpu::ganesh::AtlasRenderTask::readView ( const GrCaps & caps ) const

inline

Definition at line 35 of file AtlasRenderTask.h.

35{ return fDynamicAtlas->readView(caps); }

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

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

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AtlasRenderTask()

Member Function Documentation

◆ addPath()

◆ atlasProxy()

◆ instantiate()

◆ onExecute()

◆ onMakeClosed()

◆ readView()