#include <PathRenderer.h>

Inheritance diagram for skgpu::ganesh::PathRenderer:

Classes
struct	CanDrawPathArgs

struct	DrawPathArgs

struct	StencilPathArgs

Public Types
enum	StencilSupport { kNoSupport_StencilSupport , kStencilOnly_StencilSupport , kNoRestriction_StencilSupport }

enum class	CanDrawPath { kNo , kAsBackup , kYes }

Public Member Functions
	PathRenderer ()=default

virtual const char *	name () const =0

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

Static Protected Member Functions
static void	GetPathDevBounds (const SkPath &path, SkISize devSize, const SkMatrix &matrix, SkRect *bounds)

Private Member Functions
virtual StencilSupport	onGetStencilSupport (const GrStyledShape &) const

virtual bool	onDrawPath (const DrawPathArgs &args)=0

virtual CanDrawPath	onCanDrawPath (const CanDrawPathArgs &args) const =0

virtual void	onStencilPath (const StencilPathArgs &)

Detailed Description

Base class for drawing paths into a OpsTask.

Definition at line 36 of file PathRenderer.h.

Member Enumeration Documentation

◆ CanDrawPath

enum class skgpu::ganesh::PathRenderer::CanDrawPath

strong

Enumerator
kNo
kAsBackup
kYes

Definition at line 75 of file PathRenderer.h.

                           {
        kNo,
        kAsBackup, // i.e. This renderer is better than SW fallback if no others can draw the path.
        kYes
    };

◆ StencilSupport

enum skgpu::ganesh::PathRenderer::StencilSupport

A caller may wish to use a path renderer to draw a path into the stencil buffer. However, the path renderer itself may require use of the stencil buffer. Also a path renderer may use a GrProcessor coverage stage that sets coverage to zero to eliminate pixels that are covered by bounding geometry but outside the path. These exterior pixels would still be rendered into the stencil.

A PathRenderer can provide three levels of support for stenciling paths: 1) kNoRestriction: This is the most general. The caller passes a GrPaint and calls drawPath(). The path is rendered exactly as the draw state indicates including support for simultaneous color and stenciling with arbitrary stenciling rules. Pixels partially covered by AA paths are affected by the stencil settings. 2) kStencilOnly: The path renderer cannot apply arbitrary stencil rules nor shade and stencil simultaneously. The path renderer does support the stencilPath() function which performs no color writes and writes a non-zero stencil value to pixels covered by the path. 3) kNoSupport: This path renderer cannot be used to stencil the path.

Enumerator
kNoSupport_StencilSupport
kStencilOnly_StencilSupport
kNoRestriction_StencilSupport

Definition at line 60 of file PathRenderer.h.

                        {
        kNoSupport_StencilSupport,
        kStencilOnly_StencilSupport,
        kNoRestriction_StencilSupport,
    };

Constructor & Destructor Documentation

◆ PathRenderer()

skgpu::ganesh::PathRenderer::PathRenderer ( )

default

Member Function Documentation

◆ canDrawPath()

CanDrawPath skgpu::ganesh::PathRenderer::canDrawPath ( const CanDrawPathArgs & args ) const

inline

Returns how well this path renderer is able to render the given path. Returning kNo or kAsBackup allows the caller to keep searching for a better path renderer. This function is called when searching for the best path renderer to draw a path.

Definition at line 113 of file PathRenderer.h.

                                                               {
        SkDEBUGCODE(args.validate();)
        return this->onCanDrawPath(args);
    }

◆ drawPath()

bool skgpu::ganesh::PathRenderer::drawPath ( const DrawPathArgs & args )

Draws the path into the draw target. If getStencilSupport() would return kNoRestriction then the subclass must respect the stencil settings.

Definition at line 47 of file PathRenderer.cpp.

                                                    {
#ifdef SK_DEBUG
    args.validate();
    CanDrawPathArgs canArgs;
    canArgs.fCaps = args.fContext->priv().caps();
    canArgs.fProxy = args.fSurfaceDrawContext->asRenderTargetProxy();
    canArgs.fClipConservativeBounds = args.fClipConservativeBounds;
    canArgs.fViewMatrix = args.fViewMatrix;
    canArgs.fShape = args.fShape;
    canArgs.fPaint = &args.fPaint;
    canArgs.fSurfaceProps = &args.fSurfaceDrawContext->surfaceProps();
    canArgs.fAAType = args.fAAType;
    canArgs.validate();
 
    canArgs.fHasUserStencilSettings = !args.fUserStencilSettings->isUnused();
    SkASSERT(CanDrawPath::kNo != this->canDrawPath(canArgs));
    if (!args.fUserStencilSettings->isUnused()) {
        SkPath path;
        args.fShape->asPath(&path);
        SkASSERT(args.fShape->style().isSimpleFill());
        SkASSERT(kNoRestriction_StencilSupport == this->getStencilSupport(*args.fShape));
    }
#endif
    return this->onDrawPath(args);
}

