skgpu::ganesh::SmallPathAtlasMgr Class Reference

#include <SmallPathAtlasMgr.h>

Inheritance diagram for skgpu::ganesh::SmallPathAtlasMgr:

Public Member Functions
	SmallPathAtlasMgr ()
	~SmallPathAtlasMgr () override
void	reset ()
bool	initAtlas (GrProxyProvider *, const GrCaps *)
SmallPathShapeData *	findOrCreate (const GrStyledShape &, int desiredDimension)
SmallPathShapeData *	findOrCreate (const GrStyledShape &, const SkMatrix &ctm)
GrDrawOpAtlas::ErrorCode	addToAtlas (GrResourceProvider *, GrDeferredUploadTarget *, int width, int height, const void *image, skgpu::AtlasLocator *)
void	setUseToken (SmallPathShapeData *, skgpu::AtlasToken)
bool	preFlush (GrOnFlushResourceProvider *onFlushRP) override
void	postFlush (skgpu::AtlasToken startTokenForNextFlush) override
bool	retainOnFreeGpuResources () override
const GrSurfaceProxyView *	getViews (int *numActiveProxies)
void	deleteCacheEntry (SmallPathShapeData *)
Public Member Functions inherited from GrOnFlushCallbackObject
virtual	~GrOnFlushCallbackObject ()
Public Member Functions inherited from skgpu::PlotEvictionCallback
virtual	~PlotEvictionCallback ()=default
Public Member Functions inherited from skgpu::AtlasGenerationCounter
uint64_t	next ()

Private Member Functions
void	evict (skgpu::PlotLocator) override

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

Detailed Description

This class manages the small path renderer's atlas. It solely operates at flush time. Thus the small path renderer will generate ops at record time but the location of the ops' source data and even the number of proxies to be used will not be determined until the recorded DAGs/DDLs are (re)played.

TODO: investigate fusing this class and the GrAtlasManager.

Definition at line 33 of file SmallPathAtlasMgr.h.

Constructor & Destructor Documentation

SmallPathAtlasMgr()

skgpu::ganesh::SmallPathAtlasMgr::SmallPathAtlasMgr

(

)

Definition at line 25 of file SmallPathAtlasMgr.cpp.

{}

~SmallPathAtlasMgr()

skgpu::ganesh::SmallPathAtlasMgr::~SmallPathAtlasMgr ( )

override

Definition at line 27 of file SmallPathAtlasMgr.cpp.

                                      {
    this->reset();
}

Member Function Documentation

addToAtlas()

GrDrawOpAtlas::ErrorCode skgpu::ganesh::SmallPathAtlasMgr::addToAtlas	(	GrResourceProvider *	resourceProvider,
		GrDeferredUploadTarget *	target,
		int	width,
		int	height,
		const void *	image,
		skgpu::AtlasLocator *	locator
	)

Definition at line 116 of file SmallPathAtlasMgr.cpp.

                                                                                   {
    return fAtlas->addToAtlas(resourceProvider, target, width, height, image, locator);
}

deleteCacheEntry()

void skgpu::ganesh::SmallPathAtlasMgr::deleteCacheEntry

(

SmallPathShapeData *

shapeData

)

Definition at line 77 of file SmallPathAtlasMgr.cpp.

                                                                      {
    fShapeCache.remove(shapeData->fKey);
    fShapeList.remove(shapeData);
    delete shapeData;
}

evict()

void skgpu::ganesh::SmallPathAtlasMgr::evict ( skgpu::PlotLocator  plotLocator )

overrideprivatevirtual

Implements skgpu::PlotEvictionCallback.

Definition at line 129 of file SmallPathAtlasMgr.cpp.

                                                          {
    // remove any paths that use this plot
    ShapeDataList::Iter iter;
    iter.init(fShapeList, ShapeDataList::Iter::kHead_IterStart);
    SmallPathShapeData* shapeData;
    while ((shapeData = iter.get())) {
        iter.next();
        if (plotLocator == shapeData->fAtlasLocator.plotLocator()) {
            fShapeCache.remove(shapeData->fKey);
            fShapeList.remove(shapeData);
            delete shapeData;
#ifdef DF_PATH_TRACKING
            ++g_NumFreedShapes;
#endif
        }
    }
}

findOrCreate() [1/2]

SmallPathShapeData * skgpu::ganesh::SmallPathAtlasMgr::findOrCreate	(	const GrStyledShape &	shape,
		const SkMatrix &	ctm
	)

Definition at line 108 of file SmallPathAtlasMgr.cpp.

                                                                         {
    SmallPathShapeDataKey key(shape, ctm);
 
    // TODO: move the key into 'findOrCreate'
    return this->findOrCreate(key);
}

findOrCreate() [2/2]

