rendering_engine::TextBlock2D Class Reference

2D drawable representing a block of rendered text. More...

#include <text_block_2d.hpp>

Inherits rendering_engine::Drawable2D.

Classes
struct	GlyphQuad
	Renderable quad representing a single glyph. More...
struct	Mesh
	CPU-side mesh data for glyph quads. More...
struct	Properties
struct	ShapedGlyph
	Result of text shaping for a single glyph. More...

Public Member Functions
	TextBlock2D (Scene &scene, std::shared_ptr< TextRenderer > textRenderer, Properties properties=Properties())
	Constructs a 2D text block.
void	Initialize () override
	Initializes render resource pointers (material, mesh, etc.). Must be called after setting material and mesh names.
void	Update (float deltaTime) override
	Updates logic (animation, movement, etc.) for this drawable.
void	Draw (const Camera2D &camera) override
	Submits this quad to the renderer for drawing.
virtual void	SetText (std::string text)
	Sets the displayed text.
void	SetTextColor (glm::vec4 color)
	Sets the text color.
void	SetOutlineColor (glm::vec4 color)
	Sets the outline color.
glm::vec2	GetDimensions () const
	Returns text block dimensions.
template<>
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< std::uint32_t > &glyphs)
template<>
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< ShapedGlyph > &glyphs)
template<>
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< std::uint32_t > &glyphs)
template<>
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< ShapedGlyph > &glyphs)
Public Member Functions inherited from rendering_engine::Drawable2D
	Drawable2D (RenderResourceContext renderContext, Scene &scene)
	Constructs the Drawable2D with a resource context.
void	SetPosition (const glm::vec2 &position)
	Sets the quad position in 2D space.
void	SetRotation (float angleDegrees)
	Sets the quad rotation.
void	SetScale (const glm::vec2 &scale)
	Sets the quad scale along each axis.
const glm::vec2 &	GetPosition () const
	Gets the quad position.
float	GetRotation () const
	Gets the quad rotation angle (degrees).
const glm::vec2 &	GetScale () const
	Gets the quad scale.
SceneComponent2D &	GetTransform ()
	Access to the underlying SceneComponent2D (transform).
const SceneComponent2D &	GetTransform () const
void	Destroy () override
	Requests destruction of this drawable.
Public Member Functions inherited from rendering_engine::DrawableComponent
	DrawableComponent (RenderResourceContext renderContext, Scene &scene)
	Constructs the DrawableComponent with a resource context.
virtual	~DrawableComponent ()=default
	Virtual destructor.
virtual void	Shutdown ()
	Releases all render resources owned by this drawable.
void	UpdateOnTick (bool in)
	DrawableComponent (const DrawableComponent &)=delete
DrawableComponent &	operator= (const DrawableComponent &)=delete

Protected Member Functions
std::vector< std::uint32_t >	DecodeUtf8 (const std::string &text)
	Decodes a UTF-8 string into Unicode code points.
std::string	CodepointToUtf8 (std::uint32_t codePoint)
	Converts a Unicode code point to UTF-8.
std::vector< ShapedGlyph >	ShapeText (const std::string &text)
	Shapes text and returns shaped glyphs.
void	ConstructMeshAutoLinebreak (const std::vector< std::uint32_t > &codePoints)
void	ConstructMesh ()
	Constructs glyph geometry without shaping.
void	ShapeTextAndConstructMesh ()
	Shapes text and constructs glyph geometry.
GlyphQuad	MakeGlyphQuad (GlyphIndex glyphIndext, float penX, float penY)
	Creates a glyph quad at the current pen position.
void	PushQuad (std::unordered_map< std::string, TextBlock2D::Mesh > &meshes, GlyphQuad glyphQuad, float horizontalShift=0.0f)
	Appends a glyph quad to a mesh.
void	UploadMeshes (const std::unordered_map< std::string, TextBlock2D::Mesh > &meshes)
	Uploads prepared meshes to GPU resources.
void	SetOutlineThickness (float thicknessPx)
	Sets outline thickness for all render batches.
template<typename T >
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< T > &glyphs)
	Prepares mesh slots based on glyph usage.
std::vector< std::string >	SplitString (const std::string &text, std::string separator)
	Splits a string by a separator.
bool	IsTextShapingRequired (std::uint32_t codePoint) const
	Checks whether shaping is required for a code point.
Protected Member Functions inherited from rendering_engine::DrawableComponent
void	AddRenderBatch (std::string meshName, std::string materialName)

