Inheritance diagram for DIEllipseOp:

Public Member Functions
	DIEllipseOp (GrProcessorSet *processorSet, const SkPMColor4f &color, const DeviceSpaceParams &params, const SkMatrix &viewMatrix)

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 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
static DEFINE_OP_CLASS_ID GrOp::Owner	Make (GrRecordingContext *context, GrPaint &&paint, const SkMatrix &viewMatrix, const SkRect &ellipse, const SkStrokeRec &stroke)

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 ()

Private Member Functions
GrProgramInfo *	programInfo () override

void	onCreateProgramInfo (const GrCaps caps, SkArenaAlloc arena, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&appliedClip, const GrDstProxyView &dstProxyView, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp) override

void	onPrepareDraws (GrMeshDrawTarget *target) override

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

CombineResult	onCombineIfPossible (GrOp t, SkArenaAlloc , const GrCaps &caps) 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 >

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)

Static Protected Member Functions inherited from GrMeshDrawOp
static bool	CombinedQuadCountWillOverflow (GrAAType aaType, bool willBeUpgradedToAA, int combinedQuadCount)

Detailed Description

Definition at line 2113 of file GrOvalOpFactory.cpp.

Constructor & Destructor Documentation

◆ DIEllipseOp()

DIEllipseOp::DIEllipseOp	(	GrProcessorSet *	processorSet,
		const SkPMColor4f &	color,
		const DeviceSpaceParams &	params,
		const SkMatrix &	viewMatrix
	)

inline

Definition at line 2201 of file GrOvalOpFactory.cpp.

            : INHERITED(ClassID())
            , fHelper(processorSet, GrAAType::kCoverage)
            , fUseScale(false) {
        // This expands the outer rect so that after CTM we end up with a half-pixel border
        SkScalar a = viewMatrix[SkMatrix::kMScaleX];
        SkScalar b = viewMatrix[SkMatrix::kMSkewX];
        SkScalar c = viewMatrix[SkMatrix::kMSkewY];
        SkScalar d = viewMatrix[SkMatrix::kMScaleY];
        SkScalar geoDx = 1.f / SkScalarSqrt(a * a + c * c);
        SkScalar geoDy = 1.f / SkScalarSqrt(b * b + d * d);
 
        fEllipses.emplace_back(
                Ellipse{viewMatrix, color, params.fXRadius, params.fYRadius, params.fInnerXRadius,
                        params.fInnerYRadius, geoDx, geoDy, params.fStyle,
                        SkRect::MakeLTRB(params.fCenter.fX - params.fXRadius,
                                         params.fCenter.fY - params.fYRadius,
                                         params.fCenter.fX + params.fXRadius,
                                         params.fCenter.fY + params.fYRadius)});
        this->setTransformedBounds(fEllipses[0].fBounds, viewMatrix, HasAABloat::kYes,
                                   IsHairline::kNo);
    }

Member Function Documentation

◆ finalize()

GrProcessorSet::Analysis DIEllipseOp::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 2235 of file GrOvalOpFactory.cpp.

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

◆ fixedFunctionFlags()

FixedFunctionFlags DIEllipseOp::fixedFunctionFlags ( ) const

inlineoverridevirtual

Reimplemented from GrDrawOp.

Definition at line 2245 of file GrOvalOpFactory.cpp.

2245{ return fHelper.fixedFunctionFlags(); }

GrSimpleMeshDrawOpHelper::fixedFunctionFlags

GrDrawOp::FixedFunctionFlags fixedFunctionFlags() const

Definition GrSimpleMeshDrawOpHelper.cpp:35

◆ Make()

static DEFINE_OP_CLASS_ID GrOp::Owner DIEllipseOp::Make	(	GrRecordingContext *	context,
		GrPaint &&	paint,
		const SkMatrix &	viewMatrix,
		const SkRect &	ellipse,
		const SkStrokeRec &	stroke
	)

inlinestatic

