skgpu::ganesh::SmallPathRenderer Class Reference

#include <SmallPathRenderer.h>

Inheritance diagram for skgpu::ganesh::SmallPathRenderer:

Public Member Functions
	SmallPathRenderer ()=default
const char *	name () const override
Public Member Functions inherited from skgpu::ganesh::PathRenderer
	PathRenderer ()=default
StencilSupport	getStencilSupport (const GrStyledShape &shape) const
CanDrawPath	canDrawPath (const CanDrawPathArgs &args) const
bool	drawPath (const DrawPathArgs &args)
void	stencilPath (const StencilPathArgs &args)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Private Member Functions
StencilSupport	onGetStencilSupport (const GrStyledShape &) const override
CanDrawPath	onCanDrawPath (const CanDrawPathArgs &) const override
bool	onDrawPath (const DrawPathArgs &) override

Additional Inherited Members
Public Types inherited from skgpu::ganesh::PathRenderer
enum	StencilSupport { kNoSupport_StencilSupport , kStencilOnly_StencilSupport , kNoRestriction_StencilSupport }
enum class	CanDrawPath { kNo , kAsBackup , kYes }
Static Protected Member Functions inherited from skgpu::ganesh::PathRenderer
static void	GetPathDevBounds (const SkPath &path, SkISize devSize, const SkMatrix &matrix, SkRect *bounds)

Detailed Description

Definition at line 19 of file SmallPathRenderer.h.

Constructor & Destructor Documentation

SmallPathRenderer()

skgpu::ganesh::SmallPathRenderer::SmallPathRenderer ( )

default

Member Function Documentation

name()

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

inlineoverridevirtual

Implements skgpu::ganesh::PathRenderer.

Definition at line 23 of file SmallPathRenderer.h.

{ return "Small"; }

onCanDrawPath()

PathRenderer::CanDrawPath skgpu::ganesh::SmallPathRenderer::onCanDrawPath ( const CanDrawPathArgs &  args ) const

overrideprivatevirtual

Subclass implementation of canDrawPath()

Implements skgpu::ganesh::PathRenderer.

Definition at line 668 of file SmallPathRenderer.cpp.

                                                                                          {
    if (!args.fCaps->shaderCaps()->fShaderDerivativeSupport) {
        return CanDrawPath::kNo;
    }
    // If the shape has no key then we won't get any reuse.
    if (!args.fShape->hasUnstyledKey()) {
        return CanDrawPath::kNo;
    }
    // This only supports filled paths, however, the caller may apply the style to make a filled
    // path and try again.
    if (!args.fShape->style().isSimpleFill()) {
        return CanDrawPath::kNo;
    }
    // This does non-inverse coverage-based antialiased fills.
    if (GrAAType::kCoverage != args.fAAType) {
        return CanDrawPath::kNo;
    }
    // TODO: Support inverse fill
    if (args.fShape->inverseFilled()) {
        return CanDrawPath::kNo;
    }
 
    SkScalar scaleFactors[2] = { 1, 1 };
    // TODO: handle perspective distortion
    if (!args.fViewMatrix->hasPerspective() && !args.fViewMatrix->getMinMaxScales(scaleFactors)) {
        return CanDrawPath::kNo;
    }
    // For affine transformations, too much shear can produce artifacts.
    if (!scaleFactors[0] || scaleFactors[1]/scaleFactors[0] > 4) {
        return CanDrawPath::kNo;
    }
    // Only support paths with bounds within kMaxDim by kMaxDim,
    // scaled to have bounds within kMaxSize by kMaxSize.
    // The goal is to accelerate rendering of lots of small paths that may be scaling.
    SkRect bounds = args.fShape->styledBounds();
    SkScalar minDim = std::min(bounds.width(), bounds.height());
    SkScalar maxDim = std::max(bounds.width(), bounds.height());
    SkScalar minSize = minDim * SkScalarAbs(scaleFactors[0]);
    SkScalar maxSize = maxDim * SkScalarAbs(scaleFactors[1]);
    if (maxDim > kMaxDim || kMinSize > minSize || maxSize > kMaxSize) {
        return CanDrawPath::kNo;
    }
 
    return CanDrawPath::kYes;
}

onDrawPath()

bool skgpu::ganesh::SmallPathRenderer::onDrawPath ( const DrawPathArgs &  args )

overrideprivatevirtual

Subclass implementation of drawPath()

Implements skgpu::ganesh::PathRenderer.

Definition at line 714 of file SmallPathRenderer.cpp.

                                                           {
    GR_AUDIT_TRAIL_AUTO_FRAME(args.fContext->priv().auditTrail(),
                              "SmallPathRenderer::onDrawPath");
 
    // we've already bailed on inverse filled paths, so this is safe
    SkASSERT(!args.fShape->isEmpty());
    SkASSERT(args.fShape->hasUnstyledKey());
 
    GrOp::Owner op = SmallPathOp::Make(
            args.fContext, std::move(args.fPaint), *args.fShape, *args.fViewMatrix,
            args.fGammaCorrect, args.fUserStencilSettings);
    args.fSurfaceDrawContext->addDrawOp(args.fClip, std::move(op));
 
    return true;
}

onGetStencilSupport()

StencilSupport skgpu::ganesh::SmallPathRenderer::onGetStencilSupport ( const GrStyledShape &  ) const

inlineoverrideprivatevirtual

Subclass overrides if it has any limitations of stenciling support.

Reimplemented from skgpu::ganesh::PathRenderer.

Definition at line 26 of file SmallPathRenderer.h.

                                                                            {
        return PathRenderer::kNoSupport_StencilSupport;
    }

---

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

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