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

#include <text_block_2d.hpp>

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. More...

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

void	Update (float deltaTime) override
	Updates logic (animation, movement, etc.) for this drawable. More...

void	Draw (const Camera2D &camera) override
	Submits this quad to the renderer for drawing. More...

virtual void	SetText (std::string text)
	Sets the displayed text. More...

void	SetTextColor (glm::vec4 color)
	Sets the text color. More...

void	SetOutlineColor (glm::vec4 color)
	Sets the outline color. More...

glm::vec2	GetDimensions () const
	Returns text block dimensions. More...

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. More...

void	Initialize () override
	Initializes render resources. More...

void	Update (float deltaTime) override
	Updates model matrix (and any other logic). More...

virtual void	Draw (const Camera2D &camera)=0
	Submits this quad to the renderer for drawing. More...

void	SetPosition (const glm::vec2 &position)
	Sets the quad position in 2D space. More...

void	SetRotation (float angleDegrees)
	Sets the quad rotation. More...

void	SetScale (const glm::vec2 &scale)
	Sets the quad scale along each axis. More...

const glm::vec2 &	GetPosition () const
	Gets the quad position. More...

float	GetRotation () const
	Gets the quad rotation angle (degrees). More...

const glm::vec2 &	GetScale () const
	Gets the quad scale. More...

SceneComponent2D &	GetTransform ()
	Access to the underlying SceneComponent2D (transform). More...

const SceneComponent2D &	GetTransform () const

void	Destroy () override
	Requests destruction of this drawable. More...

Public Member Functions inherited from rendering_engine::DrawableComponent
	DrawableComponent (RenderResourceContext renderContext, Scene &scene)
	Constructs the DrawableComponent with a resource context. More...

virtual	~DrawableComponent ()=default
	Virtual destructor. More...

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

virtual void	Update (float deltaTime)=0
	Updates logic (animation, movement, etc.) for this drawable. More...

virtual void	Shutdown ()
	Releases all render resources owned by this drawable. More...

virtual void	Destroy ()
	Requests destruction of this drawable. More...

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. More...

std::string	CodepointToUtf8 (std::uint32_t codePoint)
	Converts a Unicode code point to UTF-8. More...

std::vector< ShapedGlyph >	ShapeText (const std::string &text)
	Shapes text and returns shaped glyphs. More...

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

void	ConstructMesh ()
	Constructs glyph geometry without shaping. More...

void	ShapeTextAndConstructMesh ()
	Shapes text and constructs glyph geometry. More...

GlyphQuad	MakeGlyphQuad (GlyphIndex glyphIndext, float penX, float penY)
	Creates a glyph quad at the current pen position. More...

void	PushQuad (std::string meshName, std::unordered_map< std::string, TextBlock2D::Mesh > &meshes, GlyphQuad glyphQuad, float horizontalShift=0.0f)
	Appends a glyph quad to a mesh. More...

void	UploadMeshes (const std::unordered_map< std::string, TextBlock2D::Mesh > &meshes)
	Uploads prepared meshes to GPU resources. More...

void	SetOutlineThickness (float thicknessPx)
	Sets outline thickness for all render batches. More...

template<typename T >
std::unordered_map< std::string, TextBlock2D::Mesh >	PrepareMeshSlots (const std::vector< T > &glyphs)
	Prepares mesh slots based on glyph usage. More...

std::vector< std::string >	SplitString (const std::string &text, std::string separator)
	Splits a string by a separator. More...

