#include <AtlasPathRenderer.h>

Inheritance diagram for skgpu::ganesh::AtlasPathRenderer:

Public Member Functions
const char *	name () const override

GrFPResult	makeAtlasClipEffect (const skgpu::ganesh::SurfaceDrawContext , const GrOp opBeingClipped, std::unique_ptr< GrFragmentProcessor > inputFP, const SkIRect &drawBounds, const SkMatrix &, const SkPath &)

Public Member Functions inherited from skgpu::ganesh::PathRenderer
	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

Public Member Functions inherited from GrOnFlushCallbackObject
virtual	~GrOnFlushCallbackObject ()

virtual bool	preFlush (GrOnFlushResourceProvider *)=0

virtual void	postFlush (skgpu::AtlasToken startTokenForNextFlush)

virtual bool	retainOnFreeGpuResources ()

Static Public Member Functions
static bool	IsSupported (GrRecordingContext *)

static sk_sp< AtlasPathRenderer >	Make (GrRecordingContext *rContext)

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 27 of file AtlasPathRenderer.h.

Member Function Documentation

◆ IsSupported()

bool skgpu::ganesh::AtlasPathRenderer::IsSupported ( GrRecordingContext * rContext )

static

Definition at line 107 of file AtlasPathRenderer.cpp.

                                                                {
#ifdef SK_BUILD_FOR_IOS
    // b/195095846: There is a bug with the atlas path renderer on OpenGL iOS. Disable until we can
    // investigate.
    if (rContext->backend() == GrBackendApi::kOpenGL) {
        return false;
    }
#endif
#ifdef SK_BUILD_FOR_WIN
    // http://skbug.com/13519 There is a bug with the atlas path renderer on Direct3D, running on
    // Radeon hardware and possibly others. Disable until we can investigate.
    if (rContext->backend() == GrBackendApi::kDirect3D) {
        return false;
    }
#endif
    const GrCaps& caps = *rContext->priv().caps();
    auto atlasFormat = caps.getDefaultBackendFormat(kAtlasAlpha8Type, GrRenderable::kYes);
    return rContext->asDirectContext() &&  // The atlas doesn't support DDL yet.
           caps.internalMultisampleCount(atlasFormat) > 1 &&
           // GrAtlasRenderTask currently requires tessellation. In the future it could use the
           // default path renderer when tessellation isn't available.
           TessellationPathRenderer::IsSupported(caps);
}

◆ Make()

sk_sp< AtlasPathRenderer > skgpu::ganesh::AtlasPathRenderer::Make ( GrRecordingContext * rContext )

static

Definition at line 131 of file AtlasPathRenderer.cpp.

                                                                             {
    return IsSupported(rContext)
            ? sk_sp<AtlasPathRenderer>(new AtlasPathRenderer(rContext->asDirectContext()))
            : nullptr;
}

◆ makeAtlasClipEffect()

GrFPResult skgpu::ganesh::AtlasPathRenderer::makeAtlasClipEffect	(	const skgpu::ganesh::SurfaceDrawContext *	sdc,
		const GrOp *	opBeingClipped,
		std::unique_ptr< GrFragmentProcessor >	inputFP,
		const SkIRect &	drawBounds,
		const SkMatrix &	viewMatrix,
		const SkPath &	path
	)

Definition at line 332 of file AtlasPathRenderer.cpp.

                                                                      {
    if (viewMatrix.hasPerspective()) {
        return GrFPFailure(std::move(inputFP));
    }
 
    const SkRect pathDevBounds = viewMatrix.mapRect(path.getBounds());
    if (!is_visible(pathDevBounds, drawBounds)) {
        // The path is empty or outside the drawBounds. No mask is needed. We explicitly allow the
        // returned successful "fp" to be null in case this bypassed atlas clip effect was the first
        // clip to be processed by the clip stack (at which point inputFP is null).
        return path.isInverseFillType() ? GrFPNullableSuccess(std::move(inputFP))
                                        : GrFPFailure(std::move(inputFP));
    }
 
    auto fallbackAAType = (sdc->numSamples() > 1 || sdc->canUseDynamicMSAA()) ? GrAAType::kMSAA
                                                                              : GrAAType::kCoverage;
    if (!this->pathFitsInAtlas(pathDevBounds, fallbackAAType)) {
        // The path is too big.
        return GrFPFailure(std::move(inputFP));
    }
 
    SkIRect devIBounds;
    SkIPoint16 locationInAtlas;
    bool transposedInAtlas;
    // Called if the atlas runs out of room, to determine if it's safe to create a new one. (Draws
    // can never access more than one atlas.)
    auto drawRefsAtlasCallback = [opBeingClipped, &inputFP](const GrSurfaceProxy* atlasProxy) {
        return refs_atlas(opBeingClipped, atlasProxy) ||
               refs_atlas(inputFP.get(), atlasProxy);
    };
    // addPathToAtlas() ignores inverseness of the fill. See GrAtlasRenderTask::getAtlasUberPath().
    if (!this->addPathToAtlas(sdc->recordingContext(), viewMatrix, path, pathDevBounds, &devIBounds,
                              &locationInAtlas, &transposedInAtlas, drawRefsAtlasCallback)) {
        // The atlas ran out of room and we were unable to start a new one.
        return GrFPFailure(std::move(inputFP));
    }
 
    SkMatrix atlasMatrix;
    auto [atlasX, atlasY] = locationInAtlas;
    if (!transposedInAtlas) {
        atlasMatrix = SkMatrix::Translate(atlasX - devIBounds.left(), atlasY - devIBounds.top());
    } else {
        atlasMatrix.setAll(0, 1, atlasX - devIBounds.top(),
                           1, 0, atlasY - devIBounds.left(),
                           0, 0, 1);
    }
    auto flags = GrModulateAtlasCoverageEffect::Flags::kNone;
    if (path.isInverseFillType()) {
        flags |= GrModulateAtlasCoverageEffect::Flags::kInvertCoverage;
    }
    if (!devIBounds.contains(drawBounds)) {
        flags |= GrModulateAtlasCoverageEffect::Flags::kCheckBounds;
        // At this point in time we expect callers to tighten the scissor for "kIntersect" clips, as
        // opposed to us having to check the path bounds. Feel free to remove this assert if that
        // ever changes.
        SkASSERT(path.isInverseFillType());
    }
    GrSurfaceProxyView atlasView = fAtlasRenderTasks.back()->readView(*sdc->caps());
    return GrFPSuccess(std::make_unique<GrModulateAtlasCoverageEffect>(flags, std::move(inputFP),
                                                                       std::move(atlasView),
                                                                       atlasMatrix, devIBounds));
}

◆ name()

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

inlineoverridevirtual

Implements skgpu::ganesh::PathRenderer.

Definition at line 34 of file AtlasPathRenderer.h.

34{ return "GrAtlasPathRenderer"; }

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

third_party/skia/src/gpu/ganesh/ops/AtlasPathRenderer.h
third_party/skia/src/gpu/ganesh/ops/AtlasPathRenderer.cpp

Public Member Functions