skgpu::ganesh::StrokeTessellateOp Class Reference

#include <StrokeTessellateOp.h>

Inheritance diagram for skgpu::ganesh::StrokeTessellateOp:

Public Member Functions
	StrokeTessellateOp (GrAAType, const SkMatrix &, const SkPath &, const SkStrokeRec &, GrPaint &&)
Public Member Functions inherited from GrDrawOp
	GrDrawOp (uint32_t classID)
virtual ClipResult	clipToShape (skgpu::ganesh::SurfaceDrawContext *, SkClipOp, const SkMatrix &, const GrShape &, GrAA)
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)

Private Member Functions
const char *	name () const override
void	visitProxies (const GrVisitProxyFunc &) const override
bool	usesMSAA () const override
GrProcessorSet::Analysis	finalize (const GrCaps &, const GrAppliedClip *, GrClampType) override
bool	usesStencil () const override
CombineResult	onCombineIfPossible (GrOp *, SkArenaAlloc *, const GrCaps &) override
void	onPrePrepare (GrRecordingContext *, const GrSurfaceProxyView &, GrAppliedClip *, const GrDstProxyView &, GrXferBarrierFlags, GrLoadOp colorLoadOp) override
void	onPrepare (GrOpFlushState *) override
void	onExecute (GrOpFlushState *, const SkRect &chainBounds) override

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 23 of file StrokeTessellateOp.h.

Constructor & Destructor Documentation

StrokeTessellateOp()

skgpu::ganesh::StrokeTessellateOp::StrokeTessellateOp	(	GrAAType	aaType,
		const SkMatrix &	viewMatrix,
		const SkPath &	path,
		const SkStrokeRec &	stroke,
		GrPaint &&	paint
	)

Definition at line 20 of file StrokeTessellateOp.cpp.

        : GrDrawOp(ClassID())
        , fAAType(aaType)
        , fViewMatrix(viewMatrix)
        , fPathStrokeList(path, stroke, paint.getColor4f())
        , fTotalCombinedVerbCnt(path.countVerbs())
        , fProcessors(std::move(paint)) {
    if (!this->headColor().fitsInBytes()) {
        fPatchAttribs |= PatchAttribs::kWideColorIfEnabled;
    }
    SkRect devBounds = path.getBounds();
    if (!this->headStroke().isHairlineStyle()) {
        // Non-hairlines inflate in local path space (pre-transform).
        float r = stroke.getInflationRadius();
        devBounds.outset(r, r);
    }
    viewMatrix.mapRect(&devBounds, devBounds);
    if (this->headStroke().isHairlineStyle()) {
        // Hairlines inflate in device space (post-transform).
        float r = SkStrokeRec::GetInflationRadius(stroke.getJoin(), stroke.getMiter(),
                                                  stroke.getCap(), 1);
        devBounds.outset(r, r);
    }
    this->setBounds(devBounds, HasAABloat::kNo, IsHairline::kNo);
}

Member Function Documentation

finalize()

GrProcessorSet::Analysis skgpu::ganesh::StrokeTessellateOp::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 58 of file StrokeTessellateOp.cpp.

                                                                             {
    // Make sure the finalize happens before combining. We might change fNeedsStencil here.
    SkASSERT(fPathStrokeList.fNext == nullptr);
    if (!caps.shaderCaps()->fInfinitySupport) {
        // The GPU can't infer curve type based in infinity, so we need to send in an attrib
        // explicitly stating the curve type.
        fPatchAttribs |= PatchAttribs::kExplicitCurveType;
    }
    const GrProcessorSet::Analysis& analysis = fProcessors.finalize(
            this->headColor(), GrProcessorAnalysisCoverage::kNone, clip,
            &GrUserStencilSettings::kUnused, caps, clampType, &this->headColor());
    fNeedsStencil = !analysis.unaffectedByDstValue();
    return analysis;
}

name()

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

inlineoverrideprivatevirtual

Implements GrOp.

Definition at line 48 of file StrokeTessellateOp.h.

{ return "StrokeTessellateOp"; }

onCombineIfPossible()

GrOp::CombineResult skgpu::ganesh::StrokeTessellateOp::onCombineIfPossible ( GrOp *  grOp, SkArenaAlloc *  alloc, const GrCaps &  caps  )

overrideprivatevirtual

Reimplemented from GrOp.