bool	IsTextShapingRequired (std::uint32_t codePoint) const
	Checks whether shaping is required for a code point. More...

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),
    bIsTextShapeEnabled(properties.textShapeEnabled),
    mFontName(properties.fontName),
    mFontSize(properties.fontSize),
    mLineSpacingScale(properties.lineSpacingScale),
    mTextAlign(properties.textAlign),
    mMaxLineLength(properties.maxLineLength),
    mOutlineThicknessPx(properties.outlineThicknessPx > 2 ? 2 : properties.outlineThicknessPx),
    mColor(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f)),
    mDimensions(glm::vec2(0.0f, 0.0f))
{
    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 629 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 325 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();
 
    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 += glyphQuad.advanceX;
            lineOfGlyphQuads.push_back(glyphQuad);
        }
 
        lineLengths.push_back(penX);
        linesOfGlyphQuads.push_back(lineOfGlyphQuads);
        const float lineLength = penX;
 
        penY += (fontMetrics.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)
        {
            const std::string meshName = mMaterialMesh[glyphQuad.fontAtlasMaterialName];
            float horizontalShift = 0.0f;
            if (mTextAlign == TextAlign::Center)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]) / 2.0f;
            }
            if (mTextAlign == TextAlign::Right)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]);
            }
            PushQuad(meshName, 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();
    // 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 += fontMetrics.lineHeight;
                continue;
            }
 
            GlyphIndex glyphIndex = mFontResources->GetIndexFromCodePoint(glyph);
            GlyphQuad glyphQuad = MakeGlyphQuad(glyphIndex, penX, penY);
            const std::string meshName = mMaterialMesh[glyphQuad.fontAtlasMaterialName];
            PushQuad(meshName, meshes, glyphQuad);
            penX += 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 += 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 += 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);
                    }
                    const std::string meshName = mMaterialMesh[quad.fontAtlasMaterialName];
                    PushQuad(meshName, meshes, quad, horizontalShift);
                }
                line.clear();
 
                penX = 0.0f;
                penY += fontMetrics.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 <= 0x7F)
        {
            // 1-byte sequence (ASCII)
            codePoint = c;
            i += 1;
        }
        else if ((c & 0xE0) == 0xC0)
        {
            // 2-byte sequence
            if (i + 1 >= length) break;
 
            codePoint =
                ((c & 0x1F) << 6) |
                (bytes[i + 1] & 0x3F);
 
            i += 2;
        }
        else if ((c & 0xF0) == 0xE0)
        {
            // 3-byte sequence
            if (i + 2 >= length) break;
 
            codePoint =
                ((c & 0x0F) << 12) |
                ((bytes[i + 1] & 0x3F) << 6) |
                (bytes[i + 2] & 0x3F);
 
            i += 3;
        }
        else if ((c & 0xF8) == 0xF0)
        {
            // 4-byte sequence
            if (i + 3 >= length) break;
 
            codePoint =
                ((c & 0x07) << 18) |
                ((bytes[i + 1] & 0x3F) << 12) |
                ((bytes[i + 2] & 0x3F) << 6) |
                (bytes[i + 3] & 0x3F);
 
            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 614 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 490 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;
    
    // Positions
    const float x0 = penX + glyphMetrics.bearingX;
    const float y0 = penY - glyphMetrics.bearingY; // y0 - top
    const float y1 = y0 + glyphMetrics.height; // y1 - bottom
    const float x1 = x0 + glyphMetrics.width;
 
    result.x0 = x0 - mOutlineThicknessPx * 2;
    result.y0 = y0 - mOutlineThicknessPx * 2;
    result.x1 = x1 + mOutlineThicknessPx * 2;
    result.y1 = y1 + mOutlineThicknessPx * 2;
 
    // UVs
    const auto atlasWidth = static_cast<float>(fontAtlas->GetCpuImageData().GetWidth());
    const auto atlasHeight = static_cast<float>(fontAtlas->GetCpuImageData().GetHeight());
 
    const float u0 = static_cast<float>(glyphMetrics.atlasX - mOutlineThicknessPx * 2) / atlasWidth;
    const float v0 = static_cast<float>(glyphMetrics.atlasY - mOutlineThicknessPx * 2) / atlasHeight;
    const float u1 = static_cast<float>(glyphMetrics.atlasX + glyphMetrics.width + mOutlineThicknessPx * 2) / atlasWidth;
    const float v1 = static_cast<float>(glyphMetrics.atlasY + glyphMetrics.height + mOutlineThicknessPx * 2) / atlasHeight;
 
    result.u0 = u0;
    result.v0 = v0;
    result.u1 = u1;
    result.v1 = v1;
 
    result.advanceX = glyphMetrics.advanceX;
 
    return result;
}

◆ PrepareMeshSlots() [1/3]

template<>

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

Definition at line 724 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() [2/3]

template<>

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

Definition at line 693 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() [3/3]

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::string	meshName,
		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 532 of file text_block_2d.cpp.

{
    const uint32_t vertexBase = meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).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;
 
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).positions2D.push_back(vert_0);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).positions2D.push_back(vert_1);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).positions2D.push_back(vert_2);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).positions2D.push_back(vert_3);
 
    // UVs
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).texCoords.push_back(glm::vec2(glyphQuad.u0, glyphQuad.v0));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).texCoords.push_back(glm::vec2(glyphQuad.u1, glyphQuad.v0));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).texCoords.push_back(glm::vec2(glyphQuad.u1, glyphQuad.v1));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).texCoords.push_back(glm::vec2(glyphQuad.u0, glyphQuad.v1));
 
    // Colors
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).colors.push_back(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
 
    // Indices
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 0);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 1);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 2);
 
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 2);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 3);
    meshes.at(mMaterialMesh[glyphQuad.fontAtlasMaterialName]).indices.push_back(vertexBase + 0);
}

