#include <PathStencilCoverOp.h>

Inheritance diagram for skgpu::ganesh::PathStencilCoverOp:

Private Member Functions
const char *	name () const override

void	visitProxies (const GrVisitProxyFunc &) const override

FixedFunctionFlags	fixedFunctionFlags () const override

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

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

void	onPrepare (GrOpFlushState *) override

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

Friends
class	GrOp

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 >

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 bool	usesStencil () const

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

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)

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)

Detailed Description

Definition at line 21 of file PathStencilCoverOp.h.

Member Function Documentation

◆ finalize()

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

overrideprivatevirtual

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 125 of file PathStencilCoverOp.cpp.

                                                                             {
    return fProcessors.finalize(fColor, GrProcessorAnalysisCoverage::kNone, clip, nullptr, caps,
                                clampType, &fColor);
}

◆ fixedFunctionFlags()

GrDrawOp::FixedFunctionFlags skgpu::ganesh::PathStencilCoverOp::fixedFunctionFlags ( ) const

overrideprivatevirtual

Reimplemented from GrDrawOp.

Definition at line 117 of file PathStencilCoverOp.cpp.

                                                                        {
    auto flags = FixedFunctionFlags::kUsesStencil;
    if (fAAType != GrAAType::kNone) {
        flags |= FixedFunctionFlags::kUsesHWAA;
    }
    return flags;
}

◆ name()

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

inlineoverrideprivatevirtual

Implements GrOp.

Definition at line 70 of file PathStencilCoverOp.h.

70{ return "PathStencilCoverOp"; }

◆ onExecute()

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

overrideprivatevirtual

Implements GrOp.

Definition at line 318 of file PathStencilCoverOp.cpp.

                                                                                        {
    if (!fTessellator) {
        return;
    }
 
    if (fCoverBBoxProgram &&
        fCoverBBoxProgram->geomProc().hasVertexAttributes() &&
        !fBBoxVertexBufferIfNoIDSupport) {
        return;
    }
 
    // Stencil the inner fan, if any.
    if (fFanVertexCount > 0) {
        SkASSERT(fStencilFanProgram);
        SkASSERT(fFanBuffer);
        flushState->bindPipelineAndScissorClip(*fStencilFanProgram, this->bounds());
        flushState->bindBuffers(nullptr, nullptr, fFanBuffer);
        flushState->draw(fFanVertexCount, fFanBaseVertex);
    }
 
    // Stencil the rest of the path.
    SkASSERT(fStencilPathProgram);
    flushState->bindPipelineAndScissorClip(*fStencilPathProgram, this->bounds());
    fTessellator->draw(flushState);
 
    // Fill in the bounding box (if not in stencil-only mode).
    if (fCoverBBoxProgram) {
        flushState->bindPipelineAndScissorClip(*fCoverBBoxProgram, this->bounds());
        flushState->bindTextures(fCoverBBoxProgram->geomProc(), nullptr,
                                 fCoverBBoxProgram->pipeline());
        flushState->bindBuffers(nullptr, fBBoxBuffer, fBBoxVertexBufferIfNoIDSupport);
        flushState->drawInstanced(fPathCount, fBBoxBaseInstance, 4, 0);
    }
}

◆ onPrepare()

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

overrideprivatevirtual

Implements GrOp.

