GrAtlasManager Class Reference

#include <GrAtlasManager.h>

Inheritance diagram for GrAtlasManager:

Public Member Functions
	GrAtlasManager (GrProxyProvider *, size_t maxTextureBytes, GrDrawOpAtlas::AllowMultitexturing, bool supportBilerpAtlas)
	~GrAtlasManager () override
const GrSurfaceProxyView *	getViews (skgpu::MaskFormat format, unsigned int *numActiveProxies)
void	freeAll ()
bool	hasGlyph (skgpu::MaskFormat, sktext::gpu::Glyph *)
GrDrawOpAtlas::ErrorCode	addGlyphToAtlas (const SkGlyph &, sktext::gpu::Glyph *, int srcPadding, GrResourceProvider *, GrDeferredUploadTarget *)
void	addGlyphToBulkAndSetUseToken (skgpu::BulkUsePlotUpdater *, skgpu::MaskFormat, sktext::gpu::Glyph *, skgpu::AtlasToken)
void	setUseTokenBulk (const skgpu::BulkUsePlotUpdater &updater, skgpu::AtlasToken token, skgpu::MaskFormat format)
GrDrawOpAtlas::ErrorCode	addToAtlas (GrResourceProvider *, GrDeferredUploadTarget *, skgpu::MaskFormat, int width, int height, const void *image, skgpu::AtlasLocator *)
uint64_t	atlasGeneration (skgpu::MaskFormat format) const
bool	preFlush (GrOnFlushResourceProvider *onFlushRP) override
void	postFlush (skgpu::AtlasToken startTokenForNextFlush) override
bool	retainOnFreeGpuResources () override
Public Member Functions inherited from GrOnFlushCallbackObject
virtual	~GrOnFlushCallbackObject ()
Public Member Functions inherited from skgpu::AtlasGenerationCounter
uint64_t	next ()

Friends
class	GrAtlasManagerTools

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

Detailed Description

The GrAtlasManager manages the lifetime of and access to GrDrawOpAtlases. It is only available at flush and only via the GrOpFlushState.

This implies that all of the advanced atlasManager functionality (i.e., adding glyphs to the atlas) are only available at flush time.

Definition at line 43 of file GrAtlasManager.h.

Constructor & Destructor Documentation

GrAtlasManager()

GrAtlasManager::GrAtlasManager	(	GrProxyProvider *	proxyProvider,
		size_t	maxTextureBytes,
		GrDrawOpAtlas::AllowMultitexturing	allowMultitexturing,
		bool	supportBilerpAtlas
	)

Definition at line 35 of file GrAtlasManager.cpp.

            : fAllowMultitexturing{allowMultitexturing}
            , fSupportBilerpAtlas{supportBilerpAtlas}
            , fProxyProvider{proxyProvider}
            , fCaps{fProxyProvider->refCaps()}
            , fAtlasConfig{fCaps->maxTextureSize(), maxTextureBytes} { }

~GrAtlasManager()

GrAtlasManager::~GrAtlasManager ( )

overridedefault

Member Function Documentation

addGlyphToAtlas()

GrDrawOpAtlas::ErrorCode GrAtlasManager::addGlyphToAtlas	(	const SkGlyph &	skGlyph,
		sktext::gpu::Glyph *	glyph,
		int	srcPadding,
		GrResourceProvider *	resourceProvider,
		GrDeferredUploadTarget *	uploadTarget
	)

Definition at line 155 of file GrAtlasManager.cpp.

                                                                                               {
#if !defined(SK_DISABLE_SDF_TEXT)
    SkASSERT(0 <= srcPadding && srcPadding <= SK_DistanceFieldInset);
#else
    SkASSERT(0 <= srcPadding);
#endif
 
    if (skGlyph.image() == nullptr) {
        return GrDrawOpAtlas::ErrorCode::kError;
    }
    SkASSERT(glyph != nullptr);
 
    MaskFormat glyphFormat = Glyph::FormatFromSkGlyph(skGlyph.maskFormat());
    MaskFormat expectedMaskFormat = this->resolveMaskFormat(glyphFormat);
    int bytesPerPixel = MaskFormatBytesPerPixel(expectedMaskFormat);
 
    int padding;
    switch (srcPadding) {
        case 0:
            // The direct mask/image case.
            padding = 0;
            if (fSupportBilerpAtlas) {
                // Force direct masks (glyph with no padding) to have padding.
                padding = 1;
                srcPadding = 1;
            }
            break;
        case 1:
            // The transformed mask/image case.
            padding = 1;
            break;
#if !defined(SK_DISABLE_SDF_TEXT)
        case SK_DistanceFieldInset:
            // The SDFT case.
            // If the srcPadding == SK_DistanceFieldInset (SDFT case) then the padding is built
            // into the image on the glyph; no extra padding needed.
            // TODO: can the SDFT glyph image in the cache be reduced by the padding?
            padding = 0;
            break;
#endif
        default:
            // The padding is not one of the know forms.
            return GrDrawOpAtlas::ErrorCode::kError;
    }
 
    const int width = skGlyph.width() + 2*padding;
    const int height = skGlyph.height() + 2*padding;
    int rowBytes = width * bytesPerPixel;
    size_t size = height * rowBytes;
 
    // Temporary storage for normalizing glyph image.
    SkAutoSMalloc<1024> storage(size);
    void* dataPtr = storage.get();
    if (padding > 0) {
        sk_bzero(dataPtr, size);
        // Advance in one row and one column.
        dataPtr = (char*)(dataPtr) + rowBytes + bytesPerPixel;
    }
 
    get_packed_glyph_image(skGlyph, rowBytes, expectedMaskFormat, dataPtr);
 
    auto errorCode = this->addToAtlas(resourceProvider,
                                      uploadTarget,
                                      expectedMaskFormat,
                                      width,
                                      height,
                                      storage.get(),
                                      &glyph->fAtlasLocator);
 
    if (errorCode == GrDrawOpAtlas::ErrorCode::kSucceeded) {
        glyph->fAtlasLocator.insetSrc(srcPadding);
    }
 
    return errorCode;
}

