#include <DrawAtlasPathOp.h>

Inheritance diagram for skgpu::ganesh::DrawAtlasPathOp:

Public Member Functions
DEFINE_OP_CLASS_ID	DrawAtlasPathOp (SkArenaAlloc *arena, const SkIRect &fillBounds, const SkMatrix &localToDevice, GrPaint &&paint, SkIPoint16 locationInAtlas, const SkIRect &pathDevIBounds, bool transposedInAtlas, GrSurfaceProxyView atlasView, bool isInverseFill)

const char *	name () const override

FixedFunctionFlags	fixedFunctionFlags () const override

void	visitProxies (const GrVisitProxyFunc &func) const override

GrProcessorSet::Analysis	finalize (const GrCaps &, const GrAppliedClip *, GrClampType) override

CombineResult	onCombineIfPossible (GrOp , SkArenaAlloc , const GrCaps &) override

void	onPrePrepare (GrRecordingContext , const GrSurfaceProxyView &writeView, GrAppliedClip , const GrDstProxyView &, GrXferBarrierFlags, GrLoadOp colorLoadOp) override

void	onPrepare (GrOpFlushState *) override

void	onExecute (GrOpFlushState *, const SkRect &chainBounds) override

Public Member Functions inherited from GrDrawOp
	GrDrawOp (uint32_t classID)

virtual bool	usesMSAA () const

virtual ClipResult	clipToShape (skgpu::ganesh::SurfaceDrawContext *, SkClipOp, const SkMatrix &, const GrShape &, GrAA)

virtual GrProcessorSet::Analysis	finalize (const GrCaps &, const GrAppliedClip *, GrClampType)=0

virtual bool	usesStencil () const

Public Member Functions inherited from GrOp
virtual	~GrOp ()=default

virtual const char *	name () const =0

virtual void	visitProxies (const GrVisitProxyFunc &) const

CombineResult	combineIfPossible (GrOp that, SkArenaAlloc alloc, const GrCaps &caps)

const SkRect &	bounds () const

void	setClippedBounds (const SkRect &clippedBounds)

bool	hasAABloat () const

bool	hasZeroArea () const

void	operator delete (void *p)

template<typename T >
const T &	cast () const

template<typename T >
T *	cast ()

uint32_t	classID () const

uint32_t	uniqueID () const

void	prePrepare (GrRecordingContext context, const GrSurfaceProxyView &dstView, GrAppliedClip clip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)

void	prepare (GrOpFlushState *state)

void	execute (GrOpFlushState *state, const SkRect &chainBounds)

void	chainConcat (GrOp::Owner)

bool	isChainHead () const

bool	isChainTail () const

GrOp *	nextInChain () const

GrOp *	prevInChain () const

GrOp::Owner	cutChain ()

void	setBounds (const SkRect &newBounds, HasAABloat aabloat, IsHairline zeroArea)

void	setTransformedBounds (const SkRect &srcBounds, const SkMatrix &m, HasAABloat aabloat, IsHairline zeroArea)

void	makeFullScreen (GrSurfaceProxy *proxy)

Additional Inherited Members
Public Types inherited from GrDrawOp
enum class	ClipResult { kFail , kClippedGeometrically , kClippedInShader , kClippedOut }

Public Types inherited from GrOp
enum class	CombineResult { kMerged , kMayChain , kCannotCombine }

enum class	HasAABloat : bool { kNo = false , kYes = true }

enum class	IsHairline : bool { kNo = false , kYes = true }

using	Owner = std::unique_ptr< GrOp >

Static Public Member Functions inherited from GrOp
template<typename Op , typename... Args>
static Owner	Make (GrRecordingContext *context, Args &&... args)

template<typename Op , typename... Args>
static Owner	MakeWithProcessorSet (GrRecordingContext *context, const SkPMColor4f &color, GrPaint &&paint, Args &&... args)

template<typename Op , typename... Args>
static Owner	MakeWithExtraMemory (GrRecordingContext *context, size_t extraSize, Args &&... args)

static uint32_t	GenOpClassID ()

Protected Types inherited from GrDrawOp
enum class	FixedFunctionFlags : uint32_t { kNone = 0x0 , kUsesHWAA = 0x1 , kUsesStencil = 0x2 }

