rendering_engine::TextRenderer Class Reference

Central text system manager and font resource registry. More...

#include <text_renderer.hpp>

Public Member Functions
	TextRenderer (RenderResourceContext rrc)
	Constructs the text renderer and initializes internal font systems.
	~TextRenderer ()
	Shuts down the text system and releases font backend resources.
void	LoadFontsFromFolder (std::string pathToFolder)
	Loads fonts from a filesystem folder.
void	LoadFontsFromPackage ()
	Loads fonts bundled inside an application package.
const RenderResourceContext &	GetRenderResourceContext () const
	Returns the rendering resource context.
std::shared_ptr< FontResources >	GetFontResources (const std::string &fontName, unsigned int fontSize)
	Retrieves or creates font resources for a font and size.
void	StoreFontAtlasesInFiles (bool in)
	Enables or disables storing generated font atlases to files.
const std::vector< std::string > &	GetScriptsRequiredShaping () const
	Returns scripts that require shaping before rendering.
std::pair< std::uint32_t, std::uint32_t >	GetScriptRange (std::string script)
	Returns the Unicode codepoint range for a script.
FT_Library &	GetFontLibrary ()
	Returns the internal FreeType library instance.
void	Shutdown ()

Protected Member Functions
void	LoadFontsAvailableInFolder (std::string pathToFolder)
	Discovers fonts available in a filesystem folder.
void	LoadPreloadableFontAtlasesFromFolder (const std::unordered_map< std::string, std::string > &availableFontsInFolder)
	Loads preloadable font atlases from a folder.
void	LoadFontsAvailableInPackage ()
	Discovers fonts available in the application package.
void	LoadPreloadableFontAtlasesFromPackage (const std::unordered_map< std::string, std::string > &availableFontsInPackage)
	Loads preloadable font atlases from the application package.

Detailed Description

Central text system manager and font resource registry.

Owns the font backend instance, manages font discovery and caching, defines script metadata, and coordinates font atlas preloading based on application configuration.

Definition at line 36 of file text_renderer.hpp.

Constructor & Destructor Documentation

TextRenderer()

rendering_engine::TextRenderer::TextRenderer

(

RenderResourceContext

rrc

)

Constructs the text renderer and initializes internal font systems.

Parameters

rrc	Rendering resource context.

This object owns the lifetime of the font backend and must outlive all font resources created through it.

Definition at line 95 of file text_renderer.cpp.

    :
    mRenderResourceContext(rrc)
{
    LOG_INFO("Initializing TextRenderer...");
    auto start = std::chrono::steady_clock::now();
 
    mErrorResult = FT_Init_FreeType(&mLibrary);
    if (mErrorResult)
    {
        LOG_ERROR("Failed to initialize FreeType library!");
        throw std::runtime_error{ "Failed to initialize FreeType library!" };
    }
 
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("FreeType initialized in " + std::to_string(ms) + " ms.");
}

~TextRenderer()

rendering_engine::TextRenderer::~TextRenderer

(

)

Shuts down the text system and releases font backend resources.

All FontResources obtained from this renderer must be destroyed before the renderer itself.

Definition at line 115 of file text_renderer.cpp.

{
}

Member Function Documentation

GetFontLibrary()

FT_Library & rendering_engine::TextRenderer::GetFontLibrary ( )

inline

Returns the internal FreeType library instance.

Returns

Reference to FT_Library.

Definition at line 99 of file text_renderer.hpp.

    {
        return mLibrary;
    }

GetFontResources()

std::shared_ptr< FontResources > rendering_engine::TextRenderer::GetFontResources	(	const std::string &	fontName,
		unsigned int	fontSize
	)

Retrieves or creates font resources for a font and size.

If the requested font resources are not yet loaded, they will be created on demand from available font sources.

Parameters

fontName	Font family name.
fontSize	Font size in pixels.

Returns

Shared pointer to font resources, or nullptr if unavailable.