Definition at line 75 of file StrokeTessellateOp.cpp.

                                                                                {
    SkASSERT(grOp->classID() == this->classID());
    auto* op = static_cast<StrokeTessellateOp*>(grOp);
 
    // This must be called after finalize(). fNeedsStencil can change in finalize().
    SkASSERT(fProcessors.isFinalized());
    SkASSERT(op->fProcessors.isFinalized());
 
    if (fNeedsStencil ||
        op->fNeedsStencil ||
        fViewMatrix != op->fViewMatrix ||
        fAAType != op->fAAType ||
        fProcessors != op->fProcessors ||
        this->headStroke().isHairlineStyle() != op->headStroke().isHairlineStyle()) {
        return CombineResult::kCannotCombine;
    }
 
    auto combinedAttribs = fPatchAttribs | op->fPatchAttribs;
    if (!(combinedAttribs & PatchAttribs::kStrokeParams) &&
        !tess::StrokesHaveEqualParams(this->headStroke(), op->headStroke())) {
        // The paths have different stroke properties. We will need to enable dynamic stroke if we
        // still decide to combine them.
        if (this->headStroke().isHairlineStyle()) {
            return CombineResult::kCannotCombine;  // Dynamic hairlines aren't supported.
        }
        combinedAttribs |= PatchAttribs::kStrokeParams;
    }
    if (!(combinedAttribs & PatchAttribs::kColor) && this->headColor() != op->headColor()) {
        // The paths have different colors. We will need to enable dynamic color if we still decide
        // to combine them.
        combinedAttribs |= PatchAttribs::kColor;
    }
 
    // Don't actually enable new dynamic state on ops that already have lots of verbs.
    constexpr static GrTFlagsMask<PatchAttribs> kDynamicStatesMask(PatchAttribs::kStrokeParams |
                                                                   PatchAttribs::kColor);
    PatchAttribs neededDynamicStates = combinedAttribs & kDynamicStatesMask;
    if (neededDynamicStates != PatchAttribs::kNone) {
        if (!this->shouldUseDynamicStates(neededDynamicStates) ||
            !op->shouldUseDynamicStates(neededDynamicStates)) {
            return CombineResult::kCannotCombine;
        }
    }
 
    fPatchAttribs = combinedAttribs;
 
    // Concat the op's PathStrokeList. Since the head element is allocated inside the op, we need to
    // copy it.
    auto* headCopy = alloc->make<PathStrokeList>(std::move(op->fPathStrokeList));
    *fPathStrokeTail = headCopy;
    fPathStrokeTail = (op->fPathStrokeTail == &op->fPathStrokeList.fNext) ? &headCopy->fNext
                                                                          : op->fPathStrokeTail;
 
    fTotalCombinedVerbCnt += op->fTotalCombinedVerbCnt;
    return CombineResult::kMerged;
}

onExecute()

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

overrideprivatevirtual

Implements GrOp.

Definition at line 228 of file StrokeTessellateOp.cpp.

                                                                                        {
    if (fStencilProgram) {
        flushState->bindPipelineAndScissorClip(*fStencilProgram, chainBounds);
        flushState->bindTextures(fStencilProgram->geomProc(), nullptr, fStencilProgram->pipeline());
        fTessellator->draw(flushState);
    }
    if (fFillProgram) {
        flushState->bindPipelineAndScissorClip(*fFillProgram, chainBounds);
        flushState->bindTextures(fFillProgram->geomProc(), nullptr, fFillProgram->pipeline());
        fTessellator->draw(flushState);
    }
}

onPrepare()

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

overrideprivatevirtual

Implements GrOp.

Definition at line 214 of file StrokeTessellateOp.cpp.

                                                             {
    if (!fTessellator) {
        this->prePrepareTessellator({flushState->allocator(), flushState->writeView(),
                                    flushState->usesMSAASurface(), &flushState->dstProxyView(),
                                    flushState->renderPassBarriers(), flushState->colorLoadOp(),
                                    &flushState->caps()}, flushState->detachAppliedClip());
    }
    SkASSERT(fTessellator);
    fTessellator->prepare(flushState,
                          fViewMatrix,
                          &fPathStrokeList,
                          fTotalCombinedVerbCnt);
}

onPrePrepare()

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

overrideprivatevirtual

Implements GrOp.

Definition at line 195 of file StrokeTessellateOp.cpp.

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

usesMSAA()

bool skgpu::ganesh::StrokeTessellateOp::usesMSAA ( ) const

inlineoverrideprivatevirtual

Called before setting up the GrAppliedClip and before finalize. This information is required to determine how to compute a GrAppliedClip from a GrClip for this op.

Reimplemented from GrDrawOp.

Definition at line 50 of file StrokeTessellateOp.h.

{ return fAAType == GrAAType::kMSAA; }

usesStencil()

bool skgpu::ganesh::StrokeTessellateOp::usesStencil ( ) const

inlineoverrideprivatevirtual

Called after finalize, at which point every op should know whether it will need stencil.

Reimplemented from GrDrawOp.

Definition at line 52 of file StrokeTessellateOp.h.

                                      {
        // This must be called after finalize(). fNeedsStencil can change in finalize().
        SkASSERT(fProcessors.isFinalized());
        return fNeedsStencil;
    }

visitProxies()

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

overrideprivatevirtual

Reimplemented from GrOp.

Definition at line 48 of file StrokeTessellateOp.cpp.

                                                                        {
    if (fFillProgram) {
        fFillProgram->visitFPProxies(func);
    } else if (fStencilProgram) {
        fStencilProgram->visitFPProxies(func);
    } else {
        fProcessors.visitProxies(func);
    }
}

---

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

• third_party/skia/src/gpu/ganesh/ops/StrokeTessellateOp.h
• third_party/skia/src/gpu/ganesh/ops/StrokeTessellateOp.cpp