Protected Member Functions inherited from GrDrawOp
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (FixedFunctionFlags)

virtual FixedFunctionFlags	fixedFunctionFlags () const

Detailed Description

Definition at line 42 of file DrawAtlasPathOp.h.

Constructor & Destructor Documentation

◆ DrawAtlasPathOp()

DEFINE_OP_CLASS_ID skgpu::ganesh::DrawAtlasPathOp::DrawAtlasPathOp	(	SkArenaAlloc *	arena,
		const SkIRect &	fillBounds,
		const SkMatrix &	localToDevice,
		GrPaint &&	paint,
		SkIPoint16	locationInAtlas,
		const SkIRect &	pathDevIBounds,
		bool	transposedInAtlas,
		GrSurfaceProxyView	atlasView,
		bool	isInverseFill
	)

inline

Definition at line 46 of file DrawAtlasPathOp.h.

            : GrDrawOp(ClassID())
            , fHeadInstance(arena->make<Instance>(fillBounds, localToDevice, paint.getColor4f(),
                                                  locationInAtlas, pathDevIBounds,
                                                  transposedInAtlas))
            , fTailInstance(&fHeadInstance->fNext)
            , fAtlasHelper(std::move(atlasView),
                           isInverseFill ? AtlasInstancedHelper::ShaderFlags::kCheckBounds |
                                           AtlasInstancedHelper::ShaderFlags::kInvertCoverage
                                         : AtlasInstancedHelper::ShaderFlags::kNone)
            , fProcessors(std::move(paint)) {
        this->setBounds(SkRect::Make(fillBounds), HasAABloat::kYes, IsHairline::kNo);
    }

Member Function Documentation

◆ finalize()

GrProcessorSet::Analysis skgpu::ganesh::DrawAtlasPathOp::finalize	(	const GrCaps &	,
		const GrAppliedClip *	,
		GrClampType
	)

overridevirtual

This is called after the GrAppliedClip has been computed and just prior to recording the op or combining it with a previously recorded op. The op should convert any proxies or resources it owns to "pending io" status so that resource allocation can be more optimal. Additionally, at this time the op must report whether a copy of the destination (or destination texture itself) needs to be provided to the GrXferProcessor when this op executes.

Implements GrDrawOp.

Definition at line 156 of file DrawAtlasPathOp.cpp.

                                                                          {
    const GrProcessorSet::Analysis& analysis = fProcessors.finalize(
            fHeadInstance->fColor, GrProcessorAnalysisCoverage::kSingleChannel, clip,
            &GrUserStencilSettings::kUnused, caps, clampType, &fHeadInstance->fColor);
    fUsesLocalCoords = analysis.usesLocalCoords();
    return analysis;
}

◆ fixedFunctionFlags()

FixedFunctionFlags skgpu::ganesh::DrawAtlasPathOp::fixedFunctionFlags ( ) const

inlineoverridevirtual

Reimplemented from GrDrawOp.

Definition at line 63 of file DrawAtlasPathOp.h.

63{ return FixedFunctionFlags::kNone; }

GrDrawOp::FixedFunctionFlags::kNone

@ kNone

◆ name()

const char * skgpu::ganesh::DrawAtlasPathOp::name ( ) const

inlineoverridevirtual

Implements GrOp.

Definition at line 62 of file DrawAtlasPathOp.h.

62{ return "DrawAtlasPathOp"; }

◆ onCombineIfPossible()

GrOp::CombineResult skgpu::ganesh::DrawAtlasPathOp::onCombineIfPossible	(	GrOp *	op,
		SkArenaAlloc *	,
		const GrCaps &
	)

overridevirtual

Reimplemented from GrOp.

Definition at line 165 of file DrawAtlasPathOp.cpp.

                                                                                             {
    auto that = op->cast<DrawAtlasPathOp>();
 
    if (!fAtlasHelper.isCompatible(that->fAtlasHelper) ||
        fProcessors != that->fProcessors) {
        return CombineResult::kCannotCombine;
    }
 
    SkASSERT(fUsesLocalCoords == that->fUsesLocalCoords);
    *fTailInstance = that->fHeadInstance;
    fTailInstance = that->fTailInstance;
    fInstanceCount += that->fInstanceCount;
    return CombineResult::kMerged;
}