Definition at line 159 of file text_renderer.cpp.

{
    auto key = std::make_pair(fontName, fontSize);
    if (auto search = mFontResources.find(key); search != mFontResources.end())
    {
        return search->second;
    }
    else
    {
        if (!mAvailableFontsInPackage.empty())
        {
            if (!mAvailableFontsInPackage.empty())
            {
                auto foundInPackage = mAvailableFontsInPackage.find(fontName);
                if (foundInPackage != mAvailableFontsInPackage.end())
                {
                    const std::string virtualFilePath = mAvailableFontsInPackage[fontName];
                    std::vector<uint8_t> binaryFileData = Utility::ReadPackedFile(virtualFilePath);
 
                    mFontResources[key] = std::make_shared<FontResources>(mRenderResourceContext, this, fontName, binaryFileData, fontSize);
                    mFontResources[key]->StoreFontAtlasesInFiles(bStoreFontAtlasesInFiles);
 
                    return mFontResources[key];
                }
                else
                {
                    // Log Font {fontName} is not avalable in asset package
                }
            }
        }
        else
        {
            if (!mAvailableFontsInFolder.empty())
            {
                auto foundInFolder = mAvailableFontsInFolder.find(fontName);
                if (foundInFolder != mAvailableFontsInFolder.end())
                {
                    mFontResources[key] = std::make_shared<FontResources>(mRenderResourceContext, this, mAvailableFontsInFolder[fontName], fontSize);
 
                    return mFontResources[key];
                }
                else
                {
                    // Log Font {fontName} is not avalable in asset folder
                }
            }
        }
    }
 
    return nullptr;
}

GetRenderResourceContext()

const RenderResourceContext & rendering_engine::TextRenderer::GetRenderResourceContext

(

)

const

Returns the rendering resource context.

Returns

Reference to the rendering resource context.

Definition at line 154 of file text_renderer.cpp.

{
    return mRenderResourceContext;
}

GetScriptRange()

std::pair< std::uint32_t, std::uint32_t > rendering_engine::TextRenderer::GetScriptRange

(

std::string

script

)

Returns the Unicode codepoint range for a script.

Parameters

script

Script identifier.

Returns

Pair of <begin, end> Unicode codepoints.

Definition at line 221 of file text_renderer.cpp.

{
    std::pair<std::uint32_t, std::uint32_t> result{ 0U, 0U };
 
    auto search = sScriptRanges.find(script);
    {
        if (search != sScriptRanges.end())
            return sScriptRanges[script];
    }
    return result;
}

GetScriptsRequiredShaping()

const std::vector< std::string > & rendering_engine::TextRenderer::GetScriptsRequiredShaping

(

)

const

Returns scripts that require shaping before rendering.

Returns

List of script identifiers.

Definition at line 216 of file text_renderer.cpp.

{
    return sScriptsRequiresShaping;
}

LoadFontsAvailableInFolder()

void rendering_engine::TextRenderer::LoadFontsAvailableInFolder ( std::string  pathToFolder )

protected

Discovers fonts available in a filesystem folder.

Parameters

pathToFolder

Path to the font folder.

Definition at line 233 of file text_renderer.cpp.

{
    LOG_INFO("Scanning font folder: " + pathToFolder);
    // 1. Check if path is valid and exist
    std::filesystem::path pathToDirectory = std::filesystem::path(pathToFolder);
    const bool isValidFolderPath = std::filesystem::exists(std::filesystem::path(pathToFolder)) && std::filesystem::is_directory(std::filesystem::path(pathToFolder));
    if (!isValidFolderPath)
    {
        return;
    }
    // 2. Iterate through files in the folder.
    //    if file is in the list of supported extensions
    for (std::filesystem::recursive_directory_iterator it(pathToDirectory), end;
        it != end;
        ++it)
    {
        const std::filesystem::path& filePath = it->path();
 
        if (!std::filesystem::is_regular_file(filePath))
            continue;
 
        const std::string ext = filePath.extension().string();
        if (ext != ".ttf" && ext != ".otf")
            continue;
 
        // Fonts name and file path stored for future runtime loading
        std::string fontName = filePath.stem().string();
        mAvailableFontsInFolder[fontName] = filePath.string();
    }
    LOG_INFO("Discovered " +
        std::to_string(mAvailableFontsInFolder.size()) +
        " fonts in folder.");
}