SmallPathShapeData * skgpu::ganesh::SmallPathAtlasMgr::findOrCreate	(	const GrStyledShape &	shape,
		int	desiredDimension
	)

Definition at line 100 of file SmallPathAtlasMgr.cpp.

                                                                          {
    SmallPathShapeDataKey key(shape, desiredDimension);
 
    // TODO: move the key into 'findOrCreate'
    return this->findOrCreate(key);
}

getViews()

const GrSurfaceProxyView * skgpu::ganesh::SmallPathAtlasMgr::getViews ( int *  numActiveProxies )

inline

Definition at line 78 of file SmallPathAtlasMgr.h.

                                                              {
        *numActiveProxies = fAtlas->numActivePages();
        return fAtlas->getViews();
    }

initAtlas()

bool skgpu::ganesh::SmallPathAtlasMgr::initAtlas	(	GrProxyProvider *	proxyProvider,
		const GrCaps *	caps
	)

Definition at line 50 of file SmallPathAtlasMgr.cpp.

                                                                                    {
    if (fAtlas) {
        return true;
    }
 
    static constexpr size_t kMaxAtlasTextureBytes = 2048 * 2048;
    static constexpr size_t kPlotWidth = 512;
    static constexpr size_t kPlotHeight = 256;
 
    GrColorType atlasColorType = GrColorType::kAlpha_8;
    const GrBackendFormat format = caps->getDefaultBackendFormat(atlasColorType,
                                                                 GrRenderable::kNo);
 
    GrDrawOpAtlasConfig atlasConfig(caps->maxTextureSize(), kMaxAtlasTextureBytes);
    SkISize size = atlasConfig.atlasDimensions(MaskFormat::kA8);
    fAtlas = GrDrawOpAtlas::Make(proxyProvider, format,
                                 GrColorTypeToSkColorType(atlasColorType),
                                 GrColorTypeBytesPerPixel(atlasColorType),
                                 size.width(), size.height(),
                                 kPlotWidth, kPlotHeight, this,
                                 GrDrawOpAtlas::AllowMultitexturing::kYes,
                                 this,
                                 /*label=*/"SmallPathAtlas");
 
    return SkToBool(fAtlas);
}

postFlush()

void skgpu::ganesh::SmallPathAtlasMgr::postFlush ( skgpu::AtlasToken  startTokenForNextFlush )

inlineoverridevirtual

Called once flushing is complete. startTokenForNextFlush can be used to track resources used in the current flush.

Reimplemented from GrOnFlushCallbackObject.

Definition at line 68 of file SmallPathAtlasMgr.h.

                                                                    {
        if (fAtlas) {
            fAtlas->compact(startTokenForNextFlush);
        }
    }

preFlush()

bool skgpu::ganesh::SmallPathAtlasMgr::preFlush ( GrOnFlushResourceProvider *  onFlushRP )

inlineoverridevirtual

Implements GrOnFlushCallbackObject.

Definition at line 55 of file SmallPathAtlasMgr.h.

                                                                 {
#if defined(GR_TEST_UTILS)
        if (onFlushRP->failFlushTimeCallbacks()) {
            return false;
        }
#endif
 
        if (fAtlas) {
            fAtlas->instantiate(onFlushRP);
        }
        return true;
    }

reset()

void skgpu::ganesh::SmallPathAtlasMgr::reset

(

)

Definition at line 31 of file SmallPathAtlasMgr.cpp.

                              {
    ShapeDataList::Iter iter;
    iter.init(fShapeList, ShapeDataList::Iter::kHead_IterStart);
    SmallPathShapeData* shapeData;
    while ((shapeData = iter.get())) {
        iter.next();
        delete shapeData;
    }
 
    fShapeList.reset();
    fShapeCache.reset();
 
#ifdef DF_PATH_TRACKING
    SkDebugf("Cached shapes: %d, freed shapes: %d\n", g_NumCachedShapes, g_NumFreedShapes);
#endif
 
    fAtlas = nullptr;
}

retainOnFreeGpuResources()

bool skgpu::ganesh::SmallPathAtlasMgr::retainOnFreeGpuResources ( )

inlineoverridevirtual

Tells the callback owner to hold onto this object when freeing GPU resources.

Reimplemented from GrOnFlushCallbackObject.

Definition at line 76 of file SmallPathAtlasMgr.h.

{ return true; }

setUseToken()

void skgpu::ganesh::SmallPathAtlasMgr::setUseToken	(	SmallPathShapeData *	shapeData,
		skgpu::AtlasToken	token
	)

Definition at line 123 of file SmallPathAtlasMgr.cpp.

                                                           {
    fAtlas->setLastUseToken(shapeData->fAtlasLocator, token);
}

---

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

• third_party/skia/src/gpu/ganesh/ops/SmallPathAtlasMgr.h
• third_party/skia/src/gpu/ganesh/ops/SmallPathAtlasMgr.cpp