skgpu::graphite::ComputePathAtlas Class Reference

#include <ComputePathAtlas.h>

Inheritance diagram for skgpu::graphite::ComputePathAtlas:

Public Member Functions
virtual bool	recordDispatches (Recorder *, ComputeTask::DispatchGroupList *) const =0
void	reset ()
Public Member Functions inherited from skgpu::graphite::PathAtlas
	PathAtlas (Recorder *recorder, uint32_t requestedWidth, uint32_t requestedHeight)
virtual	~PathAtlas ()
std::pair< const Renderer *, std::optional< MaskAndOrigin > >	addShape (const Rect &transformedShapeBounds, const Shape &shape, const Transform &localToDevice, const SkStrokeRec &style)
virtual bool	isSuitableForAtlasing (const Rect &transformedShapeBounds, const Rect &clipBounds) const
uint32_t	width () const
uint32_t	height () const

Static Public Member Functions
static std::unique_ptr< ComputePathAtlas >	CreateDefault (Recorder *)

Protected Member Functions
	ComputePathAtlas (Recorder *)
const TextureProxy *	texture () const
const TextureProxy *	addRect (skvx::half2 maskSize, SkIPoint16 *outPos)
bool	isSuitableForAtlasing (const Rect &transformedShapeBounds, const Rect &clipBounds) const override
virtual void	onReset ()=0
Protected Member Functions inherited from skgpu::graphite::PathAtlas
virtual const TextureProxy *	onAddShape (const Shape &, const Transform &transform, const SkStrokeRec &, skvx::half2 maskSize, skvx::half2 *outPos)=0

Additional Inherited Members
Public Types inherited from skgpu::graphite::PathAtlas
using	MaskAndOrigin = std::pair< CoverageMaskShape, SkIPoint >
Static Public Attributes inherited from skgpu::graphite::PathAtlas
static constexpr int	kEntryPadding = 1
Protected Attributes inherited from skgpu::graphite::PathAtlas
Recorder *	fRecorder
uint32_t	fWidth = 0
uint32_t	fHeight = 0

Detailed Description

Base class for PathAtlas implementations that rasterize coverage masks on the GPU using compute shaders.

When a new shape gets added, it gets tracked as input to a series of GPU compute passes. This data is recorded by recordDispatches() into a DispatchGroup which can be added to a ComputeTask.

After a successful call to recordDispatches(), the client is free to call reset() and start adding new shapes for a future atlas render.

Definition at line 42 of file ComputePathAtlas.h.

Constructor & Destructor Documentation

ComputePathAtlas()

skgpu::graphite::ComputePathAtlas::ComputePathAtlas ( Recorder *  recorder )

explicitprotected

Definition at line 44 of file ComputePathAtlas.cpp.

    : PathAtlas(recorder, kComputeAtlasDim, kComputeAtlasDim)
    , fRectanizer(this->width(), this->height()) {}

Member Function Documentation

addRect()

const TextureProxy * skgpu::graphite::ComputePathAtlas::addRect ( skvx::half2  maskSize, SkIPoint16 *  outPos  )

protected

Definition at line 89 of file ComputePathAtlas.cpp.

                                                                  {
    if (!this->initializeTextureIfNeeded()) {
        SKGPU_LOG_E("Failed to instantiate an atlas texture");
        return nullptr;
    }
 
    // An empty mask always fits, so just return the texture.
    // TODO: This may not be needed if we can handle clipped out bounds with inverse fills
    // another way. See PathAtlas::addShape().
    if (!all(maskSize)) {
        *outPos = {0, 0};
        return fTexture.get();
    }
 
    if (!fRectanizer.addPaddedRect(maskSize.x(), maskSize.y(), kEntryPadding, outPos)) {
        return nullptr;
    }
 
    return fTexture.get();
}

CreateDefault()

std::unique_ptr< ComputePathAtlas > skgpu::graphite::ComputePathAtlas::CreateDefault ( Recorder *  recorder )

static

Definition at line 417 of file ComputePathAtlas.cpp.

                                                                                  {
#ifdef SK_ENABLE_VELLO_SHADERS
    return std::make_unique<VelloComputePathAtlas>(recorder);
#else
    return nullptr;
#endif
}

isSuitableForAtlasing()

bool skgpu::graphite::ComputePathAtlas::isSuitableForAtlasing ( const Rect &  transformedShapeBounds, const Rect &  clipBounds  ) const

overrideprotectedvirtual

Returns true if a path coverage mask with the given device-space bounds is sufficiently small to benefit from atlasing without causing too many atlas renders.

transformedShapeBounds represents the device-space bounds of the coverage mask shape unrestricted by clip and viewport bounds.

clipBounds represents the conservative bounding box of the union of the clip stack that should apply to the shape.

Reimplemented from skgpu::graphite::PathAtlas.

Definition at line 61 of file ComputePathAtlas.cpp.

                                                                           {
    Rect shapeBounds = transformedShapeBounds.makeRoundOut();
    Rect maskBounds = shapeBounds.makeIntersect(clipBounds);
    skvx::float2 maskSize = maskBounds.size();
    float width = maskSize.x(), height = maskSize.y();
 
    if (width > this->width() || height > this->height()) {
        return false;
    }
 
    // For now we're allowing paths that are smaller than 1/32nd of the full 4096x4096 atlas size
    // to prevent the atlas texture from filling up too often. There are several approaches we
    // should explore to alleviate the cost of atlasing large paths.
    if (width * height > kBboxAreaThreshold) {
        return false;
    }
 
    // Reject pathological shapes that vello can't handle efficiently yet.
    skvx::float2 unclippedSize = shapeBounds.size();
    if (std::fabs(unclippedSize.x()) > kCoordinateThreshold ||
        std::fabs(unclippedSize.y()) > kCoordinateThreshold) {
        return false;
    }
 
    return true;
}

onReset()

virtual void skgpu::graphite::ComputePathAtlas::onReset ( )

protectedpure virtual

recordDispatches()

virtual bool skgpu::graphite::ComputePathAtlas::recordDispatches ( Recorder *  , ComputeTask::DispatchGroupList *    ) const

pure virtual

reset()

void skgpu::graphite::ComputePathAtlas::reset

(

)

Definition at line 111 of file ComputePathAtlas.cpp.

                             {
    fRectanizer.reset();
 
    this->onReset();
}

texture()

const TextureProxy * skgpu::graphite::ComputePathAtlas::texture ( ) const

inlineprotected

Definition at line 58 of file ComputePathAtlas.h.

{ return fTexture.get(); }

---

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

• third_party/skia/src/gpu/graphite/ComputePathAtlas.h
• third_party/skia/src/gpu/graphite/ComputePathAtlas.cpp