LoadFontsAvailableInPackage()

void rendering_engine::TextRenderer::LoadFontsAvailableInPackage ( )

protected

Discovers fonts available in the application package.

Definition at line 308 of file text_renderer.cpp.

{
    LOG_INFO("Scanning fonts in package...");
    const auto& entries = Utility::GetPackEntries();
 
    std::string folderEntry = { "Fonts/" };
    for (auto& entry : entries)
    {
        const std::string& virtualPath = entry.first;
        if (virtualPath.rfind(folderEntry, 0) == 0) // starts with Fonts/
        {
            auto fontFilePath = std::filesystem::path(virtualPath);
            const std::string ext = fontFilePath.extension().string();
            if (ext != ".ttf" && ext != ".otf")
                continue;
 
            // Fonts name and virtual path stored for future runtime loading
            std::string fontName = fontFilePath.stem().string();
            mAvailableFontsInPackage[fontName] = fontFilePath.string();
        }
    }
    LOG_INFO("Discovered " +
        std::to_string(mAvailableFontsInPackage.size()) +
        " fonts in package.");
}

LoadFontsFromFolder()

void rendering_engine::TextRenderer::LoadFontsFromFolder

(

std::string

pathToFolder

)

Loads fonts from a filesystem folder.

Parameters

pathToFolder

Path to the folder containing font files.

Definition at line 135 of file text_renderer.cpp.

{
    LOG_INFO("Loading fonts from folder: " + pathToFolder);
    auto start = std::chrono::steady_clock::now();
    LoadFontsAvailableInFolder(pathToFolder);
    LoadPreloadableFontAtlasesFromFolder(mAvailableFontsInFolder);
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Font discovery and preload complete in " +
        std::to_string(ms) + " ms.");
}

LoadFontsFromPackage()

void rendering_engine::TextRenderer::LoadFontsFromPackage

(

)

Loads fonts bundled inside an application package.

Definition at line 148 of file text_renderer.cpp.

{
    LoadFontsAvailableInPackage();
    LoadPreloadableFontAtlasesFromPackage(mAvailableFontsInPackage);
}

LoadPreloadableFontAtlasesFromFolder()

void rendering_engine::TextRenderer::LoadPreloadableFontAtlasesFromFolder ( const std::unordered_map< std::string, std::string > &  availableFontsInFolder )

protected

Loads preloadable font atlases from a folder.

Parameters

availableFontsInFolder

Map of font names to file paths.

Definition at line 267 of file text_renderer.cpp.

{
    LOG_INFO("Preloading font atlases from folder...");
    auto start = std::chrono::steady_clock::now();
    AppConfig appConfig = Utility::ReadConfigFile();
 
    for (const auto& [fontName, filePath] : availableFontsInFolder)
    {
        for (auto requestedScript : appConfig.textScripts)
        {
            auto preloadableScriptIt = std::find(sFontAtlasPreloadableScripts.begin(), sFontAtlasPreloadableScripts.end(), requestedScript);
            if (preloadableScriptIt != sFontAtlasPreloadableScripts.end())
            {
                for (auto fontSize : appConfig.fontSizePreload)
                {
                    auto key = std::make_pair(fontName, fontSize);
                    if (mFontResources.find(key) == mFontResources.end())
                    {
                        LOG_DEBUG("Creating font resource: " + fontName +
                            " size " + std::to_string(fontSize));
                        mFontResources[key] = std::make_shared<FontResources>(mRenderResourceContext, this, filePath, fontSize);
                        mFontResources[key]->StoreFontAtlasesInFiles(bStoreFontAtlasesInFiles);
                    }
                    LOG_DEBUG("Preloading script '" + requestedScript +
                        "' for font " + fontName +
                        " size " + std::to_string(fontSize));
                    const std::uint32_t rangeBegin = sScriptRanges[requestedScript].first;
                    const std::uint32_t rangeEnd = sScriptRanges[requestedScript].second;
                    mFontResources[key]->LoadGlyphsFromCodePointRange(rangeBegin, rangeEnd);
                }
            }
        }
    }
 
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Font atlas preloading (folder) completed in " +
        std::to_string(ms) + " ms.");
}

