skgpu::graphite::TextAtlasManager Class Reference

#include <TextAtlasManager.h>

Inheritance diagram for skgpu::graphite::TextAtlasManager:

Public Member Functions
	TextAtlasManager (Recorder *)
	~TextAtlasManager ()
const sk_sp< TextureProxy > *	getProxies (MaskFormat format, unsigned int *numActiveProxies)
void	freeAll ()
bool	hasGlyph (MaskFormat, sktext::gpu::Glyph *)
DrawAtlas::ErrorCode	addGlyphToAtlas (const SkGlyph &, sktext::gpu::Glyph *, int srcPadding)
void	addGlyphToBulkAndSetUseToken (BulkUsePlotUpdater *, MaskFormat, sktext::gpu::Glyph *, AtlasToken)
void	setUseTokenBulk (const BulkUsePlotUpdater &updater, AtlasToken token, MaskFormat format)
bool	recordUploads (DrawContext *dc)
void	evictAtlases ()
void	postFlush ()
uint64_t	atlasGeneration (skgpu::MaskFormat format) const
void	setAtlasDimensionsToMinimum_ForTesting ()
void	setMaxPages_TestingOnly (uint32_t maxPages)
Public Member Functions inherited from skgpu::AtlasGenerationCounter
uint64_t	next ()

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

Detailed Description

The TextAtlasManager manages the lifetime of and access to DrawAtlases used in glyph rendering.

Definition at line 29 of file TextAtlasManager.h.

Constructor & Destructor Documentation

TextAtlasManager()

skgpu::graphite::TextAtlasManager::TextAtlasManager

(

Recorder *

recorder

)

Definition at line 28 of file TextAtlasManager.cpp.

        : fRecorder(recorder)
        , fSupportBilerpAtlas{recorder->priv().caps()->supportBilerpFromGlyphAtlas()}
        , fAtlasConfig{recorder->priv().caps()->maxTextureSize(),
                       recorder->priv().caps()->glyphCacheTextureMaximumBytes()} {
    if (!recorder->priv().caps()->allowMultipleAtlasTextures() ||
        // multitexturing supported only if range can represent the index + texcoords fully
        !(recorder->priv().caps()->shaderCaps()->fFloatIs32Bits ||
          recorder->priv().caps()->shaderCaps()->fIntegerSupport)) {
        fAllowMultitexturing = DrawAtlas::AllowMultitexturing::kNo;
    } else {
        fAllowMultitexturing = DrawAtlas::AllowMultitexturing::kYes;
    }
}

~TextAtlasManager()

skgpu::graphite::TextAtlasManager::~TextAtlasManager ( )

default

Member Function Documentation

addGlyphToAtlas()

DrawAtlas::ErrorCode skgpu::graphite::TextAtlasManager::addGlyphToAtlas	(	const SkGlyph &	skGlyph,
		sktext::gpu::Glyph *	glyph,
		int	srcPadding
	)

Definition at line 166 of file TextAtlasManager.cpp.

                                                                       {
#if !defined(SK_DISABLE_SDF_TEXT)
    SkASSERT(0 <= srcPadding && srcPadding <= SK_DistanceFieldInset);
#else
    SkASSERT(0 <= srcPadding);
#endif
 
    if (skGlyph.image() == nullptr) {
        return DrawAtlas::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 DrawAtlas::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);
 
    DrawAtlas* atlas = this->getAtlas(expectedMaskFormat);
    auto errorCode = atlas->addToAtlas(fRecorder,
                                       width,
                                       height,
                                       storage.get(),
                                       &glyph->fAtlasLocator);
 
    if (errorCode == DrawAtlas::ErrorCode::kSucceeded) {
        glyph->fAtlasLocator.insetSrc(srcPadding);
    }
 
    return errorCode;
}

addGlyphToBulkAndSetUseToken()

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

Definition at line 253 of file TextAtlasManager.cpp.

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

atlasGeneration()

uint64_t skgpu::graphite::TextAtlasManager::atlasGeneration ( skgpu::MaskFormat  format ) const

inline

Definition at line 85 of file TextAtlasManager.h.

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

evictAtlases()

void skgpu::graphite::TextAtlasManager::evictAtlases ( )

inline

Definition at line 72 of file TextAtlasManager.h.

                        {
        for (int i = 0; i < kMaskFormatCount; ++i) {
            if (fAtlases[i]) {
                fAtlases[i]->evictAllPlots();
            }
        }
    }

freeAll()

void skgpu::graphite::TextAtlasManager::freeAll

(

)

Definition at line 45 of file TextAtlasManager.cpp.

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

getProxies()

const sk_sp< TextureProxy > * skgpu::graphite::TextAtlasManager::getProxies ( MaskFormat  format, unsigned int *  numActiveProxies  )

inline

Definition at line 37 of file TextAtlasManager.h.

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

hasGlyph()

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

Definition at line 51 of file TextAtlasManager.cpp.

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

postFlush()

void skgpu::graphite::TextAtlasManager::postFlush

(

)

Definition at line 295 of file TextAtlasManager.cpp.

                                 {
    auto tokenTracker = fRecorder->priv().tokenTracker();
    for (int i = 0; i < kMaskFormatCount; ++i) {
        if (fAtlases[i]) {
            fAtlases[i]->compact(tokenTracker->nextFlushToken());
        }
    }
}

recordUploads()

bool skgpu::graphite::TextAtlasManager::recordUploads

(

DrawContext *

dc

)

Definition at line 243 of file TextAtlasManager.cpp.

                                                    {
    for (int i = 0; i < skgpu::kMaskFormatCount; i++) {
        if (fAtlases[i] && !fAtlases[i]->recordUploads(dc, fRecorder)) {
            return false;
        }
    }
 
    return true;
}

setAtlasDimensionsToMinimum_ForTesting()

void skgpu::graphite::TextAtlasManager::setAtlasDimensionsToMinimum_ForTesting

(

)

Definition at line 263 of file TextAtlasManager.cpp.

                                                              {
    // Delete any old atlases.
    // This should be safe to do as long as we are not in the middle of a flush.
    for (int i = 0; i < skgpu::kMaskFormatCount; i++) {
        fAtlases[i] = nullptr;
    }
 
    // Set all the atlas sizes to 1x1 plot each.
    new (&fAtlasConfig) DrawAtlasConfig{2048, 0};
}

setMaxPages_TestingOnly()

void skgpu::graphite::TextAtlasManager::setMaxPages_TestingOnly

(

uint32_t

maxPages

)

setUseTokenBulk()

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

inline

Definition at line 64 of file TextAtlasManager.h.

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

---

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

• third_party/skia/src/gpu/graphite/text/TextAtlasManager.h
• third_party/skia/src/gpu/graphite/text/TextAtlasManager.cpp