◆ onExecute()

void skgpu::ganesh::DrawAtlasPathOp::onExecute	(	GrOpFlushState *	flushState,
		const SkRect &	chainBounds
	)

overridevirtual

Implements GrOp.

Definition at line 248 of file DrawAtlasPathOp.cpp.

                                                                                     {
    if (fProgram->geomProc().hasVertexAttributes() && !fVertexBufferIfNoIDSupport) {
        return;
    }
    flushState->bindPipelineAndScissorClip(*fProgram, this->bounds());
    flushState->bindTextures(fProgram->geomProc(), *fAtlasHelper.proxy(), fProgram->pipeline());
    flushState->bindBuffers(nullptr, std::move(fInstanceBuffer), fVertexBufferIfNoIDSupport);
    flushState->drawInstanced(fInstanceCount, fBaseInstance, 4, 0);
}

◆ onPrepare()

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

overridevirtual

Implements GrOp.

Definition at line 217 of file DrawAtlasPathOp.cpp.

                                                          {
    if (!fProgram) {
        this->prepareProgram(flushState->caps(), flushState->allocator(), flushState->writeView(),
                             flushState->usesMSAASurface(), flushState->detachAppliedClip(),
                             flushState->dstProxyView(), flushState->renderPassBarriers(),
                             flushState->colorLoadOp());
        SkASSERT(fProgram);
    }
 
    if (VertexWriter instanceWriter = flushState->makeVertexWriter(
                fProgram->geomProc().instanceStride(), fInstanceCount, &fInstanceBuffer,
                &fBaseInstance)) {
        for (const Instance* i = fHeadInstance; i; i = i->fNext) {
            instanceWriter << SkRect::Make(i->fFillBounds)
                           << VertexWriter::If(fUsesLocalCoords,
                                               i->fLocalToDeviceIfUsingLocalCoords)
                           << i->fColor;
            fAtlasHelper.writeInstanceData(&instanceWriter, &i->fAtlasInstance);
        }
    }
 
    if (!flushState->caps().shaderCaps()->fVertexIDSupport) {
        constexpr static SkPoint kUnitQuad[4] = {{0,0}, {0,1}, {1,0}, {1,1}};
 
        SKGPU_DEFINE_STATIC_UNIQUE_KEY(gUnitQuadBufferKey);
 
        fVertexBufferIfNoIDSupport = flushState->resourceProvider()->findOrMakeStaticBuffer(
                GrGpuBufferType::kVertex, sizeof(kUnitQuad), kUnitQuad, gUnitQuadBufferKey);
    }
}

◆ onPrePrepare()

void skgpu::ganesh::DrawAtlasPathOp::onPrePrepare	(	GrRecordingContext *	rContext,
		const GrSurfaceProxyView &	writeView,
		GrAppliedClip *	appliedClip,
		const GrDstProxyView &	dstProxyView,
		GrXferBarrierFlags	renderPassXferBarriers,
		GrLoadOp	colorLoadOp
	)

overridevirtual

Implements GrOp.

Definition at line 201 of file DrawAtlasPathOp.cpp.

                                                         {
    // DMSAA is not supported on DDL.
    bool usesMSAASurface = writeView.asRenderTargetProxy()->numSamples() > 1;
    this->prepareProgram(*rContext->priv().caps(), rContext->priv().recordTimeAllocator(),
                         writeView, usesMSAASurface, std::move(*appliedClip), dstProxyView,
                         renderPassXferBarriers, colorLoadOp);
    SkASSERT(fProgram);
    rContext->priv().recordProgramInfo(fProgram);
}

◆ visitProxies()

void skgpu::ganesh::DrawAtlasPathOp::visitProxies ( const GrVisitProxyFunc & func ) const

inlineoverridevirtual

Reimplemented from GrOp.

Definition at line 64 of file DrawAtlasPathOp.h.

                                                                   {
        func(fAtlasHelper.proxy(), skgpu::Mipmapped::kNo);
        fProcessors.visitProxies(func);
    }

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DrawAtlasPathOp()

Member Function Documentation

◆ finalize()

◆ fixedFunctionFlags()

◆ name()

◆ onCombineIfPossible()

◆ onExecute()

◆ onPrepare()

◆ onPrePrepare()

◆ visitProxies()