skgpu::graphite::PathAtlas Class Reference

#include <PathAtlas.h>

Inheritance diagram for skgpu::graphite::PathAtlas:

Classes
class	DrawAtlasMgr

Public Types
using	MaskAndOrigin = std::pair< CoverageMaskShape, SkIPoint >

Public Member Functions
	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
uint32_t	width () const
uint32_t	height () const

Protected Member Functions
virtual const TextureProxy *	onAddShape (const Shape &, const Transform &transform, const SkStrokeRec &, skvx::half2 maskSize, skvx::half2 *outPos)=0

Protected Attributes
Recorder *	fRecorder
uint32_t	fWidth = 0
uint32_t	fHeight = 0

Static Protected Attributes
static constexpr int	kEntryPadding = 1

Detailed Description

PathAtlas manages one or more atlas textures that store coverage masks for path rendering.

The contents of a PathAtlas are intended to be transient: atlas regions are considered valid only for the scope of the render passes that sample them. Unlike DrawAtlas, PathAtlas does not necessarily support partial eviction and reuse of subregions. In most subclasses, once an atlas texture is filled up all of its sub-allocations must be invalidated before it can be reused.

PathAtlas does not prescribe how atlas contents get uploaded to the GPU. The specific task mechanism is defined by subclasses.

Definition at line 41 of file PathAtlas.h.

Member Typedef Documentation

MaskAndOrigin

using skgpu::graphite::PathAtlas::MaskAndOrigin = std::pair<CoverageMaskShape, SkIPoint>

Definition at line 50 of file PathAtlas.h.

Constructor & Destructor Documentation

PathAtlas()

skgpu::graphite::PathAtlas::PathAtlas	(	Recorder *	recorder,
		uint32_t	requestedWidth,
		uint32_t	requestedHeight
	)

The PathAtlas will use textures of the requested size or the system's maximum texture size, whichever is smaller.

Definition at line 26 of file PathAtlas.cpp.

        : fRecorder(recorder) {
    const Caps* caps = recorder->priv().caps();
    int maxTextureSize = std::max(caps->maxPathAtlasTextureSize(), kMinAtlasTextureSize);
    maxTextureSize = std::min(maxTextureSize, caps->maxTextureSize());
 
    fWidth = SkPrevPow2(std::min<uint32_t>(requestedWidth, maxTextureSize));
    fHeight = SkPrevPow2(std::min<uint32_t>(requestedHeight, maxTextureSize));
}

~PathAtlas()

skgpu::graphite::PathAtlas::~PathAtlas ( )

virtualdefault

Member Function Documentation

addShape()

std::pair< const Renderer *, std::optional< PathAtlas::MaskAndOrigin > > skgpu::graphite::PathAtlas::addShape	(	const Rect &	transformedShapeBounds,
		const Shape &	shape,
		const Transform &	localToDevice,
		const SkStrokeRec &	style
	)

Searches the atlas for a slot that can fit a coverage mask for a clipped shape with the given bounds in device coordinates and submits the mask to be drawn into the found atlas region. For atlases that cache coverage masks, will first search the cache before adding.

Returns an empty result if a the shape cannot fit in the atlas. Otherwise, returns the CoverageMaskShape (including the texture proxy) for sampling the eventually-rendered coverage mask and the device-space origin the mask should be drawn at (e.g. its recorded draw should be an integer translation matrix), and the Renderer that should be used to draw that shape. The Renderer should have single-channel coverage, require AA bounds outsetting, and have a single renderStep.

The bounds of the atlas entry is laid out with a 1 pixel outset from the given dimensions. The returned shape's UV origin accounts for the padding, and its mask size does not include the padding. This allows the mask to be sampled safely with linear filtering without worrying about HW filtering accessing pixels from other entries.

