skgpu::graphite::PathAtlas::DrawAtlasMgr Class Reference

#include <PathAtlas.h>

Inheritance diagram for skgpu::graphite::PathAtlas::DrawAtlasMgr:

Public Member Functions
const TextureProxy *	findOrCreateEntry (Recorder *recorder, const Shape &shape, const Transform &transform, const SkStrokeRec &strokeRec, skvx::half2 maskSize, skvx::half2 *outPos)
const TextureProxy *	addToAtlas (Recorder *recorder, const Shape &shape, const Transform &transform, const SkStrokeRec &strokeRec, skvx::half2 maskSize, skvx::half2 *outPos, AtlasLocator *locator)
bool	recordUploads (DrawContext *, Recorder *)
void	evict (PlotLocator) override
void	postFlush (Recorder *)
Public Member Functions inherited from skgpu::AtlasGenerationCounter
uint64_t	next ()
Public Member Functions inherited from skgpu::PlotEvictionCallback
virtual	~PlotEvictionCallback ()=default

Protected Member Functions
	DrawAtlasMgr (size_t width, size_t height, size_t plotWidth, size_t plotHeight, std::string_view label, const Caps *)
virtual bool	onAddToAtlas (const Shape &, const Transform &transform, const SkStrokeRec &, SkIRect shapeBounds, const AtlasLocator &)=0

Protected Attributes
std::unique_ptr< DrawAtlas >	fDrawAtlas

Additional Inherited Members
Static Public Attributes inherited from skgpu::AtlasGenerationCounter
static constexpr uint64_t	kInvalidGeneration = 0

Detailed Description

Definition at line 113 of file PathAtlas.h.

Constructor & Destructor Documentation

DrawAtlasMgr()

skgpu::graphite::PathAtlas::DrawAtlasMgr::DrawAtlasMgr ( size_t  width, size_t  height, size_t  plotWidth, size_t  plotHeight, std::string_view  label, const Caps *  caps  )

protected

Definition at line 76 of file PathAtlas.cpp.

                                                        {
    static constexpr SkColorType colorType = kAlpha_8_SkColorType;
 
    fDrawAtlas = DrawAtlas::Make(colorType,
                                 SkColorTypeBytesPerPixel(colorType),
                                 width, height,
                                 plotWidth, plotHeight,
                                 this,
                                 caps->allowMultipleAtlasTextures() ?
                                         DrawAtlas::AllowMultitexturing::kYes :
                                         DrawAtlas::AllowMultitexturing::kNo,
                                 this,
                                 label);
    SkASSERT(fDrawAtlas);
    fKeyLists.resize(fDrawAtlas->numPlots() * fDrawAtlas->maxPages());
    for (int i = 0; i < fKeyLists.size(); ++i) {
        fKeyLists[i].reset();
    }
}

Member Function Documentation

addToAtlas()

const TextureProxy * skgpu::graphite::PathAtlas::DrawAtlasMgr::addToAtlas	(	Recorder *	recorder,
		const Shape &	shape,
		const Transform &	transform,
		const SkStrokeRec &	strokeRec,
		skvx::half2	maskSize,
		skvx::half2 *	outPos,
		AtlasLocator *	locator
	)

Definition at line 140 of file PathAtlas.cpp.

                                                                               {
    // Render mask.
    SkIRect iShapeBounds = SkIRect::MakeXYWH(0, 0, maskSize.x(), maskSize.y());
    // Outset to take padding into account
    SkIRect iAtlasBounds = iShapeBounds.makeOutset(kEntryPadding, kEntryPadding);
 
    // Request space in DrawAtlas.
    DrawAtlas::ErrorCode errorCode = fDrawAtlas->addRect(recorder,
                                                         iAtlasBounds.width(),
                                                         iAtlasBounds.height(),
                                                         locator);
    if (errorCode != DrawAtlas::ErrorCode::kSucceeded) {
        return nullptr;
    }
    SkIPoint topLeft = locator->topLeft();
    *outPos = skvx::half2(topLeft.x()+kEntryPadding, topLeft.y()+kEntryPadding);
 
    // If the mask is empty, just return.
    // TODO: this may not be needed if we can handle clipped out bounds with inverse fills
    // another way. See PathAtlas::addShape().
    if (!all(maskSize)) {
        fDrawAtlas->setLastUseToken(*locator,
                                    recorder->priv().tokenTracker()->nextFlushToken());
        return fDrawAtlas->getProxies()[locator->pageIndex()].get();
    }
 
    if (!this->onAddToAtlas(shape, transform, strokeRec, iShapeBounds, *locator)) {
        return nullptr;
    }
 
    fDrawAtlas->setLastUseToken(*locator,
                                recorder->priv().tokenTracker()->nextFlushToken());
 
    return fDrawAtlas->getProxies()[locator->pageIndex()].get();
}