Definition at line 2129 of file GrOvalOpFactory.cpp.

                                                       {
        DeviceSpaceParams params;
        params.fCenter = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
        params.fXRadius = SkScalarHalf(ellipse.width());
        params.fYRadius = SkScalarHalf(ellipse.height());
 
        SkStrokeRec::Style style = stroke.getStyle();
        params.fStyle = (SkStrokeRec::kStroke_Style == style)
                                ? DIEllipseStyle::kStroke
                                : (SkStrokeRec::kHairline_Style == style)
                                          ? DIEllipseStyle::kHairline
                                          : DIEllipseStyle::kFill;
 
        params.fInnerXRadius = 0;
        params.fInnerYRadius = 0;
        if (SkStrokeRec::kFill_Style != style && SkStrokeRec::kHairline_Style != style) {
            SkScalar strokeWidth = stroke.getWidth();
 
            if (SkScalarNearlyZero(strokeWidth)) {
                strokeWidth = SK_ScalarHalf;
            } else {
                strokeWidth *= SK_ScalarHalf;
            }
 
            // we only handle thick strokes for near-circular ellipses
            if (strokeWidth > SK_ScalarHalf &&
                (SK_ScalarHalf * params.fXRadius > params.fYRadius ||
                 SK_ScalarHalf * params.fYRadius > params.fXRadius)) {
                return nullptr;
            }
 
            // we don't handle it if curvature of the stroke is less than curvature of the ellipse
            if (strokeWidth * (params.fYRadius * params.fYRadius) <
                (strokeWidth * strokeWidth) * params.fXRadius) {
                return nullptr;
            }
            if (strokeWidth * (params.fXRadius * params.fXRadius) <
                (strokeWidth * strokeWidth) * params.fYRadius) {
                return nullptr;
            }
 
            // set inner radius (if needed)
            if (SkStrokeRec::kStroke_Style == style) {
                params.fInnerXRadius = params.fXRadius - strokeWidth;
                params.fInnerYRadius = params.fYRadius - strokeWidth;
            }
 
            params.fXRadius += strokeWidth;
            params.fYRadius += strokeWidth;
        }
 
        // For large ovals with low precision floats, we fall back to the path renderer.
        // To compute the AA at the edge we divide by the gradient, which is clamped to a
        // minimum value to avoid divides by zero. With large ovals and low precision this
        // leads to blurring at the edge of the oval.
        const SkScalar kMaxOvalRadius = 16384;
        if (!context->priv().caps()->shaderCaps()->fFloatIs32Bits &&
            (params.fXRadius >= kMaxOvalRadius || params.fYRadius >= kMaxOvalRadius)) {
            return nullptr;
        }
 
        if (DIEllipseStyle::kStroke == params.fStyle &&
            (params.fInnerXRadius <= 0 || params.fInnerYRadius <= 0)) {
            params.fStyle = DIEllipseStyle::kFill;
        }
        return Helper::FactoryHelper<DIEllipseOp>(context, std::move(paint), params, viewMatrix);
    }

◆ name()

const char * DIEllipseOp::name ( ) const

inlineoverridevirtual

Implements GrOp.

Definition at line 2225 of file GrOvalOpFactory.cpp.

2225{ return "DIEllipseOp"; }

◆ onCombineIfPossible()

CombineResult DIEllipseOp::onCombineIfPossible	(	GrOp *	t,
		SkArenaAlloc *	,
		const GrCaps &	caps
	)

inlineoverrideprivatevirtual

Reimplemented from GrOp.

Definition at line 2325 of file GrOvalOpFactory.cpp.

                                                                                           {
        DIEllipseOp* that = t->cast<DIEllipseOp>();
        if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
            return CombineResult::kCannotCombine;
        }
 
        if (this->style() != that->style()) {
            return CombineResult::kCannotCombine;
        }
 
        // TODO rewrite to allow positioning on CPU
        if (!SkMatrixPriv::CheapEqual(this->viewMatrix(), that->viewMatrix())) {
            return CombineResult::kCannotCombine;
        }
 
        fEllipses.push_back_n(that->fEllipses.size(), that->fEllipses.begin());
        fWideColor |= that->fWideColor;
        return CombineResult::kMerged;
    }

◆ onCreateProgramInfo()

