Manages glyph data, font atlases, and font-level metrics. More...

#include <font_resources.hpp>

Public Member Functions
	FontResources (RenderResourceContext rrc, TextRenderer *textRenderer, std::string filepath, unsigned int const fontSize)
	Constructs font resources from a font file.

	FontResources (RenderResourceContext rrc, TextRenderer *textRenderer, std::string fontName, std::vector< uint8_t > const &fileBytes, unsigned int const fontSize)
	Constructs font resources from in-memory font data.

	~FontResources ()
	Releases all font-related resources.

void	LoadGlyphsFromCodePointRange (std::uint32_t begin, std::uint32_t end)
	Preloads glyphs for a continuous Unicode range.

void	EnsureGlyphs (const std::vector< std::uint32_t > &codePoints)
	Ensures glyphs for the given Unicode code points exist.

void	EnsureGlyphs (const std::vector< GlyphIndex > &glyphIndexes)
	Ensures glyphs for the given glyph indices exist.

void	StoreFontAtlasesInFiles (bool in)
	Enables or disables storing generated font atlases on disk.

const FontMetrics &	GetFontMetrics () const
	Returns global font metrics.

GlyphMetrics	GetGlyphMetrics (GlyphIndex glyphIndex) const
	Returns metrics for a specific glyph.

std::string	GetFontAtlasTextureName (GlyphIndex glyphIndex) const
	Returns the texture name of the atlas containing the glyph.

std::string	GetFontAtlasMaterialName (GlyphIndex glyphIndex) const
	Returns the material name associated with the glyph.

GlyphIndex	GetIndexFromCodePoint (std::uint32_t codePoint) const
	Resolves a Unicode code point to a glyph index.

FT_Face	GetFontFace ()
	Returns the internal font face handle.

Protected Member Functions
std::pair< GlyphMetrics, ImageData >	CreateGlyphBitmapBy (GlyphIndex glyphIndex)
	Creates a bitmap and metrics for a glyph by index.

std::pair< GlyphMetrics, ImageData >	CreateGlyphBitmapBy (std::uint32_t codePoint)
	Creates a bitmap and metrics for a glyph by code point.

void	CreateFontAtlasFromList (const std::vector< GlyphIndex > &glyphIndexes)
	Creates a font atlas for a list of glyphs.

void	CreateFontAtlasFromRange (std::uint32_t begin, std::uint32_t end)
	Creates a font atlas for a continuous code point range.

bool	HasGlyph (uint32_t codePoint) const
	Checks whether a glyph exists for a code point.

Protected Attributes
RenderResourceContext	mRenderResourceContext

TextRenderer *	mTextRenderer

std::string	mFontName

const unsigned int	mFontSize

FT_Error	mErrorResult = FT_Err_Ok

FT_Face	mFace = 0

FontMetrics	mFontMetrics

std::unordered_map< std::uint32_t, std::pair< GlyphMetrics, std::string > >	mGlyphsByIndex

std::unordered_map< std::string, std::string >	mFontAtlases

std::vector< uint8_t >	mFontFileBytes

bool	bStoreFontAtlasesInFiles = false

Static Protected Attributes
static std::uint32_t	sMaxGlyphsPerFontAtlas = 1024
	Maximum number of glyphs per font atlas.

static unsigned int	sFontAtlasPaddingPx = 4
	Padding in pixels around glyphs inside atlases.

Detailed Description

Manages glyph data, font atlases, and font-level metrics.

Responsible for loading glyphs on demand, generating texture atlases, and providing glyph and font metrics required for text layout and rendering.

Instances are bound to a specific font and font size.

Definition at line 80 of file font_resources.hpp.

Constructor & Destructor Documentation

◆ FontResources() [1/2]

rendering_engine::FontResources::FontResources	(	RenderResourceContext	rrc,
		TextRenderer *	textRenderer,
		std::string	filepath,
		unsigned int const	fontSize
	)

Constructs font resources from a font file.

Parameters

rrc	Rendering resource context.
textRenderer	Owning text renderer.
filepath	Path to the font file.
fontSize	Font size in pixels.