shape will be drawn after applying the linear components (scale, rotation, skew) of the provided localToDevice transform. This is done by translating the shape by the inverse of the rounded out transformedShapeBounds offset. For an unclipped shape this amounts to translating it back to its origin while preserving any sub-pixel translation. For a clipped shape, this ensures that the visible portions of the mask are centered in the atlas slot while invisible portions that would lie outside the atlas slot get clipped out.

addShape() schedules the shape to be drawn but when and how the rendering happens is specified by the subclass implementation.

The stroke-and-fill style is drawn as a single combined coverage mask containing the stroke and the fill.

Definition at line 38 of file PathAtlas.cpp.

                                  {
    // It is possible for the transformed shape bounds to be fully clipped out while the draw still
    // produces coverage due to an inverse fill. In this case, don't render any mask;
    // CoverageMaskShapeRenderStep will automatically handle the simple fill. We'll handle this
    // by adding an empty mask.
    // TODO: We could have addShape() handle this fully except we need a valid TextureProxy still.
    const bool emptyMask = transformedShapeBounds.isEmptyNegativeOrNaN();
 
    // Round out the shape bounds to preserve any fractional offset so that it is present in the
    // translation that we use when deriving the atlas-space transform later.
    Rect maskBounds = transformedShapeBounds.makeRoundOut();
 
    CoverageMaskShape::MaskInfo maskInfo;
    // This size does *not* include any padding that the atlas may place around the mask. This size
    // represents the area the shape can actually modify.
    maskInfo.fMaskSize = emptyMask ? skvx::half2(0) : skvx::cast<uint16_t>(maskBounds.size());
    Transform atlasTransform = localToDevice.postTranslate(-maskBounds.left(), -maskBounds.top());
    const TextureProxy* atlasProxy = this->onAddShape(shape,
                                                      atlasTransform,
                                                      style,
                                                      maskInfo.fMaskSize,
                                                      &maskInfo.fTextureOrigin);
    if (!atlasProxy) {
        return std::make_pair(nullptr, std::nullopt);
    }
 
    std::optional<PathAtlas::MaskAndOrigin> atlasMask =
            std::make_pair(CoverageMaskShape(shape, atlasProxy, localToDevice.inverse(), maskInfo),
                           SkIPoint{(int) maskBounds.left(), (int) maskBounds.top()});
    return std::make_pair(fRecorder->priv().rendererProvider()->coverageMask(), atlasMask);
}

height()

uint32_t skgpu::graphite::PathAtlas::height ( ) const

inline

Definition at line 95 of file PathAtlas.h.

{ return fHeight; }

isSuitableForAtlasing()

virtual bool skgpu::graphite::PathAtlas::isSuitableForAtlasing ( const Rect &  transformedShapeBounds ) const

inlinevirtual

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 in skgpu::graphite::ComputePathAtlas.

Definition at line 92 of file PathAtlas.h.

{ return true; }

onAddShape()

virtual const TextureProxy * skgpu::graphite::PathAtlas::onAddShape ( const Shape &  , const Transform &  transform, const SkStrokeRec &  , skvx::half2  maskSize, skvx::half2 *  outPos  )

protectedpure virtual

Implemented in skgpu::graphite::RasterPathAtlas.

width()

uint32_t skgpu::graphite::PathAtlas::width ( ) const

inline

Definition at line 94 of file PathAtlas.h.

{ return fWidth; }

Member Data Documentation

fHeight

uint32_t skgpu::graphite::PathAtlas::fHeight = 0

protected

Definition at line 170 of file PathAtlas.h.

fRecorder

Recorder* skgpu::graphite::PathAtlas::fRecorder

protected

Definition at line 167 of file PathAtlas.h.

fWidth

uint32_t skgpu::graphite::PathAtlas::fWidth = 0

protected

Definition at line 169 of file PathAtlas.h.

kEntryPadding

constexpr int skgpu::graphite::PathAtlas::kEntryPadding = 1

staticconstexprprotected

Definition at line 101 of file PathAtlas.h.

---

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

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