evict()

void skgpu::graphite::PathAtlas::DrawAtlasMgr::evict ( PlotLocator  plotLocator )

overridevirtual

Implements skgpu::PlotEvictionCallback.

Definition at line 186 of file PathAtlas.cpp.

                                                         {
    // Remove all entries for this Plot from the ShapeCache
    uint32_t index = shape_key_list_index(plotLocator, fDrawAtlas.get());
    ShapeKeyList::Iter iter;
    iter.init(fKeyLists[index], ShapeKeyList::Iter::kHead_IterStart);
    ShapeKeyEntry* currEntry;
    while ((currEntry = iter.get())) {
        iter.next();
        fShapeCache.remove(currEntry->fKey);
        fKeyLists[index].remove(currEntry);
        delete currEntry;
    }
}

findOrCreateEntry()

const TextureProxy * skgpu::graphite::PathAtlas::DrawAtlasMgr::findOrCreateEntry	(	Recorder *	recorder,
		const Shape &	shape,
		const Transform &	transform,
		const SkStrokeRec &	strokeRec,
		skvx::half2	maskSize,
		skvx::half2 *	outPos
	)

Definition at line 105 of file PathAtlas.cpp.

                                                                                  {
    // Shapes must have a key to use this method
    skgpu::UniqueKey maskKey = GeneratePathMaskKey(shape, transform, strokeRec, maskSize);
    AtlasLocator* cachedLocator = fShapeCache.find(maskKey);
    if (cachedLocator) {
        SkIPoint topLeft = cachedLocator->topLeft();
        *outPos = skvx::half2(topLeft.x() + kEntryPadding, topLeft.y() + kEntryPadding);
        fDrawAtlas->setLastUseToken(*cachedLocator,
                                    recorder->priv().tokenTracker()->nextFlushToken());
        return fDrawAtlas->getProxies()[cachedLocator->pageIndex()].get();
    }
 
    AtlasLocator locator;
    const TextureProxy* proxy = this->addToAtlas(recorder, shape, transform, strokeRec,
                                                 maskSize, outPos, &locator);
    if (!proxy) {
        return nullptr;
    }
 
    // Add locator to ShapeCache.
    fShapeCache.set(maskKey, locator);
    // Add key to Plot's ShapeKeyList.
    uint32_t index = shape_key_list_index(locator.plotLocator(), fDrawAtlas.get());
    ShapeKeyEntry* keyEntry = new ShapeKeyEntry();
    keyEntry->fKey = maskKey;
    fKeyLists[index].addToTail(keyEntry);
 
    return proxy;
}

onAddToAtlas()

virtual bool skgpu::graphite::PathAtlas::DrawAtlasMgr::onAddToAtlas ( const Shape &  , const Transform &  transform, const SkStrokeRec &  , SkIRect  shapeBounds, const AtlasLocator &    )

protectedpure virtual

postFlush()

void skgpu::graphite::PathAtlas::DrawAtlasMgr::postFlush

(

Recorder *

recorder

)

Definition at line 200 of file PathAtlas.cpp.

                                                        {
    fDrawAtlas->compact(recorder->priv().tokenTracker()->nextFlushToken());
}

recordUploads()

bool skgpu::graphite::PathAtlas::DrawAtlasMgr::recordUploads	(	DrawContext *	dc,
		Recorder *	recorder
	)

Definition at line 182 of file PathAtlas.cpp.

                                                                             {
    return fDrawAtlas->recordUploads(dc, recorder);
}

Member Data Documentation

fDrawAtlas

std::unique_ptr<DrawAtlas> skgpu::graphite::PathAtlas::DrawAtlasMgr::fDrawAtlas

protected

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