Definition at line 22 of file font_resources.cpp.

    :
    mRenderResourceContext(rrc),
    mTextRenderer(textRenderer),
    mFontName(std::filesystem::path(filepath).stem().string()),
    mFontSize(fontSize),
    mErrorResult(FT_Err_Ok),
    mFace(0)
{
    if (mFontSize >
        static_cast<unsigned int>(
            std::numeric_limits<FT_F26Dot6>::max() >> 6))
    {
        throw std::out_of_range("Font size exceeds FreeType supported range.");
    }
 
    const FT_F26Dot6 fontSize26Dot6 =
        static_cast<FT_F26Dot6>(mFontSize) << 6;
 
    mErrorResult = FT_New_Face(mTextRenderer->GetFontLibrary(), filepath.c_str(), 0, &mFace);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to create new face!" };
    }
 
    mErrorResult = FT_Set_Char_Size(mFace, fontSize26Dot6, fontSize26Dot6, 90, 90);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to set char size!" };
    }
 
    mFontMetrics.lineHeight = FreeType26Dot6ToPixelInt(mFace->size->metrics.height);
    mFontMetrics.ascender = FreeType26Dot6ToPixelInt(mFace->size->metrics.ascender);
    mFontMetrics.descender = FreeType26Dot6ToPixelInt(mFace->size->metrics.descender);
}

◆ FontResources() [2/2]

rendering_engine::FontResources::FontResources	(	RenderResourceContext	rrc,
		TextRenderer *	textRenderer,
		std::string	fontName,
		std::vector< uint8_t > const &	fileBytes,
		unsigned int const	fontSize
	)

Constructs font resources from in-memory font data.

Parameters

rrc	Rendering resource context.
textRenderer	Owning text renderer.
fontName	Logical font name.
fileBytes	Font file data.
fontSize	Font size in pixels.

Definition at line 58 of file font_resources.cpp.

    :
    mRenderResourceContext(rrc),
    mTextRenderer(textRenderer),
    mFontName(fontName),
    mFontSize(fontSize),
    mErrorResult(FT_Err_Ok),
    mFace(0),
    mFontFileBytes(fileBytes)
{
    if (mFontSize >
        static_cast<unsigned int>(
            std::numeric_limits<FT_F26Dot6>::max() >> 6))
    {
        throw std::out_of_range("Font size exceeds FreeType supported range.");
    }
 
    const FT_F26Dot6 fontSize26Dot6 =
        static_cast<FT_F26Dot6>(mFontSize) << 6;
 
    mErrorResult = FT_New_Memory_Face(mTextRenderer->GetFontLibrary(), mFontFileBytes.data(), static_cast<FT_Long>(mFontFileBytes.size()), 0, &mFace);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to create new face!" };
    }
 
    mErrorResult = FT_Set_Char_Size(mFace, fontSize26Dot6, fontSize26Dot6, 90, 90);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to set char size!" };
    }
 
    mFontMetrics.lineHeight = FreeType26Dot6ToPixelInt(mFace->size->metrics.height);
    mFontMetrics.ascender = FreeType26Dot6ToPixelInt(mFace->size->metrics.ascender);
    mFontMetrics.descender = FreeType26Dot6ToPixelInt(mFace->size->metrics.descender);
}

◆ ~FontResources()

rendering_engine::FontResources::~FontResources ( )

Releases all font-related resources.

Definition at line 95 of file font_resources.cpp.

{
    if (mFace)
    {
        FT_Done_Face(mFace);
        mFace = nullptr;
    }
}

Member Function Documentation

◆ CreateFontAtlasFromList()

void rendering_engine::FontResources::CreateFontAtlasFromList ( const std::vector< GlyphIndex > & glyphIndexes )

protected

Creates a font atlas for a list of glyphs.

Parameters

glyphIndexes List of glyph indices.

Definition at line 358 of file font_resources.cpp.

