ButtCapDashedCircleOp Class Reference

Inheritance diagram for ButtCapDashedCircleOp:

Public Member Functions
	ButtCapDashedCircleOp (GrProcessorSet *processorSet, const SkPMColor4f &color, const SkMatrix &viewMatrix, SkPoint center, SkScalar radius, SkScalar strokeWidth, SkScalar startAngle, SkScalar onAngle, SkScalar offAngle, SkScalar phaseAngle)
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, SkPoint center, SkScalar radius, SkScalar strokeWidth, SkScalar startAngle, SkScalar onAngle, SkScalar offAngle, SkScalar phaseAngle)
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 1500 of file GrOvalOpFactory.cpp.

Constructor & Destructor Documentation

ButtCapDashedCircleOp()

ButtCapDashedCircleOp::ButtCapDashedCircleOp ( GrProcessorSet *  processorSet, const SkPMColor4f &  color, const SkMatrix &  viewMatrix, SkPoint  center, SkScalar  radius, SkScalar  strokeWidth, SkScalar  startAngle, SkScalar  onAngle, SkScalar  offAngle, SkScalar  phaseAngle  )

inline

Definition at line 1524 of file GrOvalOpFactory.cpp.

            : GrMeshDrawOp(ClassID())
            , fHelper(processorSet, GrAAType::kCoverage) {
        SkASSERT(circle_stays_circle(viewMatrix));
        viewMatrix.mapPoints(&center, 1);
        radius = viewMatrix.mapRadius(radius);
        strokeWidth = viewMatrix.mapRadius(strokeWidth);
 
        // Determine the angle where the circle starts in device space and whether its orientation
        // has been reversed.
        SkVector start;
        bool reflection;
        if (!startAngle) {
            start = {1, 0};
        } else {
            start.fY = SkScalarSin(startAngle);
            start.fX = SkScalarCos(startAngle);
        }
        viewMatrix.mapVectors(&start, 1);
        startAngle = SkScalarATan2(start.fY, start.fX);
        reflection = (viewMatrix.getScaleX() * viewMatrix.getScaleY() -
                      viewMatrix.getSkewX() * viewMatrix.getSkewY()) < 0;
 
        auto totalAngle = onAngle + offAngle;
        phaseAngle = SkScalarMod(phaseAngle + totalAngle / 2, totalAngle) - totalAngle / 2;
 
        SkScalar halfWidth = 0;
        if (SkScalarNearlyZero(strokeWidth)) {
            halfWidth = SK_ScalarHalf;
        } else {
            halfWidth = SkScalarHalf(strokeWidth);
        }
 
        SkScalar outerRadius = radius + halfWidth;
        SkScalar innerRadius = radius - halfWidth;
 
        // The radii are outset for two reasons. First, it allows the shader to simply perform
        // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
        // Second, the outer radius is used to compute the verts of the bounding box that is
        // rendered and the outset ensures the box will cover all partially covered by the circle.
        outerRadius += SK_ScalarHalf;
        innerRadius -= SK_ScalarHalf;
        fViewMatrixIfUsingLocalCoords = viewMatrix;
 
        SkRect devBounds = SkRect::MakeLTRB(center.fX - outerRadius, center.fY - outerRadius,
                                            center.fX + outerRadius, center.fY + outerRadius);
 
        // We store whether there is a reflection as a negative total angle.
        if (reflection) {
            totalAngle = -totalAngle;
        }
        fCircles.push_back(Circle{
            color,
            outerRadius,
            innerRadius,
            onAngle,
            totalAngle,
            startAngle,
            phaseAngle,
            devBounds
        });
        // Use the original radius and stroke radius for the bounds so that it does not include the
        // AA bloat.
        radius += halfWidth;
        this->setBounds(
                {center.fX - radius, center.fY - radius, center.fX + radius, center.fY + radius},
                HasAABloat::kYes, IsHairline::kNo);
        fVertCount = circle_type_to_vert_count(true);
        fIndexCount = circle_type_to_index_count(true);
    }

