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 Rect &clipBounds) const
uint32_t	width () const
uint32_t	height () const

Static Public Attributes
static constexpr int	kEntryPadding = 1

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

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 109 of file PathAtlas.h.

{ return fHeight; }

isSuitableForAtlasing()

virtual bool skgpu::graphite::PathAtlas::isSuitableForAtlasing ( const Rect &  transformedShapeBounds, const Rect &  clipBounds  ) 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.

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

Definition at line 103 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 108 of file PathAtlas.h.

{ return fWidth; }

Member Data Documentation

fHeight

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

protected

Definition at line 180 of file PathAtlas.h.

fRecorder

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

protected

Definition at line 177 of file PathAtlas.h.

fWidth

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

protected

Definition at line 179 of file PathAtlas.h.

kEntryPadding

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

staticconstexpr

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