skgpu::graphite::ComputePathAtlas Class Reference

#include <ComputePathAtlas.h>

Inheritance diagram for skgpu::graphite::ComputePathAtlas:

Public Member Functions
virtual std::unique_ptr< DispatchGroup >	recordDispatches (Recorder *) 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)
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 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 >
Protected Attributes inherited from skgpu::graphite::PathAtlas
Recorder *	fRecorder
uint32_t	fWidth = 0
uint32_t	fHeight = 0
Static Protected Attributes inherited from skgpu::graphite::PathAtlas
static constexpr int	kEntryPadding = 1

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 36 of file ComputePathAtlas.h.

Constructor & Destructor Documentation

ComputePathAtlas()

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

explicitprotected

Definition at line 32 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 73 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 243 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

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.

Reimplemented from skgpu::graphite::PathAtlas.

Definition at line 49 of file ComputePathAtlas.cpp.

                                                                                     {
    Rect maskBounds = transformedShapeBounds.makeRoundOut();
    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.
    //
    // 1. Rendering multiple atlas textures requires an extra compute pass for each texture. This
    // impairs performance because there is a fixed cost to each dispatch and all dispatches get
    // serialized by pipeline barrier synchronization. We should explore ways to render to multiple
    // textures by issuing more workgroups in fewer dispatches as well as removing pipeline barriers
    // across dispatches that target different atlas pages.
    //
    // 2. Implement a compressed "sparse" mask rendering scheme to render paths with a large
    // bounding box using less texture space.
    return (width * height) <= (1024 * 512);
}

onReset()

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

protectedpure virtual

recordDispatches()

virtual std::unique_ptr< DispatchGroup > skgpu::graphite::ComputePathAtlas::recordDispatches ( Recorder *  ) const

pure virtual

reset()

void skgpu::graphite::ComputePathAtlas::reset

(

)

Definition at line 95 of file ComputePathAtlas.cpp.

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

texture()

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

inlineprotected

Definition at line 52 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