void DIEllipseOp::onCreateProgramInfo	(	const GrCaps *	caps,
		SkArenaAlloc *	arena,
		const GrSurfaceProxyView &	writeView,
		bool	usesMSAASurface,
		GrAppliedClip &&	appliedClip,
		const GrDstProxyView &	dstProxyView,
		GrXferBarrierFlags	renderPassXferBarriers,
		GrLoadOp	colorLoadOp
	)

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 2250 of file GrOvalOpFactory.cpp.

                                                            {
        GrGeometryProcessor* gp = DIEllipseGeometryProcessor::Make(arena, fWideColor, fUseScale,
                                                                   this->viewMatrix(),
                                                                   this->style());
 
        fProgramInfo = fHelper.createProgramInfo(caps, arena, writeView, usesMSAASurface,
                                                 std::move(appliedClip), dstProxyView, gp,
                                                 GrPrimitiveType::kTriangles,
                                                 renderPassXferBarriers, colorLoadOp);
    }

◆ onExecute()

void DIEllipseOp::onExecute	(	GrOpFlushState *	flushState,
		const SkRect &	chainBounds
	)

inlineoverrideprivatevirtual

Implements GrOp.

Definition at line 2315 of file GrOvalOpFactory.cpp.

                                                                                   {
        if (!fProgramInfo || !fMesh) {
            return;
        }
 
        flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);
        flushState->bindTextures(fProgramInfo->geomProc(), nullptr, fProgramInfo->pipeline());
        flushState->drawMesh(*fMesh);
    }

◆ onPrepareDraws()

void DIEllipseOp::onPrepareDraws ( GrMeshDrawTarget * target )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 2268 of file GrOvalOpFactory.cpp.

                                                           {
        if (!fProgramInfo) {
            this->createProgramInfo(target);
        }
 
        QuadHelper helper(target, fProgramInfo->geomProc().vertexStride(), fEllipses.size());
        VertexWriter verts{helper.vertices()};
        if (!verts) {
            return;
        }
 
        for (const auto& ellipse : fEllipses) {
            VertexColor color(ellipse.fColor, fWideColor);
            SkScalar xRadius = ellipse.fXRadius;
            SkScalar yRadius = ellipse.fYRadius;
 
            // On MSAA, bloat enough to guarantee any pixel that might be touched by the ellipse has
            // full sample coverage.
            float aaBloat = target->usesMSAASurface() ? SK_ScalarSqrt2 : .5f;
            SkRect drawBounds = ellipse.fBounds.makeOutset(ellipse.fGeoDx * aaBloat,
                                                           ellipse.fGeoDy * aaBloat);
 
            // Normalize the "outer radius" coordinates within drawBounds so that the outer edge
            // occurs at x^2 + y^2 == 1.
            float outerCoordX = drawBounds.width() / (xRadius * 2);
            float outerCoordY = drawBounds.height() / (yRadius * 2);
 
            // By default, constructed so that inner coord is (0, 0) for all points
            float innerCoordX = 0;
            float innerCoordY = 0;
 
            // ... unless we're stroked. Then normalize the "inner radius" coordinates within
            // drawBounds so that the inner edge occurs at x2^2 + y2^2 == 1.
            if (DIEllipseStyle::kStroke == this->style()) {
                innerCoordX = drawBounds.width() / (ellipse.fInnerXRadius * 2);
                innerCoordY = drawBounds.height() / (ellipse.fInnerYRadius * 2);
            }
 
            verts.writeQuad(VertexWriter::TriStripFromRect(drawBounds),
                            color,
                            origin_centered_tri_strip(outerCoordX, outerCoordY),
                            VertexWriter::If(fUseScale, std::max(xRadius, yRadius)),
                            origin_centered_tri_strip(innerCoordX, innerCoordY));
        }
        fMesh = helper.mesh();
    }

◆ programInfo()

GrProgramInfo * DIEllipseOp::programInfo ( )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 2248 of file GrOvalOpFactory.cpp.

2248{ return fProgramInfo; }

◆ visitProxies()

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

inlineoverridevirtual

Reimplemented from GrOp.

Definition at line 2227 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

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DIEllipseOp()

Member Function Documentation

◆ finalize()

◆ fixedFunctionFlags()

◆ Make()

◆ name()

◆ onCombineIfPossible()

◆ onCreateProgramInfo()

◆ onExecute()

◆ onPrepareDraws()

◆ programInfo()

◆ visitProxies()