Definition at line 224 of file PathStencilCoverOp.cpp.

                                                             {
    if (!fTessellator) {
        this->prePreparePrograms({flushState->allocator(), flushState->writeView(),
                                 flushState->usesMSAASurface(), &flushState->dstProxyView(),
                                 flushState->renderPassBarriers(), flushState->colorLoadOp(),
                                 &flushState->caps()}, flushState->detachAppliedClip());
        if (!fTessellator) {
            return;
        }
    }
 
    if (fStencilFanProgram) {
        // The inner fan isn't built into the tessellator. Generate a standard Redbook fan with a
        // middle-out topology.
        GrEagerDynamicVertexAllocator vertexAlloc(flushState, &fFanBuffer, &fFanBaseVertex);
        // Path fans might have an extra edge from an implicit kClose at the end, but they also
        // always begin with kMove. So the max possible number of edges in a single path is equal to
        // the number of verbs. Therefore, the max number of combined fan edges in a path list is
        // the number of combined verbs from the paths in the list.
        // A single n-sided polygon is fanned by n-2 triangles. Multiple polygons with a combined
        // edge count of n are fanned by strictly fewer triangles.
        int maxTrianglesInFans = std::max(fTotalCombinedPathVerbCnt - 2, 0);
        int fanTriangleCount = 0;
        if (VertexWriter triangleVertexWriter =
                    vertexAlloc.lockWriter(sizeof(SkPoint), maxTrianglesInFans * 3)) {
            for (auto [pathMatrix, path, color] : *fPathDrawList) {
                tess::AffineMatrix m(pathMatrix);
                for (tess::PathMiddleOutFanIter it(path); !it.done();) {
                    for (auto [p0, p1, p2] : it.nextStack()) {
                        triangleVertexWriter << m.map2Points(p0, p1) << m.mapPoint(p2);
                        ++fanTriangleCount;
                    }
                }
            }
 
 
            SkASSERT(fanTriangleCount <= maxTrianglesInFans);
            fFanVertexCount = fanTriangleCount * 3;
            vertexAlloc.unlock(fFanVertexCount);
        }
    }
 
    auto tessShader = &fStencilPathProgram->geomProc().cast<GrPathTessellationShader>();
    fTessellator->prepare(flushState,
                          tessShader->viewMatrix(),
                          *fPathDrawList,
                          fTotalCombinedPathVerbCnt);
 
    if (fCoverBBoxProgram) {
        size_t instanceStride = fCoverBBoxProgram->geomProc().instanceStride();
        VertexWriter vertexWriter = flushState->makeVertexWriter(instanceStride,
                                                                 fPathCount,
                                                                 &fBBoxBuffer,
                                                                 &fBBoxBaseInstance);
        SkDEBUGCODE(int pathCount = 0;)
        for (auto [pathMatrix, path, color] : *fPathDrawList) {
            SkDEBUGCODE(auto end = vertexWriter.mark(instanceStride));
            vertexWriter << pathMatrix.getScaleX()
                         << pathMatrix.getSkewY()
                         << pathMatrix.getSkewX()
                         << pathMatrix.getScaleY()
                         << pathMatrix.getTranslateX()
                         << pathMatrix.getTranslateY();
            if (path.isInverseFillType()) {
                // Fill the entire backing store to make sure we clear every stencil value back to
                // 0. If there is a scissor it will have already clipped the stencil draw.
                auto rtBounds =
                        flushState->writeView().asRenderTargetProxy()->backingStoreBoundsRect();
                SkASSERT(rtBounds == fOriginalDrawBounds);
                SkRect pathSpaceRTBounds;
                if (SkMatrixPriv::InverseMapRect(pathMatrix, &pathSpaceRTBounds, rtBounds)) {
                    vertexWriter << pathSpaceRTBounds;
                } else {
                    vertexWriter << path.getBounds();
                }
            } else {
                vertexWriter << path.getBounds();
            }
            SkASSERT(vertexWriter.mark() == end);
            SkDEBUGCODE(++pathCount;)
        }
        SkASSERT(pathCount == fPathCount);
    }
 
    if (!flushState->caps().shaderCaps()->fVertexIDSupport) {
        constexpr static SkPoint kUnitQuad[4] = {{0,0}, {0,1}, {1,0}, {1,1}};
 
        SKGPU_DEFINE_STATIC_UNIQUE_KEY(gUnitQuadBufferKey);
 
        fBBoxVertexBufferIfNoIDSupport = flushState->resourceProvider()->findOrMakeStaticBuffer(
                GrGpuBufferType::kVertex, sizeof(kUnitQuad), kUnitQuad, gUnitQuadBufferKey);
    }
}

◆ onPrePrepare()

void skgpu::ganesh::PathStencilCoverOp::onPrePrepare	(	GrRecordingContext *	context,
		const GrSurfaceProxyView &	writeView,
		GrAppliedClip *	clip,
		const GrDstProxyView &	dstProxyView,
		GrXferBarrierFlags	renderPassXferBarriers,
		GrLoadOp	colorLoadOp
	)

overrideprivatevirtual

Implements GrOp.

Definition at line 200 of file PathStencilCoverOp.cpp.

                                                            {
    // DMSAA is not supported on DDL.
    bool usesMSAASurface = writeView.asRenderTargetProxy()->numSamples() > 1;
    this->prePreparePrograms({context->priv().recordTimeAllocator(), writeView, usesMSAASurface,
                             &dstProxyView, renderPassXferBarriers, colorLoadOp,
                             context->priv().caps()},
                             (clip) ? std::move(*clip) : GrAppliedClip::Disabled());
    if (fStencilFanProgram) {
        context->priv().recordProgramInfo(fStencilFanProgram);
    }
    if (fStencilPathProgram) {
        context->priv().recordProgramInfo(fStencilPathProgram);
    }
    if (fCoverBBoxProgram) {
        context->priv().recordProgramInfo(fCoverBBoxProgram);
    }
}

◆ visitProxies()

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

overrideprivatevirtual

Reimplemented from GrOp.

Definition at line 109 of file PathStencilCoverOp.cpp.

                                                                        {
    if (fCoverBBoxProgram) {
        fCoverBBoxProgram->pipeline().visitProxies(func);
    } else {
        fProcessors.visitProxies(func);
    }
}

Friends And Related Symbol Documentation

◆ GrOp

friend class GrOp

friend

Definition at line 115 of file PathStencilCoverOp.h.

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

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

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ finalize()

◆ fixedFunctionFlags()

◆ name()

◆ onExecute()

◆ onPrepare()

◆ onPrePrepare()

◆ visitProxies()

Friends And Related Symbol Documentation

◆ GrOp