◆ 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 655 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 = glyph_pos[i].x_offset / 64.0f;
        shapedGlyph.yOffset = glyph_pos[i].y_offset / 64.0f;
        shapedGlyph.xAdvance = glyph_pos[i].x_advance / 64.0f;
        shapedGlyph.yAdvance = 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 407 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();
    int curLine = 0;
    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);
            const std::string meshName = mMaterialMesh[glyphQuad.fontAtlasMaterialName];
 
            float horizontalShift = 0.0f;
            if (mTextAlign == TextAlign::Center)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]) / 2.0f;
            }
            if (mTextAlign == TextAlign::Right)
            {
                horizontalShift = (mMaxLineLength - lineLengths[curLine]);
            }
            PushQuad(meshName, meshes, glyphQuad, horizontalShift);
            penX += glyph.xAdvance;
        }
 
        penX = 0.0f;
        penY += (fontMetrics.lineHeight * mLineSpacingScale);
        ++curLine;
    }
 
    mDimensions = glm::vec2(mMaxLineLength, linesOfShapedGlyphs.size() * fontMetrics.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 597 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 570 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 272 of file text_block_2d.hpp.

◆ mColor

glm::vec4 rendering_engine::TextBlock2D::mColor

protected

Definition at line 262 of file text_block_2d.hpp.

◆ mDimensions

glm::vec2 rendering_engine::TextBlock2D::mDimensions

protected

Definition at line 270 of file text_block_2d.hpp.

◆ mFontName

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

protected

Definition at line 264 of file text_block_2d.hpp.

◆ mFontResources

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

protected

Definition at line 261 of file text_block_2d.hpp.

◆ mFontSize

const unsigned int rendering_engine::TextBlock2D::mFontSize

protected

Definition at line 265 of file text_block_2d.hpp.

◆ mLineSpacingScale

float rendering_engine::TextBlock2D::mLineSpacingScale = 1.0f

protected

Definition at line 266 of file text_block_2d.hpp.

◆ mMaterialMesh

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

protected

Definition at line 258 of file text_block_2d.hpp.

◆ mMaxLineLength

float rendering_engine::TextBlock2D::mMaxLineLength = 0.0f

protected

Definition at line 268 of file text_block_2d.hpp.

◆ mOutlineThicknessPx

const float rendering_engine::TextBlock2D::mOutlineThicknessPx

protected

Definition at line 274 of file text_block_2d.hpp.

◆ mText

std::string rendering_engine::TextBlock2D::mText

protected

Definition at line 267 of file text_block_2d.hpp.

◆ mTextAlign

const TextAlign rendering_engine::TextBlock2D::mTextAlign

protected

Definition at line 269 of file text_block_2d.hpp.

◆ mTextRenderer

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

protected

Definition at line 260 of file text_block_2d.hpp.

◆ sDefaultFontName

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

staticprotected

Definition at line 263 of file text_block_2d.hpp.

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TextBlock2D()

Member Function Documentation

◆ CodepointToUtf8()

◆ ConstructMesh()

◆ ConstructMeshAutoLinebreak()

◆ DecodeUtf8()

◆ Draw()

◆ GetDimensions()

◆ Initialize()

◆ IsTextShapingRequired()

◆ MakeGlyphQuad()

◆ PrepareMeshSlots() [1/3]

◆ PrepareMeshSlots() [2/3]

◆ PrepareMeshSlots() [3/3]

◆ PushQuad()

◆ SetOutlineColor()

◆ SetOutlineThickness()

◆ SetText()

◆ SetTextColor()

◆ ShapeText()

◆ ShapeTextAndConstructMesh()

◆ SplitString()

◆ Update()

◆ UploadMeshes()

Member Data Documentation

◆ bIsTextShapeEnabled

◆ mColor

◆ mDimensions

◆ mFontName

◆ mFontResources

◆ mFontSize

◆ mLineSpacingScale

◆ mMaterialMesh

◆ mMaxLineLength

◆ mOutlineThicknessPx

◆ mText

◆ mTextAlign

◆ mTextRenderer

◆ sDefaultFontName