Member Function Documentation

finalize()

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

                                                                      {
        SkPMColor4f* color = &fCircles.front().fColor;
        return fHelper.finalizeProcessors(caps, clip, clampType,
                                          GrProcessorAnalysisCoverage::kSingleChannel, color,
                                          &fWideColor);
    }

fixedFunctionFlags()

FixedFunctionFlags ButtCapDashedCircleOp::fixedFunctionFlags ( ) const

inlineoverridevirtual

Reimplemented from GrDrawOp.

Definition at line 1616 of file GrOvalOpFactory.cpp.

{ return fHelper.fixedFunctionFlags(); }

Make()

static DEFINE_OP_CLASS_ID GrOp::Owner ButtCapDashedCircleOp::Make ( GrRecordingContext *  context, GrPaint &&  paint, const SkMatrix &  viewMatrix, SkPoint  center, SkScalar  radius, SkScalar  strokeWidth, SkScalar  startAngle, SkScalar  onAngle, SkScalar  offAngle, SkScalar  phaseAngle  )

inlinestatic

Definition at line 1507 of file GrOvalOpFactory.cpp.

                                                 {
        SkASSERT(circle_stays_circle(viewMatrix));
        SkASSERT(strokeWidth < 2 * radius);
        return Helper::FactoryHelper<ButtCapDashedCircleOp>(context, std::move(paint), viewMatrix,
                                                            center, radius, strokeWidth, startAngle,
                                                            onAngle, offAngle, phaseAngle);
    }

name()

const char * ButtCapDashedCircleOp::name ( ) const

inlineoverridevirtual

Implements GrOp.

Definition at line 1598 of file GrOvalOpFactory.cpp.

{ return "ButtCappedDashedCircleOp"; }

onCombineIfPossible()

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

inlineoverrideprivatevirtual

Reimplemented from GrOp.

Definition at line 1751 of file GrOvalOpFactory.cpp.

                                                                                           {
        ButtCapDashedCircleOp* that = t->cast<ButtCapDashedCircleOp>();
 
        // can only represent 65535 unique vertices with 16-bit indices
        if (fVertCount + that->fVertCount > 65536) {
            return CombineResult::kCannotCombine;
        }
 
        if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
            return CombineResult::kCannotCombine;
        }
 
        if (fHelper.usesLocalCoords() &&
            !SkMatrixPriv::CheapEqual(fViewMatrixIfUsingLocalCoords,
                                      that->fViewMatrixIfUsingLocalCoords)) {
            return CombineResult::kCannotCombine;
        }
 
        fCircles.push_back_n(that->fCircles.size(), that->fCircles.begin());
        fVertCount += that->fVertCount;
        fIndexCount += that->fIndexCount;
        fWideColor |= that->fWideColor;
        return CombineResult::kMerged;
    }

onCreateProgramInfo()

void ButtCapDashedCircleOp::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 1621 of file GrOvalOpFactory.cpp.

                                                            {
        SkASSERT(!usesMSAASurface);
 
        SkMatrix localMatrix;
        if (!fViewMatrixIfUsingLocalCoords.invert(&localMatrix)) {
            return;
        }
 
        // Setup geometry processor
        GrGeometryProcessor* gp = ButtCapDashedCircleGeometryProcessor::Make(arena,
                                                                             fWideColor,
                                                                             localMatrix);
 
        fProgramInfo = fHelper.createProgramInfo(caps,
                                                 arena,
                                                 writeView,
                                                 usesMSAASurface,
                                                 std::move(appliedClip),
                                                 dstProxyView,
                                                 gp,
                                                 GrPrimitiveType::kTriangles,
                                                 renderPassXferBarriers,
                                                 colorLoadOp);
    }

onExecute()

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

inlineoverrideprivatevirtual

Implements GrOp.

Definition at line 1741 of file GrOvalOpFactory.cpp.

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