Protected Attributes
std::unordered_map< std::string, std::string >	mMaterialMesh
const std::shared_ptr< TextRenderer >	mTextRenderer
std::shared_ptr< FontResources >	mFontResources
glm::vec4	mColor
const std::string	mFontName
const unsigned int	mFontSize
float	mLineSpacingScale = 1.0f
std::string	mText
float	mMaxLineLength = 0.0f
const TextAlign	mTextAlign
glm::vec2	mDimensions
const bool	bIsTextShapeEnabled
const float	mOutlineThicknessPx
Protected Attributes inherited from rendering_engine::Drawable2D
SceneComponent2D	mSceneComponent
Protected Attributes inherited from rendering_engine::DrawableComponent
RenderResourceContext	mRenderContext
Scene &	mScene
std::vector< RenderBatch >	mRenderBatches
bool	bUpdateOnTick

Static Protected Attributes
static std::string	sDefaultFontName = "RobotoMono-Regular"

Detailed Description

2D drawable representing a block of rendered text.

Converts UTF-8 text into glyph quads, performs layout and alignment, and submits render batches using font atlas materials.

A TextBlock2D instance is bound to a single font and font size.

Definition at line 52 of file text_block_2d.hpp.

Constructor & Destructor Documentation

TextBlock2D()

rendering_engine::TextBlock2D::TextBlock2D	(	Scene &	scene,
		std::shared_ptr< TextRenderer >	textRenderer,
		Properties	properties = Properties()
	)

Constructs a 2D text block.

Parameters

textRenderer	Owning text renderer.
properties	Text block configuration.

Definition at line 41 of file text_block_2d.cpp.

    :
    Drawable2D(textRenderer->GetRenderResourceContext(), scene),
    mTextRenderer(textRenderer),
    mColor(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)),
    mFontName(properties.fontName),
    mFontSize(properties.fontSize),
    mLineSpacingScale(properties.lineSpacingScale),
    mMaxLineLength(properties.maxLineLength),
    mTextAlign(properties.textAlign),
    mDimensions(glm::vec2(0.0f, 0.0f)),
    bIsTextShapeEnabled(properties.textShapeEnabled),
    mOutlineThicknessPx(properties.outlineThicknessPx > 2.0f ? 2.0f : properties.outlineThicknessPx)
{
    mFontResources = mTextRenderer->GetFontResources(mFontName, mFontSize);
    if (!mFontResources)
    {
        throw std::runtime_error("FontResources is not initialized for this TextBlock2D.");
    }
 
    ++sNumOfTextBlocks;
    mTextBlockID = "TextBlock_" + std::to_string(sNumOfTextBlocks);
}

Member Function Documentation

CodepointToUtf8()

std::string rendering_engine::TextBlock2D::CodepointToUtf8 ( std::uint32_t  codePoint )

protected

Converts a Unicode code point to UTF-8.

Parameters

codePoint

Unicode code point.

Returns

UTF-8 encoded string.

Definition at line 644 of file text_block_2d.cpp.

{
    std::string out;
 
    if (codePoint <= 0x7F) {
        out.push_back(static_cast<char>(codePoint));
    }
    else if (codePoint <= 0x7FF) {
        out.push_back(static_cast<char>(0xC0 | ((codePoint >> 6) & 0x1F)));
        out.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
    }
    else if (codePoint <= 0xFFFF) {
        out.push_back(static_cast<char>(0xE0 | ((codePoint >> 12) & 0x0F)));
        out.push_back(static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
    }
    else if (codePoint <= 0x10FFFF) {
        out.push_back(static_cast<char>(0xF0 | ((codePoint >> 18) & 0x07)));
        out.push_back(static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
    }
 
    return out;
}

ConstructMesh()

void rendering_engine::TextBlock2D::ConstructMesh ( )

protected

Constructs glyph geometry without shaping.

Definition at line 324 of file text_block_2d.cpp.

{
    std::vector<std::uint32_t> allUsedGlyphs;
    std::vector<std::vector<std::uint32_t>> linesOfGlyphs;
 
    auto textRuns = SplitString(mText, "\n");
 
    for (const auto& textRunString : textRuns)
    {
        auto textRunCodePoints = DecodeUtf8(textRunString);
        linesOfGlyphs.push_back(textRunCodePoints);
        std::copy(textRunCodePoints.begin(), textRunCodePoints.end(), std::back_inserter(allUsedGlyphs));
    }
    // It is better to ensure all required glyphs at once, as those if not ready yet,
    // will be added to a single font atlas
    mFontResources->EnsureGlyphs(allUsedGlyphs);
    auto meshes = PrepareMeshSlots(allUsedGlyphs);
 
 
    float maximumLineLengh = 0.0f;
    std::vector<float> lineLengths;
 
    std::vector<std::vector<GlyphQuad>> linesOfGlyphQuads;
 
    const FontMetrics& fontMetrics = mFontResources->GetFontMetrics();
    const float lineHeight = static_cast<float>(fontMetrics.lineHeight);
 
    float penX = 0.0f;
    float penY = 0.0f;
 
    for (auto line : linesOfGlyphs)
    {
        penX = 0.0f;
        std::vector<GlyphQuad> lineOfGlyphQuads;
        for (const auto& glyph : line)
        {
            GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(glyph);
            GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX, penY);
 
            penX += static_cast<float>(glyphQuad.advanceX);
            lineOfGlyphQuads.push_back(glyphQuad);
        }
 
        lineLengths.push_back(penX);
        linesOfGlyphQuads.push_back(lineOfGlyphQuads);
        const float lineLength = penX;
 
        penY += (lineHeight * mLineSpacingScale);
 
        if (lineLength > maximumLineLengh)
        {
            maximumLineLengh = lineLength;
        }
    }
 
    mMaxLineLength = (mMaxLineLength > maximumLineLengh ? mMaxLineLength : maximumLineLengh);
    mDimensions = glm::vec2(mMaxLineLength, penY);
 
    size_t curLine = 0;
    for (const auto& line : linesOfGlyphQuads)
    {
        for (const auto& glyphQuad : line)
        {
            float horizontalShift = 0.0f;
            if (mTextAlign == TextAlign::Center)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]) / 2.0f;
            }
            if (mTextAlign == TextAlign::Right)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]);
            }
            PushQuad(meshes, glyphQuad, horizontalShift);
        }
        ++curLine;
    }
 
    UploadMeshes(meshes);
 
    Initialize();
}

