skgpu::graphite::RasterPathAtlas Class Reference

#include <RasterPathAtlas.h>

Inheritance diagram for skgpu::graphite::RasterPathAtlas:

Public Member Functions
	RasterPathAtlas (Recorder *recorder)
	~RasterPathAtlas () override
void	recordUploads (DrawContext *)
void	postFlush ()
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
uint32_t	width () const
uint32_t	height () const

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

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

PathAtlas class that rasterizes coverage masks on the CPU.

When a new shape gets added, its path is rasterized in preparation for upload. These uploads are recorded by recordUploads() and subsequently added to an UploadTask.

Shapes are cached for future frames to avoid the cost of raster pipeline rendering. Multiple textures (or Pages) are used to cache masks, so if the atlas is full we can reset a Page and start adding new shapes for a future atlas render.

Definition at line 25 of file RasterPathAtlas.h.

Constructor & Destructor Documentation

RasterPathAtlas()

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

explicit

Definition at line 26 of file RasterPathAtlas.cpp.

        : PathAtlas(recorder, kDefaultAtlasDim, kDefaultAtlasDim)
        , fCachedAtlasMgr(fWidth, fHeight, fWidth, fHeight, recorder->priv().caps())
        , fSmallPathAtlasMgr(std::max(fWidth/2, kSmallPathPlotWidth),
                             std::max(fHeight/2, kSmallPathPlotHeight),
                             kSmallPathPlotWidth, kSmallPathPlotHeight,
                             recorder->priv().caps())
        , fUncachedAtlasMgr(fWidth, fHeight, fWidth, fHeight, recorder->priv().caps()) {
    SkASSERT(recorder);
}

~RasterPathAtlas()

skgpu::graphite::RasterPathAtlas::~RasterPathAtlas ( )

inlineoverride

Definition at line 28 of file RasterPathAtlas.h.

{}

Member Function Documentation

onAddShape()

const TextureProxy * skgpu::graphite::RasterPathAtlas::onAddShape ( const Shape &  shape, const Transform &  transform, const SkStrokeRec &  strokeRec, skvx::half2  maskSize, skvx::half2 *  outPos  )

overrideprotectedvirtual

Implements skgpu::graphite::PathAtlas.

Definition at line 43 of file RasterPathAtlas.cpp.

                                                                   {
    skgpu::UniqueKey maskKey;
    bool hasKey = shape.hasKey();
    if (hasKey) {
        constexpr int kMaxSmallPathSize = 162;
        // Try to locate or add to cached DrawAtlas
        const TextureProxy* proxy = nullptr;
        if (maskSize.x() <= kMaxSmallPathSize && maskSize.y() <= kMaxSmallPathSize) {
            proxy = fSmallPathAtlasMgr.findOrCreateEntry(fRecorder,
                                                         shape,
                                                         transform,
                                                         strokeRec,
                                                         maskSize,
                                                         outPos);
        }
        if (!proxy) {
            proxy = fCachedAtlasMgr.findOrCreateEntry(fRecorder,
                                                      shape,
                                                      transform,
                                                      strokeRec,
                                                      maskSize,
                                                      outPos);
        }
        if (proxy) {
            return proxy;
        }
    }
 
    // try to add to uncached DrawAtlas
    AtlasLocator loc;
    return fUncachedAtlasMgr.addToAtlas(fRecorder,
                                        shape,
                                        transform,
                                        strokeRec,
                                        maskSize,
                                        outPos,
                                        &loc);
}

postFlush()

void skgpu::graphite::RasterPathAtlas::postFlush ( )

inline

Definition at line 31 of file RasterPathAtlas.h.

                     {
        fCachedAtlasMgr.postFlush(fRecorder);
        fSmallPathAtlasMgr.postFlush(fRecorder);
        fUncachedAtlasMgr.postFlush(fRecorder);
    }

recordUploads()

void skgpu::graphite::RasterPathAtlas::recordUploads

(

DrawContext *

dc

)

Definition at line 37 of file RasterPathAtlas.cpp.

                                                   {
    fCachedAtlasMgr.recordUploads(dc, fRecorder);
    fSmallPathAtlasMgr.recordUploads(dc, fRecorder);
    fUncachedAtlasMgr.recordUploads(dc, fRecorder);
}

---

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

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