{
    // 1. Create font atlas from list
    std::unordered_map<std::uint32_t, std::pair<GlyphMetrics, ImageData>> glyphs;
    for (auto glyphIndex : glyphIndexes)
    {
        auto found = mGlyphsByIndex.find(glyphIndex.index);
        if (found != mGlyphsByIndex.end())
            continue;
        // Creating bitmaps of glyphs should be considered to dome multithreaded
        glyphs[glyphIndex.index] = CreateGlyphBitmapBy(glyphIndex);
    }
    if (glyphs.empty())
        return;
 
    auto fontAtlas = TextureAtlasMaker::CreateTextureAtlas(glyphs);
 
    // 2. Upload texture via TextureCache
 
    auto textureCache = mRenderResourceContext.textureCache;
    const std::string textureName = mFontName + "_" + std::to_string(mFontSize) + "_FontAtlas_" + std::to_string(mFontAtlases.size());
    if (bStoreFontAtlasesInFiles)
    {
        const std::string fileName = textureName + ".png";
        auto fullPath = Utility::GetContentFolderPath() / fileName;
        fontAtlas.WritePngFile(fullPath.string().c_str());
    }
    textureCache->LoadTexture(textureName, fontAtlas);
 
    // 3. Create a material via MaterialCache and add texture to it
    auto materialCache = mRenderResourceContext.materialCache;
    const std::string materialName = textureName + "_Mat";
    MaterialSettings materialSettings;
    materialSettings.parentMaterialName = std::string{ "Font2D" };
    materialSettings.materialName = materialName;
    materialSettings.materialDomain = MaterialDomain::Sprite2D;
    materialSettings.shadingModel = ShadingModel::Unlit;
    materialSettings.blendMode = BlendMode::Translucent;
    materialSettings.parameterLayout = &Font2DLayout;
 
    materialCache->AddMaterial(materialSettings);
    Material* material = materialCache->GetMaterial(materialName);
    material->SetVec4("FontColor", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    material->SetVec4("OutlineColor", glm::vec4(0, 0, 0, 1));
    material->SetFloat("OutlineThicknessPx", 0.0f); // OFF by default
    const float invW = 1.0f / static_cast<float>(fontAtlas.GetWidth());
    const float invH = 1.0f / static_cast<float>(fontAtlas.GetHeight());
    material->SetFloat("InvAtlasSizeWidth", invW);
    material->SetFloat("InvAtlasSizeHeight", invH);
 
    material->AddTexture(textureName);
 
    // material->SetFloat >> Add custom material parameters for UV manipulation
    material->InitializeRenderResources();
 
    // 4 Upload to container mFontAtlases
    for (auto& it : glyphs)
    {
        mGlyphsByIndex[it.first] = std::pair<GlyphMetrics, std::string>(it.second.first, materialName);
    }
 
    mFontAtlases[materialName] = textureName;
}

◆ CreateFontAtlasFromRange()

void rendering_engine::FontResources::CreateFontAtlasFromRange	(	std::uint32_t	begin,
		std::uint32_t	end
	)

protected

Creates a font atlas for a continuous code point range.

Parameters

begin	First Unicode code point.
end	Last Unicode code point.

Definition at line 229 of file font_resources.cpp.

{
    if (begin > end)
    {
        // range is not valid
        return;
    }
 
    // 1. Create font atlas in range of [begin; end]
    std::unordered_map<std::uint32_t, std::pair<GlyphMetrics, ImageData>> glyphs;
    for (auto codePoint = begin; codePoint <= end; ++codePoint)
    {
        if (!HasGlyph(codePoint))
        {
            continue;
        }
        // Creating bitmaps of glyphs should be considered to dome multythreaded
        glyphs[codePoint] = CreateGlyphBitmapBy(codePoint);
    }
    if (glyphs.empty())
        return;
 
    auto fontAtlas = TextureAtlasMaker::CreateTextureAtlas(glyphs);
 
    // 2. Upload texture via TextureCache
 
    auto textureCache = mRenderResourceContext.textureCache;
    const std::string textureName = mFontName + "_" + std::to_string(mFontSize) + "_FontAtlas_" + std::to_string(mFontAtlases.size());
    if (bStoreFontAtlasesInFiles)
    {
        const std::string fileName = textureName + ".png";
        auto fullPath = Utility::GetContentFolderPath() / fileName;
        fontAtlas.WritePngFile(fullPath.string().c_str());
    }
    textureCache->LoadTexture(textureName, fontAtlas);
 
    // 3. Create a material via MaterialCache and add texture to it
    auto materialCache = mRenderResourceContext.materialCache;
    const std::string materialName = textureName + "_Mat";
    MaterialSettings materialSettings;
    materialSettings.parentMaterialName = std::string{ "Font2D" };
    materialSettings.materialName = materialName;
    materialSettings.materialDomain = MaterialDomain::Sprite2D;
    materialSettings.shadingModel = ShadingModel::Unlit;
    materialSettings.blendMode = BlendMode::Translucent;
    materialSettings.parameterLayout = &Font2DLayout;
 
    materialCache->AddMaterial(materialSettings);
    Material* material = materialCache->GetMaterial(materialName);
    material->SetVec4("FontColor", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    material->SetVec4("OutlineColor", glm::vec4(0, 0, 0, 1));
    material->SetFloat("OutlineThicknessPx", 0.0); // OFF by default
    const float invW = 1.0f / static_cast<float>(fontAtlas.GetWidth());
    const float invH = 1.0f / static_cast<float>(fontAtlas.GetHeight());
    material->SetFloat("InvAtlasSizeWidth", invW);
    material->SetFloat("InvAtlasSizeHeight", invH);
 
    material->AddTexture(textureName);
 
    // material->SetFloat >> Add custom material parameters for UV manipulation
    material->InitializeRenderResources();
 
    // 4 Upload to container mFontAtlases
    for (auto& it : glyphs)
    {
        const std::uint32_t glyphIndex = static_cast<std::uint32_t>(FT_Get_Char_Index(mFace, static_cast<FT_ULong>(it.first)));
        mGlyphsByIndex[glyphIndex] = std::pair<GlyphMetrics, std::string>(it.second.first, materialName);
    }
 
    mFontAtlases[materialName] = textureName;
}

◆ CreateGlyphBitmapBy() [1/2]

std::pair< GlyphMetrics, ImageData > rendering_engine::FontResources::CreateGlyphBitmapBy ( GlyphIndex glyphIndex )

protected

Creates a bitmap and metrics for a glyph by index.

Parameters

glyphIndex Glyph identifier.

Returns: Pair of glyph metrics and image data.

Definition at line 156 of file font_resources.cpp.

{
    mErrorResult = FT_Load_Glyph(mFace, glyphIndex.index, FT_LOAD_DEFAULT);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to load glyph!" };
    }
 
    mErrorResult = FT_Render_Glyph(mFace->glyph, FT_RENDER_MODE_NORMAL);
    if (mErrorResult)
    {
        throw std::runtime_error{ "Failed to render glyph!" };
    }
 
    const unsigned padding = sFontAtlasPaddingPx;
 
    const auto srcW = mFace->glyph->bitmap.width;
    const auto srcH = mFace->glyph->bitmap.rows;
 
    const auto dstW = srcW + padding * 2;
    const auto dstH = srcH + padding * 2;
 
    const auto bufferSize = dstW * dstH * 4;
    std::vector<uint8_t> buffer(bufferSize, 0);
    for (unsigned int y = 0; y < srcH; ++y)
    {
        for (unsigned int x = 0; x < srcW; ++x)
        {
            const size_t srcIndex =
                static_cast<size_t>(y) * static_cast<size_t>(srcW) +
                static_cast<size_t>(x);
 
            const uint8_t coverage =
                mFace->glyph->bitmap.buffer[srcIndex];
 
            const size_t dstX =
                static_cast<size_t>(x) + static_cast<size_t>(padding);
 
            const size_t dstY =
                static_cast<size_t>(y) + static_cast<size_t>(padding);
 
            const size_t idx =
                (dstY * static_cast<size_t>(dstW) + dstX) * 4U;
 
            buffer[idx + 0] = coverage;
            buffer[idx + 1] = coverage;
            buffer[idx + 2] = coverage;
            buffer[idx + 3] = coverage;
        }
    }
    GlyphMetrics glyphMetrics;
    glyphMetrics.width =  srcW;
    glyphMetrics.height = srcH;
 
 
    glyphMetrics.bearingX = mFace->glyph->bitmap_left;
    glyphMetrics.bearingY = mFace->glyph->bitmap_top;
 
    glyphMetrics.advanceX = FreeType26Dot6ToPixelInt(mFace->glyph->advance.x);
 
    glyphMetrics.padding = padding;
 
    return std::pair(glyphMetrics, ImageData(dstW, dstH, buffer));
}

◆ CreateGlyphBitmapBy() [2/2]

std::pair< GlyphMetrics, ImageData > rendering_engine::FontResources::CreateGlyphBitmapBy ( std::uint32_t codePoint )

protected

Creates a bitmap and metrics for a glyph by code point.

Parameters

codePoint Unicode code point.

Returns: Pair of glyph metrics and image data.

Definition at line 221 of file font_resources.cpp.

{
    GlyphIndex glyphIndex;
    glyphIndex.index = static_cast<std::uint32_t>(FT_Get_Char_Index(mFace, static_cast<FT_ULong>(codePoint)));
 
    return CreateGlyphBitmapBy(glyphIndex);
}

◆ EnsureGlyphs() [1/2]

void rendering_engine::FontResources::EnsureGlyphs ( const std::vector< GlyphIndex > & glyphIndexes )

Ensures glyphs for the given glyph indices exist.

Parameters

glyphIndexes List of glyph indices.

Definition at line 129 of file font_resources.cpp.

{
    if (glyphIndexes.empty())
        return;
 
    std::vector<GlyphIndex> lackingGlyphs;
    for (const auto& glyphIndex : glyphIndexes)
    {
        auto found = mGlyphsByIndex.find(glyphIndex.index);
        if (found == mGlyphsByIndex.end())
        {
            GlyphIndex gi;
            gi.index = glyphIndex.index;
            lackingGlyphs.push_back(gi);
        }
    }
    if (!lackingGlyphs.empty())
    {
        CreateFontAtlasFromList(lackingGlyphs);
    }
}

◆ EnsureGlyphs() [2/2]

void rendering_engine::FontResources::EnsureGlyphs ( const std::vector< std::uint32_t > & codePoints )

Ensures glyphs for the given Unicode code points exist.

Parameters

codePoints List of Unicode code points.

Definition at line 115 of file font_resources.cpp.

{
    if (codePoints.empty())
        return;
 
    std::vector<GlyphIndex> glyphs;
    for (auto codePoint : codePoints)
    {
        glyphs.push_back(GetIndexFromCodePoint(codePoint));
    }
 
    EnsureGlyphs(glyphs);
}

◆ GetFontAtlasMaterialName()

std::string rendering_engine::FontResources::GetFontAtlasMaterialName ( GlyphIndex glyphIndex ) const

Returns the material name associated with the glyph.

Parameters

glyphIndex Glyph identifier.

Returns: Material name or empty string if unavailable.

Definition at line 336 of file font_resources.cpp.

{
    auto search = mGlyphsByIndex.find(glyphIndex.index);
    if (search == mGlyphsByIndex.end())
    {
        return std::string();
    }
    return search->second.second;
}

◆ GetFontAtlasTextureName()

std::string rendering_engine::FontResources::GetFontAtlasTextureName ( GlyphIndex glyphIndex ) const

Returns the texture name of the atlas containing the glyph.

Parameters

glyphIndex Glyph identifier.

Returns: Texture name or empty string if unavailable.

Definition at line 321 of file font_resources.cpp.

{
    auto matName = GetFontAtlasMaterialName(glyphIndex);
    if (matName.empty())
    {
        return std::string();
    }
    auto search = mFontAtlases.find(matName);
    if(search == mFontAtlases.end())
    {
        return std::string();
    }
    return search->second;
}

◆ GetFontFace()

FT_Face rendering_engine::FontResources::GetFontFace ( )

Returns the internal font face handle.

Note: Intended for internal use only.

Definition at line 353 of file font_resources.cpp.

{
    return mFace;
}

◆ GetFontMetrics()

const FontMetrics & rendering_engine::FontResources::GetFontMetrics ( ) const

Returns global font metrics.

Returns: Font metrics.

Definition at line 306 of file font_resources.cpp.

{
    return mFontMetrics;
}

◆ GetGlyphMetrics()

GlyphMetrics rendering_engine::FontResources::GetGlyphMetrics ( GlyphIndex glyphIndex ) const

Returns metrics for a specific glyph.

Parameters

glyphIndex Glyph identifier.

Returns: Glyph metrics or default-initialized metrics if unavailable.

Definition at line 311 of file font_resources.cpp.

{
    auto search = mGlyphsByIndex.find(glyphIndex.index);
    if (search == mGlyphsByIndex.end())
    {
        return GlyphMetrics();
    }
    return search->second.first;
}

◆ GetIndexFromCodePoint()

GlyphIndex rendering_engine::FontResources::GetIndexFromCodePoint ( std::uint32_t codePoint ) const

Resolves a Unicode code point to a glyph index.

Parameters

codePoint Unicode code point.

Returns: Glyph index.

Definition at line 346 of file font_resources.cpp.

{
    GlyphIndex result;
    result.index = FT_Get_Char_Index(mFace, codePoint);
    return result;
}

◆ HasGlyph()

bool rendering_engine::FontResources::HasGlyph ( uint32_t codePoint ) const

protected

Checks whether a glyph exists for a code point.

Parameters

codePoint Unicode code point.

Returns: True if the glyph exists.

Definition at line 301 of file font_resources.cpp.

{
    return FT_Get_Char_Index(mFace, codePoint) != 0;
}

◆ LoadGlyphsFromCodePointRange()

void rendering_engine::FontResources::LoadGlyphsFromCodePointRange	(	std::uint32_t	begin,
		std::uint32_t	end
	)

Preloads glyphs for a continuous Unicode range.

Parameters

begin	First Unicode code point.
end	Last Unicode code point.

Definition at line 104 of file font_resources.cpp.

{
    std::uint32_t start = begin;
    while (start < end) 
    {
        std::uint32_t currentEnd = std::min(start + sMaxGlyphsPerFontAtlas - 1, end);
        CreateFontAtlasFromRange(start, currentEnd);
        start += sMaxGlyphsPerFontAtlas;
    } 
}

◆ StoreFontAtlasesInFiles()

void rendering_engine::FontResources::StoreFontAtlasesInFiles ( bool in )

Enables or disables storing generated font atlases on disk.

Parameters

in	True to store atlases in files.

Definition at line 151 of file font_resources.cpp.

{
    bStoreFontAtlasesInFiles = in;
}

Member Data Documentation

◆ bStoreFontAtlasesInFiles

bool rendering_engine::FontResources::bStoreFontAtlasesInFiles = false

protected

Definition at line 235 of file font_resources.hpp.

◆ mErrorResult

FT_Error rendering_engine::FontResources::mErrorResult = FT_Err_Ok

protected

Definition at line 219 of file font_resources.hpp.

◆ mFace

FT_Face rendering_engine::FontResources::mFace = 0

protected

Definition at line 220 of file font_resources.hpp.

◆ mFontAtlases

std::unordered_map<std::string, std::string> rendering_engine::FontResources::mFontAtlases

protected

Definition at line 231 of file font_resources.hpp.

◆ mFontFileBytes

std::vector<uint8_t> rendering_engine::FontResources::mFontFileBytes

protected

Definition at line 233 of file font_resources.hpp.

◆ mFontMetrics

FontMetrics rendering_engine::FontResources::mFontMetrics

protected

Definition at line 222 of file font_resources.hpp.

◆ mFontName

std::string rendering_engine::FontResources::mFontName

protected

Definition at line 216 of file font_resources.hpp.

◆ mFontSize

const unsigned int rendering_engine::FontResources::mFontSize

protected

Definition at line 217 of file font_resources.hpp.

◆ mGlyphsByIndex

std::unordered_map<std::uint32_t, std::pair<GlyphMetrics, std::string> > rendering_engine::FontResources::mGlyphsByIndex

protected

Definition at line 228 of file font_resources.hpp.

◆ mRenderResourceContext

RenderResourceContext rendering_engine::FontResources::mRenderResourceContext

protected

Definition at line 214 of file font_resources.hpp.

◆ mTextRenderer

TextRenderer* rendering_engine::FontResources::mTextRenderer

protected

Definition at line 215 of file font_resources.hpp.

◆ sFontAtlasPaddingPx

unsigned int rendering_engine::FontResources::sFontAtlasPaddingPx = 4

staticprotected

Padding in pixels around glyphs inside atlases.

Definition at line 240 of file font_resources.hpp.

◆ sMaxGlyphsPerFontAtlas

std::uint32_t rendering_engine::FontResources::sMaxGlyphsPerFontAtlas = 1024

staticprotected

Maximum number of glyphs per font atlas.

Definition at line 238 of file font_resources.hpp.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FontResources() [1/2]

◆ FontResources() [2/2]

◆ ~FontResources()

Member Function Documentation

◆ CreateFontAtlasFromList()

◆ CreateFontAtlasFromRange()

◆ CreateGlyphBitmapBy() [1/2]

◆ CreateGlyphBitmapBy() [2/2]

◆ EnsureGlyphs() [1/2]

◆ EnsureGlyphs() [2/2]

◆ GetFontAtlasMaterialName()

◆ GetFontAtlasTextureName()

◆ GetFontFace()

◆ GetFontMetrics()

◆ GetGlyphMetrics()

◆ GetIndexFromCodePoint()

◆ HasGlyph()

◆ LoadGlyphsFromCodePointRange()

◆ StoreFontAtlasesInFiles()

Member Data Documentation

◆ bStoreFontAtlasesInFiles

◆ mErrorResult

◆ mFace

◆ mFontAtlases

◆ mFontFileBytes

◆ mFontMetrics

◆ mFontName

◆ mFontSize

◆ mGlyphsByIndex

◆ mRenderResourceContext

◆ mTextRenderer

◆ sFontAtlasPaddingPx

◆ sMaxGlyphsPerFontAtlas