ConstructMeshAutoLinebreak()

void rendering_engine::TextBlock2D::ConstructMeshAutoLinebreak ( const std::vector< std::uint32_t > &  codePoints )

protected

Definition at line 208 of file text_block_2d.cpp.

{
    auto meshes = PrepareMeshSlots(codePoints);
 
    const FontMetrics& fontMetrics = mFontResources->GetFontMetrics();
    const float lineHeight = static_cast<float>(fontMetrics.lineHeight);
    // Pen position (baseline)
    float penX = 0.0f;
    float penY = 0.0f;
 
    const std::uint32_t space{ 0x20 };
    const std::uint32_t newLine{ 0x0A };
 
    const bool autoTextWrappingRequested = mMaxLineLength > 0.0f;
    if (!autoTextWrappingRequested)
    {
        for (std::uint32_t glyph : codePoints)
        {
            if (glyph == newLine)
            {
                penX = 0.0f;
                penY += lineHeight;
                continue;
            }
 
            GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(glyph);
            GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX, penY);
            PushQuad(meshes, glyphQuad);
            penX += static_cast<float>(glyphQuad.advanceX);
        }
    }
    else
    {
        bool isStringComplete = false;
 
        // This variable describe the index we stay until new word is added.
        std::uint32_t currentIndex = 0;
        bool isLastGlyphProcessed = false;
        float lineLength = 0.0f;
        std::uint32_t nextGlyphIndex = 0;
 
        std::vector<GlyphQuad> line;
        std::vector<GlyphQuad> nextWord;
 
        while (!isStringComplete)
        {
            std::string stringProcessed;
 
            while (nextGlyphIndex < codePoints.size())
            {
                if (codePoints[nextGlyphIndex] == space)
                    break;
 
                const std::string curGlyph = CodepointToUtf8(codePoints[nextGlyphIndex]);
                stringProcessed.append(curGlyph);
                GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(codePoints[nextGlyphIndex]);
                GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX, penY);
                penX += static_cast<float>(glyphQuad.advanceX);
                nextWord.push_back(glyphQuad);
                ++nextGlyphIndex;
                isLastGlyphProcessed = nextGlyphIndex >= codePoints.size();
            }
 
            const bool isNewWordFitLine = penX <= mMaxLineLength;
 
            if (line.empty() || isNewWordFitLine)
            {
                if (!line.empty())
                {
                    //Insert SPACE
                    GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(space);
                    GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX, penY);
                    stringProcessed.append(" ");
                    penX += static_cast<float>(glyphQuad.advanceX);
                    nextWord.push_back(glyphQuad);
                    ++nextGlyphIndex;
                }
                // Add new word to the line
                std::copy(nextWord.begin(), nextWord.end(), std::back_inserter(line));
                nextWord.clear();
                lineLength = penX;
                currentIndex = nextGlyphIndex;
                isStringComplete = isLastGlyphProcessed;
            }
 
            if (!isNewWordFitLine || isLastGlyphProcessed)
            {
                nextWord.clear();
                // Finalize current line and switch to next. Push quads for all line, setting horizontal alignment
                for (auto& quad : line)
                {
                    float horizontalShift = 0.0f;
                    if (mTextAlign == TextAlign::Center)
                    {
                        horizontalShift = (mMaxLineLength - lineLength) / 2.0f;
                    }
                    if (mTextAlign == TextAlign::Right)
                    {
                        horizontalShift = (mMaxLineLength - lineLength);
                    }
                    PushQuad(meshes, quad, horizontalShift);
                }
                line.clear();
 
                penX = 0.0f;
                penY += lineHeight;
                nextGlyphIndex = currentIndex;
            }
        }
    }
 
    UploadMeshes(meshes);
 
    Initialize();
}