◆ GetPathDevBounds()

void skgpu::ganesh::PathRenderer::GetPathDevBounds	(	const SkPath &	path,
		SkISize	devSize,
		const SkMatrix &	matrix,
		SkRect *	bounds
	)

staticprotected

Definition at line 73 of file PathRenderer.cpp.

                                                    {
    if (path.isInverseFillType()) {
        *bounds = SkRect::Make(devSize);
        return;
    }
    *bounds = path.getBounds();
    matrix.mapRect(bounds);
}

◆ getStencilSupport()

PathRenderer::StencilSupport skgpu::ganesh::PathRenderer::getStencilSupport ( const GrStyledShape & shape ) const

This function is to get the stencil support for a particular path. The path's fill must not be an inverse type. The path will always be filled and not stroked.

Parameters

shape the shape that will be drawn. Must be simple fill styled and non-inverse filled.

Definition at line 39 of file PathRenderer.cpp.

                                                                                           {
    SkDEBUGCODE(SkPath path;)
    SkDEBUGCODE(shape.asPath(&path);)
    SkASSERT(shape.style().isSimpleFill());
    SkASSERT(!path.isInverseFillType());
    return this->onGetStencilSupport(shape);
}

◆ name()

virtual const char * skgpu::ganesh::PathRenderer::name ( ) const

pure virtual

Implemented in skgpu::ganesh::AAConvexPathRenderer, skgpu::ganesh::AAHairLinePathRenderer, skgpu::ganesh::AALinearizingConvexPathRenderer, skgpu::ganesh::AtlasPathRenderer, skgpu::ganesh::DashLinePathRenderer, skgpu::ganesh::DefaultPathRenderer, skgpu::ganesh::SmallPathRenderer, skgpu::ganesh::SoftwarePathRenderer, skgpu::ganesh::TessellationPathRenderer, and skgpu::ganesh::TriangulatingPathRenderer.

◆ onCanDrawPath()

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

privatepure virtual

Subclass implementation of canDrawPath()

◆ onDrawPath()

virtual bool skgpu::ganesh::PathRenderer::onDrawPath ( const DrawPathArgs & args )

privatepure virtual

Subclass implementation of drawPath()

◆ onGetStencilSupport()

virtual StencilSupport skgpu::ganesh::PathRenderer::onGetStencilSupport ( const GrStyledShape & ) const

inlineprivatevirtual

Subclass overrides if it has any limitations of stenciling support.

Definition at line 185 of file PathRenderer.h.

                                                                           {
        return kNoRestriction_StencilSupport;
    }

◆ onStencilPath()

void skgpu::ganesh::PathRenderer::onStencilPath ( const StencilPathArgs & args )

privatevirtual

Subclass implementation of stencilPath(). Subclass must override iff it ever returns kStencilOnly in onGetStencilSupport().

Definition at line 85 of file PathRenderer.cpp.

                                                            {
    static constexpr GrUserStencilSettings kIncrementStencil(
            GrUserStencilSettings::StaticInit<
                    0xffff,
                    GrUserStencilTest::kAlways,
                    0xffff,
                    GrUserStencilOp::kReplace,
                    GrUserStencilOp::kReplace,
                    0xffff>()
    );
 
    GrPaint paint;
    DrawPathArgs drawArgs{args.fContext,
                          std::move(paint),
                          &kIncrementStencil,
                          args.fSurfaceDrawContext,
                          nullptr,  // clip
                          args.fClipConservativeBounds,
                          args.fViewMatrix,
                          args.fShape,
                          (GrAA::kYes == args.fDoStencilMSAA) ? GrAAType::kMSAA : GrAAType::kNone,
                          false};
    this->drawPath(drawArgs);
}

◆ stencilPath()

void skgpu::ganesh::PathRenderer::stencilPath ( const StencilPathArgs & args )

inline

Draws the path to the stencil buffer. Assume the writable stencil bits are already initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.

Definition at line 167 of file PathRenderer.h.

                                                  {
        SkDEBUGCODE(args.validate();)
        SkASSERT(kNoSupport_StencilSupport != this->getStencilSupport(*args.fShape));
        this->onStencilPath(args);
    }

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

third_party/skia/src/gpu/ganesh/PathRenderer.h
third_party/skia/src/gpu/ganesh/PathRenderer.cpp

Classes

Public Types

Public Member Functions

Static Protected Member Functions

Private Member Functions