LoadPreloadableFontAtlasesFromPackage()

void rendering_engine::TextRenderer::LoadPreloadableFontAtlasesFromPackage ( const std::unordered_map< std::string, std::string > &  availableFontsInPackage )

protected

Loads preloadable font atlases from the application package.

Parameters

availableFontsInPackage

Map of font names to package paths.

Definition at line 334 of file text_renderer.cpp.

{
    LOG_INFO("Preloading font atlases from package...");
    auto start = std::chrono::steady_clock::now();
    AppConfig appConfig = Utility::ReadConfigFile();
 
    for (const auto& [fontName, virtualFilePath] : availableFontsInPackage)
    {
        for (auto requestedScript : appConfig.textScripts)
        {
            auto preloadableScriptIt = std::find(sFontAtlasPreloadableScripts.begin(), sFontAtlasPreloadableScripts.end(), requestedScript);
            if (preloadableScriptIt != sFontAtlasPreloadableScripts.end())
            {
                for (auto fontSize : appConfig.fontSizePreload)
                {
                    auto key = std::make_pair(fontName, fontSize);
                    if (mFontResources.find(key) == mFontResources.end())
                    {
                        std::vector<uint8_t> binaryFileData = Utility::ReadPackedFile(virtualFilePath);
                        LOG_DEBUG("Creating font resource: " + fontName +
                            " size " + std::to_string(fontSize));
                        mFontResources[key] = std::make_shared<FontResources>(mRenderResourceContext, this, fontName, binaryFileData, fontSize);
                        mFontResources[key]->StoreFontAtlasesInFiles(bStoreFontAtlasesInFiles);
                    }
                    LOG_DEBUG("Preloading script '" + requestedScript +
                        "' for font " + fontName +
                        " size " + std::to_string(fontSize));
                    const std::uint32_t rangeBegin = sScriptRanges[requestedScript].first;
                    const std::uint32_t rangeEnd = sScriptRanges[requestedScript].second;
                    mFontResources[key]->LoadGlyphsFromCodePointRange(rangeBegin, rangeEnd);
                }
            }
        }
    }
 
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Font atlas preloading (package) completed in " +
        std::to_string(ms) + " ms.");
}

Shutdown()

void rendering_engine::TextRenderer::Shutdown

(

)

Definition at line 119 of file text_renderer.cpp.

{
    LOG_INFO("Shutting down TextRenderer...");
    if (!mLibrary)
        return;
 
    for (auto& fontResource : mFontResources)
        fontResource.second.reset();
 
    mFontResources.clear();
 
    FT_Done_FreeType(mLibrary);
    mLibrary = nullptr;
    LOG_INFO("TextRenderer shutdown complete.");
}

StoreFontAtlasesInFiles()

void rendering_engine::TextRenderer::StoreFontAtlasesInFiles

(

bool

in

)

Enables or disables storing generated font atlases to files.

Parameters

in	True to store atlases on disk.

Definition at line 211 of file text_renderer.cpp.

{
    bStoreFontAtlasesInFiles = in;
}

---

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

• text_renderer.hpp
• text_renderer.cpp