DecodeUtf8()

std::vector< std::uint32_t > rendering_engine::TextBlock2D::DecodeUtf8 ( const std::string &  text )

protected

Decodes a UTF-8 string into Unicode code points.

Parameters

text	UTF-8 encoded string.

Returns

List of Unicode code points.

Definition at line 138 of file text_block_2d.cpp.

{
    std::vector<std::uint32_t> result;
    result.reserve(text.size()); // worst case: ASCII
 
    const unsigned char* bytes =
        reinterpret_cast<const unsigned char*>(text.data());
    const size_t length = text.size();
 
    size_t i = 0;
    while (i < length)
    {
        std::uint32_t codePoint = 0;
        unsigned char c = bytes[i];
 
        if (c <= 0x7FU)
        {
            // 1-byte sequence (ASCII)
            codePoint = c;
            i += 1;
        }
        else if ((c & 0xE0U) == 0xC0U)
        {
            // 2-byte sequence
            if (i + 1 >= length) break;
 
            codePoint =
                ((c & 0x1FU) << 6) |
                (bytes[i + 1] & 0x3FU);
 
            i += 2;
        }
        else if ((c & 0xF0U) == 0xE0U)
        {
            // 3-byte sequence
            if (i + 2 >= length) break;
 
            codePoint =
                ((c & 0x0FU) << 12) |
                ((bytes[i + 1] & 0x3FU) << 6) |
                (bytes[i + 2] & 0x3FU);
 
            i += 3;
        }
        else if ((c & 0xF8U) == 0xF0U)
        {
            // 4-byte sequence
            if (i + 3 >= length) break;
 
            codePoint =
                ((c & 0x07U) << 18) |
                ((bytes[i + 1] & 0x3FU) << 12) |
                ((bytes[i + 2] & 0x3FU) << 6) |
                (bytes[i + 3] & 0x3FU);
 
            i += 4;
        }
        else
        {
            // Invalid UTF-8 start byte
            ++i;
            continue;
        }
 
        result.push_back(codePoint);
    }
 
    return result;
}

Draw()

void rendering_engine::TextBlock2D::Draw ( const Camera2D &  camera )

overridevirtual

Submits this quad to the renderer for drawing.

Implements rendering_engine::Drawable2D.

Definition at line 75 of file text_block_2d.cpp.

{
    Transformations2D transformations;
    transformations.model = GetTransform().GetWorldMatrix();
    transformations.view = camera.GetWorldView();
    transformations.proj = camera.GetProjectionMatrix();
 
    for (auto& renderBatch : mRenderBatches)
    {
        renderBatch.renderResources->SubmitResources(transformations, renderBatch.materialParameters);
    }
}

GetDimensions()

glm::vec2 rendering_engine::TextBlock2D::GetDimensions

(

)

const

Returns text block dimensions.

Returns

Width and height in pixels.

Definition at line 125 of file text_block_2d.cpp.

{
    return mDimensions;
}

Initialize()

void rendering_engine::TextBlock2D::Initialize ( )

overridevirtual

Initializes render resource pointers (material, mesh, etc.). Must be called after setting material and mesh names.

Reimplemented from rendering_engine::Drawable2D.

Definition at line 65 of file text_block_2d.cpp.

{
    Drawable2D::Initialize();
}

IsTextShapingRequired()

bool rendering_engine::TextBlock2D::IsTextShapingRequired ( std::uint32_t  codePoint ) const

protected

Checks whether shaping is required for a code point.

Parameters

codePoint

Unicode code point.

Returns

True if shaping is required.

Definition at line 629 of file text_block_2d.cpp.

{
    auto scriptsRequiredShaping = mTextRenderer->GetScriptsRequiredShaping();
    for (const auto& script : scriptsRequiredShaping)
    {
        auto range = mTextRenderer->GetScriptRange(script);
        if (codePoint >= range.first && codePoint <= range.second)
        {
            return true;
        }
    }
 
    return false;
}

MakeGlyphQuad()

TextBlock2D::GlyphQuad rendering_engine::TextBlock2D::MakeGlyphQuad ( GlyphIndex  glyphIndext, float  penX, float  penY  )

protected

Creates a glyph quad at the current pen position.

Parameters

glyphIndex	Glyph identifier.
penX	Horizontal pen position.
penY	Vertical pen position.

Returns

Glyph quad.

Definition at line 492 of file text_block_2d.cpp.

