EllipticalRRectOp Class Reference

Inheritance diagram for EllipticalRRectOp:

Public Member Functions
	EllipticalRRectOp (GrProcessorSet *processorSet, const SkPMColor4f &color, const SkMatrix &viewMatrix, const SkRect &devRect, float devXRadius, float devYRadius, SkVector devStrokeHalfWidths, bool strokeOnly)
const char *	name () const override
void	visitProxies (const GrVisitProxyFunc &func) const override
GrProcessorSet::Analysis	finalize (const GrCaps &caps, const GrAppliedClip *clip, GrClampType clampType) override
FixedFunctionFlags	fixedFunctionFlags () const 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)

Static Public Member Functions
static DEFINE_OP_CLASS_ID GrOp::Owner	Make (GrRecordingContext *context, GrPaint &&paint, const SkMatrix &viewMatrix, const SkRect &devRect, float devXRadius, float devYRadius, SkVector devStrokeWidths, bool strokeOnly)
Static Public Member Functions inherited from GrMeshDrawOp
static bool	CanUpgradeAAOnMerge (GrAAType aa1, GrAAType aa2)
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 ()

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 >
Protected Types inherited from GrDrawOp
enum class	FixedFunctionFlags : uint32_t { kNone = 0x0 , kUsesHWAA = 0x1 , kUsesStencil = 0x2 }
Protected Member Functions inherited from GrMeshDrawOp
	GrMeshDrawOp (uint32_t classID)
void	createProgramInfo (const GrCaps *caps, SkArenaAlloc *arena, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&appliedClip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
void	createProgramInfo (GrMeshDrawTarget *)
virtual void	onPrePrepareDraws (GrRecordingContext *, const GrSurfaceProxyView &writeView, GrAppliedClip *, const GrDstProxyView &, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
Protected Member Functions inherited from GrDrawOp
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (FixedFunctionFlags)
virtual FixedFunctionFlags	fixedFunctionFlags () const
Static Protected Member Functions inherited from GrMeshDrawOp
static bool	CombinedQuadCountWillOverflow (GrAAType aaType, bool willBeUpgradedToAA, int combinedQuadCount)

Detailed Description

Definition at line 2877 of file GrOvalOpFactory.cpp.

Constructor & Destructor Documentation

EllipticalRRectOp()

EllipticalRRectOp::EllipticalRRectOp ( GrProcessorSet *  processorSet, const SkPMColor4f &  color, const SkMatrix &  viewMatrix, const SkRect &  devRect, float  devXRadius, float  devYRadius, SkVector  devStrokeHalfWidths, bool  strokeOnly  )

inline

Definition at line 2928 of file GrOvalOpFactory.cpp.

            : INHERITED(ClassID())
            , fHelper(processorSet, GrAAType::kCoverage)
            , fUseScale(false) {
        SkScalar innerXRadius = 0.0f;
        SkScalar innerYRadius = 0.0f;
        SkRect bounds = devRect;
        bool stroked = false;
        if (devStrokeHalfWidths.fX > 0) {
            // this is legit only if scale & translation (which should be the case at the moment)
            if (strokeOnly) {
                innerXRadius = devXRadius - devStrokeHalfWidths.fX;
                innerYRadius = devYRadius - devStrokeHalfWidths.fY;
                stroked = (innerXRadius >= 0 && innerYRadius >= 0);
            }
 
            devXRadius += devStrokeHalfWidths.fX;
            devYRadius += devStrokeHalfWidths.fY;
            bounds.outset(devStrokeHalfWidths.fX, devStrokeHalfWidths.fY);
        }
 
        fStroked = stroked;
        fViewMatrixIfUsingLocalCoords = viewMatrix;
        this->setBounds(bounds, HasAABloat::kYes, IsHairline::kNo);
        fRRects.emplace_back(
                RRect{color, devXRadius, devYRadius, innerXRadius, innerYRadius, bounds});
    }

Member Function Documentation

finalize()

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

inlineoverridevirtual

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 2968 of file GrOvalOpFactory.cpp.

                                                                      {
        fUseScale = !caps.shaderCaps()->fFloatIs32Bits;
        SkPMColor4f* color = &fRRects.front().fColor;
        return fHelper.finalizeProcessors(caps, clip, clampType,
                                          GrProcessorAnalysisCoverage::kSingleChannel, color,
                                          &fWideColor);
    }

fixedFunctionFlags()

FixedFunctionFlags EllipticalRRectOp::fixedFunctionFlags ( ) const

inlineoverridevirtual

Reimplemented from GrDrawOp.

Definition at line 2977 of file GrOvalOpFactory.cpp.

{ return fHelper.fixedFunctionFlags(); }

Make()

static DEFINE_OP_CLASS_ID GrOp::Owner EllipticalRRectOp::Make ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, const SkRect &  devRect, float  devXRadius, float  devYRadius, SkVector  devStrokeWidths, bool  strokeOnly  )

inlinestatic

Definition at line 2886 of file GrOvalOpFactory.cpp.

                                             {
        SkASSERT(devXRadius >= 0.5 || strokeOnly);
        SkASSERT(devYRadius >= 0.5 || strokeOnly);
        SkASSERT((devStrokeWidths.fX > 0) == (devStrokeWidths.fY > 0));
        SkASSERT(!(strokeOnly && devStrokeWidths.fX <= 0));
        if (devStrokeWidths.fX > 0) {
            if (SkScalarNearlyZero(devStrokeWidths.length())) {
                devStrokeWidths.set(SK_ScalarHalf, SK_ScalarHalf);
            } else {
                devStrokeWidths.scale(SK_ScalarHalf);
            }
 
            // we only handle thick strokes for near-circular ellipses
            if (devStrokeWidths.length() > SK_ScalarHalf &&
                (SK_ScalarHalf * devXRadius > devYRadius ||
                 SK_ScalarHalf * devYRadius > devXRadius)) {
                return nullptr;
            }
 
            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
            if (devStrokeWidths.fX * (devYRadius * devYRadius) <
                (devStrokeWidths.fY * devStrokeWidths.fY) * devXRadius) {
                return nullptr;
            }
            if (devStrokeWidths.fY * (devXRadius * devXRadius) <
                (devStrokeWidths.fX * devStrokeWidths.fX) * devYRadius) {
                return nullptr;
            }
        }
        return Helper::FactoryHelper<EllipticalRRectOp>(context, std::move(paint),
                                                        viewMatrix, devRect,
                                                        devXRadius, devYRadius, devStrokeWidths,
                                                        strokeOnly);
    }

name()

const char * EllipticalRRectOp::name ( ) const

inlineoverridevirtual

Implements GrOp.

Definition at line 2958 of file GrOvalOpFactory.cpp.

{ return "EllipticalRRectOp"; }

visitProxies()

void EllipticalRRectOp::visitProxies ( const GrVisitProxyFunc &  func ) const

inlineoverridevirtual

Reimplemented from GrOp.

Definition at line 2960 of file GrOvalOpFactory.cpp.

                                                                   {
        if (fProgramInfo) {
            fProgramInfo->visitFPProxies(func);
        } else {
            fHelper.visitProxies(func);
        }
    }

---

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

• third_party/skia/src/gpu/ganesh/ops/GrOvalOpFactory.cpp