skgpu::ganesh::PathRendererChain Class Reference

#include <PathRendererChain.h>

Inheritance diagram for skgpu::ganesh::PathRendererChain:

Classes
struct	Options

Public Types
enum class	DrawType { kColor , kStencil , kStencilAndColor }

Public Member Functions
	PathRendererChain (GrRecordingContext *, const Options &)
PathRenderer *	getPathRenderer (const PathRenderer::CanDrawPathArgs &, DrawType, PathRenderer::StencilSupport *)
skgpu::ganesh::AtlasPathRenderer *	getAtlasPathRenderer ()
PathRenderer *	getTessellationPathRenderer ()
Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default
	SkNoncopyable (SkNoncopyable &&)=default
SkNoncopyable &	operator= (SkNoncopyable &&)=default

Detailed Description

Keeps track of an ordered list of path renderers. When a path needs to be drawn this list is scanned to find the most preferred renderer. To add your path renderer to the list implement the GrPathRenderer::AddPathRenderers function.

Definition at line 28 of file PathRendererChain.h.

Member Enumeration Documentation

DrawType

enum class skgpu::ganesh::PathRendererChain::DrawType

strong

Documents how the caller plans to use a GrPathRenderer to draw a path. It affects the PR returned by getPathRenderer

Enumerator
kColor
kStencil
kStencilAndColor

Definition at line 38 of file PathRendererChain.h.

                        {
        kColor,            // draw to the color buffer, no AA
        kStencil,          // draw just to the stencil buffer
        kStencilAndColor,  // draw the stencil and color buffer, no AA
    };

Constructor & Destructor Documentation

PathRendererChain()

skgpu::ganesh::PathRendererChain::PathRendererChain	(	GrRecordingContext *	context,
		const Options &	options
	)

Definition at line 31 of file PathRendererChain.cpp.

                                                                                        {
    const GrCaps& caps = *context->priv().caps();
    if (options.fGpuPathRenderers & GpuPathRenderers::kDashLine) {
        fChain.push_back(sk_make_sp<ganesh::DashLinePathRenderer>());
    }
    if (options.fGpuPathRenderers & GpuPathRenderers::kAAConvex) {
        fChain.push_back(sk_make_sp<AAConvexPathRenderer>());
    }
    if (options.fGpuPathRenderers & GpuPathRenderers::kAAHairline) {
        fChain.push_back(sk_make_sp<AAHairLinePathRenderer>());
    }
    if (options.fGpuPathRenderers & GpuPathRenderers::kAALinearizing) {
        fChain.push_back(sk_make_sp<AALinearizingConvexPathRenderer>());
    }
    if (options.fGpuPathRenderers & GpuPathRenderers::kAtlas) {
        if (auto atlasPathRenderer = AtlasPathRenderer::Make(context)) {
            fAtlasPathRenderer = atlasPathRenderer.get();
            context->priv().addOnFlushCallbackObject(atlasPathRenderer.get());
            fChain.push_back(std::move(atlasPathRenderer));
        }
    }
#if !defined(SK_ENABLE_OPTIMIZE_SIZE)
    if (options.fGpuPathRenderers & GpuPathRenderers::kSmall) {
        fChain.push_back(sk_make_sp<SmallPathRenderer>());
    }
    if (options.fGpuPathRenderers & GpuPathRenderers::kTriangulating) {
        fChain.push_back(sk_make_sp<TriangulatingPathRenderer>());
    }
#endif
    if (options.fGpuPathRenderers & GpuPathRenderers::kTessellation) {
        if (TessellationPathRenderer::IsSupported(caps)) {
            auto tess = sk_make_sp<TessellationPathRenderer>();
            fTessellationPathRenderer = tess.get();
            fChain.push_back(std::move(tess));
        }
    }
 
    // We always include the default path renderer (as well as SW), so we can draw any path
    fChain.push_back(sk_make_sp<DefaultPathRenderer>());
}

Member Function Documentation

getAtlasPathRenderer()

skgpu::ganesh::AtlasPathRenderer * skgpu::ganesh::PathRendererChain::getAtlasPathRenderer ( )

inline

Returns a direct pointer to the atlas path renderer, or null if it is not in the chain.

Definition at line 54 of file PathRendererChain.h.

{ return fAtlasPathRenderer; }

getPathRenderer()

PathRenderer * skgpu::ganesh::PathRendererChain::getPathRenderer	(	const PathRenderer::CanDrawPathArgs &	args,
		DrawType	drawType,
		PathRenderer::StencilSupport *	stencilSupport
	)

Returns a GrPathRenderer compatible with the request if one is available. If the caller is drawing the path to the stencil buffer then stencilSupport can be used to determine whether the path can be rendered with arbitrary stencil rules or not. See comments on StencilSupport in GrPathRenderer.h.

Definition at line 72 of file PathRendererChain.cpp.

                                                                                             {
    static_assert(PathRenderer::kNoSupport_StencilSupport <
                  PathRenderer::kStencilOnly_StencilSupport);
    static_assert(PathRenderer::kStencilOnly_StencilSupport <
                  PathRenderer::kNoRestriction_StencilSupport);
    PathRenderer::StencilSupport minStencilSupport;
    if (DrawType::kStencil == drawType) {
        minStencilSupport = PathRenderer::kStencilOnly_StencilSupport;
    } else if (DrawType::kStencilAndColor == drawType) {
        minStencilSupport = PathRenderer::kNoRestriction_StencilSupport;
    } else {
        minStencilSupport = PathRenderer::kNoSupport_StencilSupport;
    }
    if (minStencilSupport != PathRenderer::kNoSupport_StencilSupport) {
        // We don't support (and shouldn't need) stenciling of non-fill paths.
        if (!args.fShape->style().isSimpleFill()) {
            return nullptr;
        }
    }
 
    PathRenderer* bestPathRenderer = nullptr;
    for (const sk_sp<PathRenderer>& pr : fChain) {
        PathRenderer::StencilSupport support = PathRenderer::kNoSupport_StencilSupport;
        if (PathRenderer::kNoSupport_StencilSupport != minStencilSupport) {
            support = pr->getStencilSupport(*args.fShape);
            if (support < minStencilSupport) {
                continue;
            }
        }
        PathRenderer::CanDrawPath canDrawPath = pr->canDrawPath(args);
        if (PathRenderer::CanDrawPath::kNo == canDrawPath) {
            continue;
        }
        if (PathRenderer::CanDrawPath::kAsBackup == canDrawPath && bestPathRenderer) {
            continue;
        }
        if (stencilSupport) {
            *stencilSupport = support;
        }
        bestPathRenderer = pr.get();
        if (PathRenderer::CanDrawPath::kYes == canDrawPath) {
            break;
        }
    }
    return bestPathRenderer;
}

getTessellationPathRenderer()

PathRenderer * skgpu::ganesh::PathRendererChain::getTessellationPathRenderer ( )

inline

Returns a direct pointer to the tessellation path renderer, or null if it is not in the chain.

Definition at line 58 of file PathRendererChain.h.

                                                {
        return fTessellationPathRenderer;
    }

---

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

• third_party/skia/src/gpu/ganesh/PathRendererChain.h
• third_party/skia/src/gpu/ganesh/PathRendererChain.cpp