{
    GlyphQuad result;
 
    const GlyphMetrics& glyphMetrics = mFontResources->GetGlyphMetrics(glyphIndex);
    auto fontAtlasMaterialName = mFontResources->GetFontAtlasMaterialName(glyphIndex);
    const auto fontAtlasTextureName = mFontResources->GetFontAtlasTextureName(glyphIndex);
    auto textureCache = mTextRenderer->GetRenderResourceContext().textureCache;
    const auto& fontAtlas = textureCache->GetTextureResources(fontAtlasTextureName);
 
    result.fontAtlasMaterialName = fontAtlasMaterialName;
    
    const float bearingX = static_cast<float>(glyphMetrics.bearingX);
    const float bearingY = static_cast<float>(glyphMetrics.bearingY);
    const float glyphWidth = static_cast<float>(glyphMetrics.width);
    const float glyphHeight = static_cast<float>(glyphMetrics.height);
 
    // Positions
    const float x0 = penX + bearingX;
    const float y0 = penY - bearingY; // y0 - top
    const float y1 = y0 + glyphHeight; // y1 - bottom
    const float x1 = x0 + glyphWidth;
 
    result.x0 = x0 - mOutlineThicknessPx * 2;
    result.y0 = y0 - mOutlineThicknessPx * 2;
    result.x1 = x1 + mOutlineThicknessPx * 2;
    result.y1 = y1 + mOutlineThicknessPx * 2;
 
    // UVs
    const float atlasWidth =
        static_cast<float>(fontAtlas->GetCpuImageData().GetWidth());
    const float atlasHeight =
        static_cast<float>(fontAtlas->GetCpuImageData().GetHeight());
 
    const float atlasX = static_cast<float>(glyphMetrics.atlasX);
    const float atlasY = static_cast<float>(glyphMetrics.atlasY);
 
    result.u0 = (atlasX - mOutlineThicknessPx * 2) / atlasWidth;
    result.v0 = (atlasY - mOutlineThicknessPx * 2) / atlasHeight;
    result.u1 = (atlasX + glyphWidth + mOutlineThicknessPx * 2) / atlasWidth;
    result.v1 = (atlasY + glyphHeight + mOutlineThicknessPx * 2) / atlasHeight;
 
    result.advanceX = glyphMetrics.advanceX;
 
    return result;
}

PrepareMeshSlots() [1/5]

template<>

std::unordered_map< std::string, TextBlock2D::Mesh > rendering_engine::TextBlock2D::PrepareMeshSlots

(

const std::vector< ShapedGlyph > &

glyphs

)

PrepareMeshSlots() [2/5]

template<>

std::unordered_map< std::string, TextBlock2D::Mesh > rendering_engine::TextBlock2D::PrepareMeshSlots

(

const std::vector< ShapedGlyph > &

glyphs

)

Definition at line 739 of file text_block_2d.cpp.

{
    mMaterialMesh.clear();
    // Prepare map of used material names with corresponding mesh names.
    for (const auto& glyph : glyphs)
    {
        const std::uint32_t linefeed = 0x000A;
        const std::uint32_t carriageReturn = 0x000D;
        const std::uint32_t tab = 0x0009;
        if (glyph.glyphIndex == linefeed || glyph.glyphIndex == carriageReturn || glyph.glyphIndex == tab)
        {
            continue;
        }
 
        GlyphIndex glyphIndex;
        glyphIndex.index = glyph.glyphIndex;
        auto fontAtlasMaterialName = mFontResources->GetFontAtlasMaterialName(glyphIndex);
        const auto search = mMaterialMesh.find(fontAtlasMaterialName);
        if (search == mMaterialMesh.end())
        {
            const std::string meshName = mTextBlockID + "_" + std::to_string(mMaterialMesh.size());
            mMaterialMesh[fontAtlasMaterialName] = meshName;
        }
    }
 
    // Prepare map of used mesh names with mesh structures
    std::unordered_map<std::string, TextBlock2D::Mesh> meshes;
    for (const auto& mesh : mMaterialMesh)
    {
        meshes[mesh.second] = TextBlock2D::Mesh();
    }
 
    return meshes;
}

PrepareMeshSlots() [3/5]

template<>

std::unordered_map< std::string, TextBlock2D::Mesh > rendering_engine::TextBlock2D::PrepareMeshSlots

(

const std::vector< std::uint32_t > &

glyphs

)

PrepareMeshSlots() [4/5]

template<>

std::unordered_map< std::string, TextBlock2D::Mesh > rendering_engine::TextBlock2D::PrepareMeshSlots

(

const std::vector< std::uint32_t > &

glyphs

)

Definition at line 708 of file text_block_2d.cpp.