addGlyphToBulkAndSetUseToken()

void GrAtlasManager::addGlyphToBulkAndSetUseToken	(	skgpu::BulkUsePlotUpdater *	updater,
		skgpu::MaskFormat	format,
		sktext::gpu::Glyph *	glyph,
		skgpu::AtlasToken	token
	)

Definition at line 245 of file GrAtlasManager.cpp.

                                                                         {
    SkASSERT(glyph);
    if (updater->add(glyph->fAtlasLocator)) {
        this->getAtlas(format)->setLastUseToken(glyph->fAtlasLocator, token);
    }
}

addToAtlas()

GrDrawOpAtlas::ErrorCode GrAtlasManager::addToAtlas	(	GrResourceProvider *	resourceProvider,
		GrDeferredUploadTarget *	target,
		skgpu::MaskFormat	format,
		int	width,
		int	height,
		const void *	image,
		skgpu::AtlasLocator *	atlasLocator
	)

Definition at line 236 of file GrAtlasManager.cpp.

                                                                                     {
    return this->getAtlas(format)->addToAtlas(resourceProvider, target, width, height, image,
                                              atlasLocator);
}

atlasGeneration()

uint64_t GrAtlasManager::atlasGeneration ( skgpu::MaskFormat  format ) const

inline

Definition at line 97 of file GrAtlasManager.h.

                                                           {
        return this->getAtlas(format)->atlasGeneration();
    }

freeAll()

void GrAtlasManager::freeAll

(

)

Definition at line 47 of file GrAtlasManager.cpp.

                             {
    for (int i = 0; i < skgpu::kMaskFormatCount; ++i) {
        fAtlases[i] = nullptr;
    }
}

getViews()

const GrSurfaceProxyView * GrAtlasManager::getViews ( skgpu::MaskFormat  format, unsigned int *  numActiveProxies  )

inline

Definition at line 55 of file GrAtlasManager.h.

                                                                                               {
        format = this->resolveMaskFormat(format);
        if (this->initAtlas(format)) {
            *numActiveProxies = this->getAtlas(format)->numActivePages();
            return this->getAtlas(format)->getViews();
        }
        *numActiveProxies = 0;
        return nullptr;
    }

hasGlyph()

bool GrAtlasManager::hasGlyph	(	skgpu::MaskFormat	format,
		sktext::gpu::Glyph *	glyph
	)

Definition at line 53 of file GrAtlasManager.cpp.

                                                             {
    SkASSERT(glyph);
    return this->getAtlas(format)->hasID(glyph->fAtlasLocator.plotLocator());
}

postFlush()

void GrAtlasManager::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 118 of file GrAtlasManager.h.

                                                                    {
        for (int i = 0; i < skgpu::kMaskFormatCount; ++i) {
            if (fAtlases[i]) {
                fAtlases[i]->compact(startTokenForNextFlush);
            }
        }
    }

preFlush()

bool GrAtlasManager::preFlush ( GrOnFlushResourceProvider *  onFlushRP )

inlineoverridevirtual

Implements GrOnFlushCallbackObject.

Definition at line 103 of file GrAtlasManager.h.

                                                                 {
#if defined(GR_TEST_UTILS)
        if (onFlushRP->failFlushTimeCallbacks()) {
            return false;
        }
#endif
 
        for (int i = 0; i < skgpu::kMaskFormatCount; ++i) {
            if (fAtlases[i]) {
                fAtlases[i]->instantiate(onFlushRP);
            }
        }
        return true;
    }

retainOnFreeGpuResources()

bool GrAtlasManager::retainOnFreeGpuResources ( )

inlineoverridevirtual

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

Reimplemented from GrOnFlushCallbackObject.

Definition at line 128 of file GrAtlasManager.h.

{ return true; }

setUseTokenBulk()

void GrAtlasManager::setUseTokenBulk ( const skgpu::BulkUsePlotUpdater &  updater, skgpu::AtlasToken  token, skgpu::MaskFormat  format  )

inline

Definition at line 83 of file GrAtlasManager.h.

                                                 {
        this->getAtlas(format)->setLastUseTokenBulk(updater, token);
    }

Friends And Related Symbol Documentation

GrAtlasManagerTools

friend class GrAtlasManagerTools

friend

Definition at line 131 of file GrAtlasManager.h.

---

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

• third_party/skia/src/gpu/ganesh/text/GrAtlasManager.h
• third_party/skia/src/gpu/ganesh/text/GrAtlasManager.cpp