onPrepareDraws()

void ButtCapDashedCircleOp::onPrepareDraws ( GrMeshDrawTarget *  target )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 1653 of file GrOvalOpFactory.cpp.

                                                           {
        if (!fProgramInfo) {
            this->createProgramInfo(target);
            if (!fProgramInfo) {
                return;
            }
        }
 
        sk_sp<const GrBuffer> vertexBuffer;
        int firstVertex;
        VertexWriter vertices = target->makeVertexWriter(fProgramInfo->geomProc().vertexStride(),
                                                         fVertCount, &vertexBuffer, &firstVertex);
        if (!vertices) {
            SkDebugf("Could not allocate vertices\n");
            return;
        }
 
        sk_sp<const GrBuffer> indexBuffer;
        int firstIndex = 0;
        uint16_t* indices = target->makeIndexSpace(fIndexCount, &indexBuffer, &firstIndex);
        if (!indices) {
            SkDebugf("Could not allocate indices\n");
            return;
        }
 
        int currStartVertex = 0;
        for (const auto& circle : fCircles) {
            // The inner radius in the vertex data must be specified in normalized space so that
            // length() can be called with smaller values to avoid precision issues with half
            // floats.
            auto normInnerRadius = circle.fInnerRadius / circle.fOuterRadius;
            const SkRect& bounds = circle.fDevBounds;
            bool reflect = false;
            struct { float onAngle, totalAngle, startAngle, phaseAngle; } dashParams = {
                circle.fOnAngle, circle.fTotalAngle, circle.fStartAngle, circle.fPhaseAngle
            };
            if (dashParams.totalAngle < 0) {
                reflect = true;
                dashParams.totalAngle = -dashParams.totalAngle;
                dashParams.startAngle = -dashParams.startAngle;
            }
 
            VertexColor color(circle.fColor, fWideColor);
 
            // The bounding geometry for the circle is composed of an outer bounding octagon and
            // an inner bounded octagon.
 
            // Compute the vertices of the outer octagon.
            SkPoint center = SkPoint::Make(bounds.centerX(), bounds.centerY());
            SkScalar halfWidth = 0.5f * bounds.width();
 
            auto reflectY = [=](const SkPoint& p) {
                return SkPoint{ p.fX, reflect ? -p.fY : p.fY };
            };
 
            for (int i = 0; i < 8; ++i) {
                vertices << (center + kOctagonOuter[i] * halfWidth)
                         << color
                         << reflectY(kOctagonOuter[i])
                         << circle.fOuterRadius
                         << normInnerRadius
                         << dashParams;
            }
 
            // Compute the vertices of the inner octagon.
            for (int i = 0; i < 8; ++i) {
                vertices << (center + kOctagonInner[i] * circle.fInnerRadius)
                         << color
                         << (reflectY(kOctagonInner[i]) * normInnerRadius)
                         << circle.fOuterRadius
                         << normInnerRadius
                         << dashParams;
            }
 
            const uint16_t* primIndices = circle_type_to_indices(true);
            const int primIndexCount = circle_type_to_index_count(true);
            for (int i = 0; i < primIndexCount; ++i) {
                *indices++ = primIndices[i] + currStartVertex;
            }
 
            currStartVertex += circle_type_to_vert_count(true);
        }
 
        fMesh = target->allocMesh();
        fMesh->setIndexed(std::move(indexBuffer), fIndexCount, firstIndex, 0, fVertCount - 1,
                          GrPrimitiveRestart::kNo, std::move(vertexBuffer), firstVertex);
    }

programInfo()

GrProgramInfo * ButtCapDashedCircleOp::programInfo ( )

inlineoverrideprivatevirtual

Implements GrMeshDrawOp.

Definition at line 1619 of file GrOvalOpFactory.cpp.

{ return fProgramInfo; }

visitProxies()

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

inlineoverridevirtual

Reimplemented from GrOp.

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