{
    mMaterialMesh.clear();
    // Prepare map of used material names with corresponding mesh names.
    for (auto codePoint : glyphs)
    {
        if (codePoint == 0x000A || codePoint == 0x000D || codePoint == 0x0009)
        {
            continue;
        }
 
        GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(codePoint);
        auto fontAtlasMaterialName = mFontResources->GetFontAtlasMaterialName(glyphIndex);
        const auto search = mMaterialMesh.find(fontAtlasMaterialName);
        if (search == mMaterialMesh.end())
        {
            const std::string meshName = mTextBlockID + "_" + std::to_string(mMaterialMesh.size());
            mMaterialMesh[fontAtlasMaterialName] = meshName;
        }
    }
 
    // Prepare map of used mesh names with mesh structures
    std::unordered_map<std::string, TextBlock2D::Mesh> meshes;
    for (const auto& mesh : mMaterialMesh)
    {
        meshes[mesh.second] = TextBlock2D::Mesh();
    }
    return meshes;
}

PrepareMeshSlots() [5/5]

template<typename T >

std::unordered_map< std::string, TextBlock2D::Mesh > rendering_engine::TextBlock2D::PrepareMeshSlots ( const std::vector< T > &  glyphs )

protected

Prepares mesh slots based on glyph usage.

Parameters

glyphs

Glyph collection.

Returns

Map of mesh names to mesh data.

PushQuad()

void rendering_engine::TextBlock2D::PushQuad ( std::unordered_map< std::string, TextBlock2D::Mesh > &  meshes, GlyphQuad  glyphQuad, float  horizontalShift = 0.0f  )

protected

Appends a glyph quad to a mesh.

Parameters

meshName	Target mesh name.
meshes	Mesh container.
glyphQuad	Glyph quad data.
horizontalShift	Alignment offset.

Definition at line 539 of file text_block_2d.cpp.

{
    auto& mesh = meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]);
 
    if (mesh.positions2D.size() >
        static_cast<std::size_t>(std::numeric_limits<std::uint32_t>::max()) - 3U)
    {
        throw std::overflow_error("TextBlock2D mesh exceeds 32-bit index range.");
    }
 
    const std::uint32_t vertexBase = static_cast<std::uint32_t>(mesh.positions2D.size());
 
    const glm::vec2 shift(horizontalShift, 0.0f);
 
    const glm::vec2 vert_0 = glm::vec2(glyphQuad.x0, glyphQuad.y0) + shift;
    const glm::vec2 vert_1 = glm::vec2(glyphQuad.x1, glyphQuad.y0) + shift;
    const glm::vec2 vert_2 = glm::vec2(glyphQuad.x1, glyphQuad.y1) + shift;
    const glm::vec2 vert_3 = glm::vec2(glyphQuad.x0, glyphQuad.y1) + shift;
 
    mesh.positions2D.push_back(vert_0);
    mesh.positions2D.push_back(vert_1);
    mesh.positions2D.push_back(vert_2);
    mesh.positions2D.push_back(vert_3);
 
    // UVs
    mesh.texCoords.push_back(glm::vec2(glyphQuad.u0, glyphQuad.v0));
    mesh.texCoords.push_back(glm::vec2(glyphQuad.u1, glyphQuad.v0));
    mesh.texCoords.push_back(glm::vec2(glyphQuad.u1, glyphQuad.v1));
    mesh.texCoords.push_back(glm::vec2(glyphQuad.u0, glyphQuad.v1));
 
    // Colors
    mesh.colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    mesh.colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    mesh.colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    mesh.colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
 
    // Indices
    mesh.indices.push_back(vertexBase + 0U);
    mesh.indices.push_back(vertexBase + 1U);
    mesh.indices.push_back(vertexBase + 2U);
 
    mesh.indices.push_back(vertexBase + 2U);
    mesh.indices.push_back(vertexBase + 3U);
    mesh.indices.push_back(vertexBase + 0U);
}

SetOutlineColor()

void rendering_engine::TextBlock2D::SetOutlineColor

(

glm::vec4

color

)

Sets the outline color.

Parameters

color

RGBA color.

Definition at line 117 of file text_block_2d.cpp.

{
    for (auto& renderBatch : mRenderBatches)
    {
        renderBatch.materialParameters.SetMaterialVec4("OutlineColor", color);
    }
}

SetOutlineThickness()

void rendering_engine::TextBlock2D::SetOutlineThickness ( float  thicknessPx )

protected

Sets outline thickness for all render batches.

Parameters

thicknessPx

Thickness in pixels.

Definition at line 130 of file text_block_2d.cpp.

{
    for (auto& renderBatch : mRenderBatches)
    {
        renderBatch.materialParameters.SetMaterialFloat("OutlineThicknessPx", thicknessPx);
    }
}

SetText()

void rendering_engine::TextBlock2D::SetText ( std::string  text )

virtual

Sets the displayed text.

Parameters

text	UTF-8 encoded text string.

Definition at line 88 of file text_block_2d.cpp.

{
    if (mText == text)
    {
        //Text has not changes, no new ensure/mesh-construction needed.
        return;
    }
    mText = text;
 
 
    if (bIsTextShapeEnabled)
    {
        ShapeTextAndConstructMesh();
    }
    else
    {
        ConstructMesh();
    }
    SetOutlineThickness(mOutlineThicknessPx);
}

SetTextColor()

void rendering_engine::TextBlock2D::SetTextColor

(

glm::vec4

color

)

Sets the text color.

Parameters

color

RGBA color.

Definition at line 109 of file text_block_2d.cpp.

{
    for (auto& renderBatch : mRenderBatches)
    {
        renderBatch.materialParameters.SetMaterialVec4("FontColor", color);
    }
}

ShapeText()

std::vector< TextBlock2D::ShapedGlyph > rendering_engine::TextBlock2D::ShapeText ( const std::string &  text )

protected

Shapes text and returns shaped glyphs.

Parameters

text	UTF-8 encoded text.

Returns

List of shaped glyphs.

Definition at line 670 of file text_block_2d.cpp.

{
    std::vector<TextBlock2D::ShapedGlyph> result;
 
    hb_buffer_t* buf;
    buf = hb_buffer_create();
    hb_buffer_add_utf8(buf, text.c_str(), -1, 0, -1);
 
    hb_buffer_guess_segment_properties(buf);
 
    auto* fontFace = mFontResources->GetFontFace();
    hb_font_t* font = hb_ft_font_create_referenced(fontFace);
 
    hb_shape(font, buf, NULL, 0);
 
    unsigned int glyph_count;
    hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
    hb_glyph_position_t* glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
 
    for (unsigned int i = 0; i < glyph_count; i++)
    {
        ShapedGlyph shapedGlyph;
        shapedGlyph.glyphIndex = glyph_info[i].codepoint;
        shapedGlyph.xOffset = static_cast<float>(glyph_pos[i].x_offset) / 64.0f;
        shapedGlyph.yOffset = static_cast<float>(glyph_pos[i].y_offset) / 64.0f;
        shapedGlyph.xAdvance =static_cast<float>(glyph_pos[i].x_advance) / 64.0f;
        shapedGlyph.yAdvance = static_cast<float>(glyph_pos[i].y_advance) / 64.0f;
        shapedGlyph.cluster = glyph_info[i].cluster;
        result.push_back(shapedGlyph);
    }
 
    hb_font_destroy(font);
    hb_buffer_destroy(buf);
 
    return result;
}

ShapeTextAndConstructMesh()

void rendering_engine::TextBlock2D::ShapeTextAndConstructMesh ( )

protected

Shapes text and constructs glyph geometry.

Definition at line 406 of file text_block_2d.cpp.

{
    auto textRuns = SplitString(mText, "\n");
 
    std::vector<std::vector<ShapedGlyph>> linesOfShapedGlyphs;
    std::vector<ShapedGlyph> preShapedGlyphs;
 
    for (const auto& textRun : textRuns)
    {
        auto shapedTextRun = ShapeText(textRun);
        linesOfShapedGlyphs.push_back(shapedTextRun);
        std::copy(shapedTextRun.begin(), shapedTextRun.end(), std::back_inserter(preShapedGlyphs));
    }
    std::vector<GlyphIndex> ensureGlyphs;
    for (const auto& shapedGlyph : preShapedGlyphs)
    {
        GlyphIndex gi;
        gi.index = shapedGlyph.glyphIndex;
        ensureGlyphs.push_back(gi);
    }
    mFontResources->EnsureGlyphs(ensureGlyphs);
 
    auto meshes = PrepareMeshSlots(preShapedGlyphs);
 
    // Pen position (baseline)
    float penX = 0.0f;
    float penY = 0.0f;
 
    float maximumLineLengh = 0.0f;
    std::vector<float> lineLengths;
 
    for (auto& line : linesOfShapedGlyphs)
    {
        float lineLength = 0.0f;
        for (const auto& glyph : line)
        {
            lineLength += glyph.xAdvance;
        }
        lineLengths.push_back(lineLength);
        if (lineLength > maximumLineLengh)
        {
            maximumLineLengh = lineLength;
        }
    }
    mMaxLineLength = (mMaxLineLength > maximumLineLengh ? mMaxLineLength : maximumLineLengh);
 
    const FontMetrics& fontMetrics = mFontResources->GetFontMetrics();
    const float lineHeight = static_cast<float>(fontMetrics.lineHeight);
    std::size_t curLine = 0U;
    for (auto& line : linesOfShapedGlyphs)
    {
        for (const auto& glyph : line)
        {
            GlyphIndex glyphIndex;
            glyphIndex.index = glyph.glyphIndex;
 
            GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX + glyph.xOffset, penY + glyph.yOffset);
 
            float horizontalShift = 0.0f;
            if (mTextAlign == TextAlign::Center)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]) / 2.0f;
            }
            if (mTextAlign == TextAlign::Right)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]);
            }
            PushQuad(meshes, glyphQuad, horizontalShift);
            penX += glyph.xAdvance;
        }
 
        penX = 0.0f;
        penY += (lineHeight * mLineSpacingScale);
        ++curLine;
    }
 
    const float lineCount =
    static_cast<float>(linesOfShapedGlyphs.size());
 
    mDimensions = glm::vec2(mMaxLineLength, lineCount * lineHeight * mLineSpacingScale);
 
    UploadMeshes(meshes);
 
    Initialize();
}

SplitString()

std::vector< std::string > rendering_engine::TextBlock2D::SplitString ( const std::string &  text, std::string  separator  )

protected

Splits a string by a separator.

Parameters

text	Input string.
separator	Separator string.

Returns

List of substrings.

Definition at line 612 of file text_block_2d.cpp.

{
    std::vector<std::string> result;
    std::string_view sv(text);
    size_t start = 0, end = 0;
 
    while (true) {
        end = sv.find(separator, start);
        // Extract token (including empty ones)
        result.emplace_back(sv.substr(start, end - start));
        if (end == std::string_view::npos) break;
        start = end + 1;  // Move past the delimiter
    }
 
    return result;
}

Update()

void rendering_engine::TextBlock2D::Update ( float  deltaTime )

overridevirtual

Updates logic (animation, movement, etc.) for this drawable.

Parameters

deltaTime

Time step (seconds).

Reimplemented from rendering_engine::Drawable2D.

Definition at line 70 of file text_block_2d.cpp.

{
    Drawable2D::Update(deltaTime);
}

UploadMeshes()

void rendering_engine::TextBlock2D::UploadMeshes ( const std::unordered_map< std::string, TextBlock2D::Mesh > &  meshes )

protected

Uploads prepared meshes to GPU resources.

Parameters

meshes

CPU-side mesh data.

Definition at line 585 of file text_block_2d.cpp.

{
    // Once meshes are ready, request its upload from ModelCache
    auto modelCache = mTextRenderer->GetRenderResourceContext().meshCache;
 
    for (auto& material : mMaterialMesh)
    {
        auto meshName = material.second;
        auto mesh = meshes.at(meshName);
        modelCache->LoadCustomMesh(meshName,
            mesh.positions2D,
            mesh.texCoords,
            mesh.colors,
            mesh.indices);
    }
 
    // Set mesh name and material name for THIS drawable, so the first font atlas for now only.
 
    Shutdown();
    for (const auto& materialMesh : mMaterialMesh)
    {
        const std::string meshName = materialMesh.second;
        const std::string materialName = materialMesh.first;
        AddRenderBatch(meshName, materialName);
    }
}

Member Data Documentation

bIsTextShapeEnabled

const bool rendering_engine::TextBlock2D::bIsTextShapeEnabled

protected

Definition at line 271 of file text_block_2d.hpp.

mColor

glm::vec4 rendering_engine::TextBlock2D::mColor

protected

Definition at line 261 of file text_block_2d.hpp.

mDimensions

glm::vec2 rendering_engine::TextBlock2D::mDimensions

protected

Definition at line 269 of file text_block_2d.hpp.

mFontName

const std::string rendering_engine::TextBlock2D::mFontName

protected

Definition at line 263 of file text_block_2d.hpp.

mFontResources

std::shared_ptr<FontResources> rendering_engine::TextBlock2D::mFontResources

protected

Definition at line 260 of file text_block_2d.hpp.

mFontSize

const unsigned int rendering_engine::TextBlock2D::mFontSize

protected

Definition at line 264 of file text_block_2d.hpp.

mLineSpacingScale

float rendering_engine::TextBlock2D::mLineSpacingScale = 1.0f

protected

Definition at line 265 of file text_block_2d.hpp.

mMaterialMesh

std::unordered_map<std::string, std::string> rendering_engine::TextBlock2D::mMaterialMesh

protected

Definition at line 257 of file text_block_2d.hpp.

mMaxLineLength

float rendering_engine::TextBlock2D::mMaxLineLength = 0.0f

protected

Definition at line 267 of file text_block_2d.hpp.

mOutlineThicknessPx

const float rendering_engine::TextBlock2D::mOutlineThicknessPx

protected

Definition at line 273 of file text_block_2d.hpp.

mText

std::string rendering_engine::TextBlock2D::mText

protected

Definition at line 266 of file text_block_2d.hpp.

mTextAlign

const TextAlign rendering_engine::TextBlock2D::mTextAlign

protected

Definition at line 268 of file text_block_2d.hpp.

mTextRenderer

const std::shared_ptr<TextRenderer> rendering_engine::TextBlock2D::mTextRenderer

protected

Definition at line 259 of file text_block_2d.hpp.

sDefaultFontName

std::string rendering_engine::TextBlock2D::sDefaultFontName = "RobotoMono-Regular"

staticprotected

Definition at line 262 of file text_block_2d.hpp.

---

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

• text_block_2d.hpp
• text_block_2d.cpp