Chronos::Engine::Text Class Reference

Class for creating a text object for rendering text. More...

#include <text.hpp>

Inheritance diagram for Chronos::Engine::Text:

Collaboration diagram for Chronos::Engine::Text:

Public Member Functions
void	init (Chronos::Engine::Device *device, VkCommandPool commandPool, Chronos::Engine::SwapChain *swapChain, VkSampler textureSampler, VkRenderPass *renderPass, Chronos::Engine::FontTypes fontStyle)
	Initializes the font object and creates the necessary objects.
void	destroy () override
	Destroys the font object and frees the memory.
void	clear ()
	Clears the text stored in the font object.
void	render (uint32_t currentFrame, uint32_t imageIndex, float bgColor[3], VkViewport &viewport, VkRect2D &scissor, std::vector< VkCommandBuffer > &commandBuffers) override
	Records the commands needed for rendering the text .
void	update (uint32_t currentFrame) override
	Updates the attributes(like position, color, etc) of the text.
Public Member Functions inherited from Chronos::Engine::Object
void	init (Chronos::Engine::Device *device, VkCommandPool commandPool, SwapChain *swapChain, VkSampler textureSampler, VkRenderPass *renderPass, ObjectType objectType, unsigned char *vertShaderCode, int vertShaderCodeSize, unsigned char *fragShaderCode, int fragShaderCodeSize)
	Initializes the object.
void	recreateGraphicsPipeline ()
	Recreates the graphics pipeline for the object.

Public Attributes
VkBuffer	vertexBuffer
	The vertices of each character used for rendering.
uint32_t	numLetters
	The total number of letters to render.
Chronos::Engine::TextParams	params
	Various parameters of the text that are set by the user.
Public Attributes inherited from Chronos::Engine::Object
VkPipeline	graphicsPipeline
VkPipelineLayout	pipelineLayout
std::vector< VkDescriptorSet >	descriptorSets
Chronos::Engine::ObjectType	objectType

Private Member Functions
void	createDescriptorSets () override
	Creates the descriptor sets needed for rendering the text.
std::vector< VkDescriptorType >	getDescriptorTypes () override
	Gets the descriptor types needed for rendering the text.
std::vector< VkShaderStageFlagBits >	getDescriptorStages () override
	Gets the descriptor stages in which the descriptor sets are used.
PipelineAttributes	getPipelineAttributes () override
	Returns the pipeline attributes that are set for the graphics pipeline.
void	updateBuffer ()
	Updates the buffer with the new text.

Private Attributes
stb_fontchar	stbFontData [STB_FONT_consolas_24_latin1_NUM_CHARS]
uint32_t	maxTextLength = 2048
	Maximum number of characters that can be rendered.
VkDeviceMemory	vertexBufferMemory
	The vertex buffer memory.
Chronos::Engine::Texture	fontTexture
std::vector< Chronos::Engine::ColorBuffer >	colorBuffers
uint32_t	firstChar = 'a'
FontTypes	fontStyle
glm::vec4 *	mappedMemory
unsigned char(*	fontpixels )[256]

Additional Inherited Members
Protected Member Functions inherited from Chronos::Engine::Object
void	createGraphicsPipeline ()
	Creates the graphics pipeline for the object.
void	createDescriptorPool ()
	Creates the Vulkan descriptor pool for the object.
void	createDescriptorSetLayout ()
	Creates the Vulkan descriptor set layout for the object.
Protected Attributes inherited from Chronos::Engine::Object
Chronos::Engine::Device *	device
Chronos::Engine::SwapChain *	swapChain
VkCommandPool	commandPool
VkSampler	textureSampler
VkRenderPass *	renderPass
VkDescriptorSetLayout	descriptorSetLayout
VkDescriptorPool	descriptorPool
std::vector< Chronos::Engine::UniformBuffer >	uniformBuffers

Detailed Description

Class for creating a text object for rendering text.

We can choose from a lot of fonts and sizes. There are many available.

For rendering text in vulkan, we need a bunch of setup and objects. It is also a very complex process. This class handles this process and abstracts this complex process into a simple class with simple methods that can be used for rendering text.

The way the test is rendered is by creating a texture atlas. This is a texture that contains all the characters in the font. This texture is then used to render the text. The text is rendered by creating a rectangle for each character and then rendering it.

This class is not meant to be directly used, but instead to be used by the

class. That will handle the creation and destruction of the font object, along with any updates needed.

Definition at line 86 of file text.hpp.

Member Function Documentation

clear()

void Chronos::Engine::Text::clear

(

)

Clears the text stored in the font object.

Used for resetting the text stored in the font object.

Definition at line 296 of file text.cpp.

{
    if (vkMapMemory(device->device, vertexBufferMemory, 0, VK_WHOLE_SIZE, 0,
        (void**)&mappedMemory)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to map memory!");
    }
    numLetters = 0;
    mappedMemory = nullptr;
 
    vkUnmapMemory(device->device, vertexBufferMemory);
    mappedMemory = nullptr;
}

createDescriptorSets()

void Chronos::Engine::Text::createDescriptorSets ( )

overrideprivatevirtual

Creates the descriptor sets needed for rendering the text.

This function is used to create the descriptor sets needed for rendering the text. The descriptor sets contain information about the texture sampler and the uniform buffer.

Implements Chronos::Engine::Object.

Definition at line 94 of file text.cpp.

{
    std::vector<VkDescriptorSetLayout> layouts(
    MAX_FRAMES_IN_FLIGHT, descriptorSetLayout);
    VkDescriptorSetAllocateInfo allocInfo {};
    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    allocInfo.descriptorPool = descriptorPool;
    allocInfo.descriptorSetCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
    allocInfo.pSetLayouts = layouts.data();
    descriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
    if (vkAllocateDescriptorSets(
        device->device, &allocInfo, descriptorSets.data())
    != VK_SUCCESS) {
    throw std::runtime_error("failed to allocate descriptor sets!");
    }
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
 
    VkDescriptorImageInfo imageInfo {};
    imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    imageInfo.imageView = fontTexture.textureImageView;
    imageInfo.sampler = textureSampler;
 
    VkDescriptorBufferInfo bufferInfo {};
    bufferInfo.buffer = uniformBuffers[i].buffer;
    bufferInfo.offset = 0;
    bufferInfo.range = sizeof(UniformBufferObject);
 
    VkDescriptorBufferInfo bufferInfo2 {};
    bufferInfo2.buffer = colorBuffers[i].buffer;
    bufferInfo2.offset = 0;
    bufferInfo2.range = sizeof(UniformColorBufferObject);
 
    std::array<VkWriteDescriptorSet, 3> descriptorWrites {};
 
    descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
    descriptorWrites[0].dstSet = descriptorSets[i];
    descriptorWrites[0].dstBinding = 0;
    descriptorWrites[0].dstArrayElement = 0;
    descriptorWrites[0].descriptorType
        = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
    descriptorWrites[0].descriptorCount = 1;
    descriptorWrites[0].pImageInfo = &imageInfo;
 
    descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
    descriptorWrites[1].dstSet = descriptorSets[i];
    descriptorWrites[1].dstBinding = 1;
    descriptorWrites[1].dstArrayElement = 0;
    descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    descriptorWrites[1].descriptorCount = 1;
    descriptorWrites[1].pBufferInfo = &bufferInfo;
 
    descriptorWrites[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
    descriptorWrites[2].dstSet = descriptorSets[i];
    descriptorWrites[2].dstBinding = 2;
    descriptorWrites[2].dstArrayElement = 0;
    descriptorWrites[2].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    descriptorWrites[2].descriptorCount = 1;
    descriptorWrites[2].pBufferInfo = &bufferInfo2;
 
    vkUpdateDescriptorSets(device->device,
        static_cast<uint32_t>(descriptorWrites.size()),
        descriptorWrites.data(), 0, nullptr);
    }
};

References MAX_FRAMES_IN_FLIGHT.

destroy()

void Chronos::Engine::Text::destroy ( )

overridevirtual

Destroys the font object and frees the memory.

This destroys all the vulkan related objects related to this class and frees memory.

Implements Chronos::Engine::Object.

Definition at line 210 of file text.cpp.

{
    Chronos::Engine::Object::destroy();
    vkDestroyBuffer(device->device, vertexBuffer, nullptr);
    vkFreeMemory(device->device, vertexBufferMemory, nullptr);
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
    colorBuffers[i].destroy();
    }
    fontTexture.destroy();
    delete[] fontpixels;
}

References Chronos::Engine::Object::destroy(), and MAX_FRAMES_IN_FLIGHT.

Here is the call graph for this function:

getDescriptorStages()

std::vector< VkShaderStageFlagBits > Chronos::Engine::Text::getDescriptorStages ( )

overrideprivatevirtual

Gets the descriptor stages in which the descriptor sets are used.

Implements Chronos::Engine::Object.

Definition at line 88 of file text.cpp.

{
    return std::vector<VkShaderStageFlagBits> { VK_SHADER_STAGE_FRAGMENT_BIT,
    VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT };
}

getDescriptorTypes()

std::vector< VkDescriptorType > Chronos::Engine::Text::getDescriptorTypes ( )

overrideprivatevirtual

Gets the descriptor types needed for rendering the text.

Implements Chronos::Engine::Object.

Definition at line 80 of file text.cpp.

{
    return std::vector<VkDescriptorType> {
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
    };
}

getPipelineAttributes()

Chronos::Engine::PipelineAttributes Chronos::Engine::Text::getPipelineAttributes ( )

overrideprivatevirtual

Returns the pipeline attributes that are set for the graphics pipeline.

Implements Chronos::Engine::Object.

Definition at line 160 of file text.cpp.

{
    PipelineAttributes pipelineAttributes;
    pipelineAttributes.bindingDescriptions
    = std::vector<VkVertexInputBindingDescription> { 2 };
    pipelineAttributes.bindingDescriptions[0].binding = 0;
    pipelineAttributes.bindingDescriptions[0].stride = sizeof(glm::vec4);
    pipelineAttributes.bindingDescriptions[0].inputRate
    = VK_VERTEX_INPUT_RATE_VERTEX;
 
    pipelineAttributes.bindingDescriptions[1].binding = 1;
    pipelineAttributes.bindingDescriptions[1].stride = sizeof(glm::vec4);
    pipelineAttributes.bindingDescriptions[1].inputRate
    = VK_VERTEX_INPUT_RATE_VERTEX;
 
    pipelineAttributes.attributeDescriptions
    = std::vector<VkVertexInputAttributeDescription> { 2 };
    pipelineAttributes.attributeDescriptions[0].binding = 0;
    pipelineAttributes.attributeDescriptions[0].location = 0;
    pipelineAttributes.attributeDescriptions[0].format
    = VK_FORMAT_R32G32_SFLOAT;
    pipelineAttributes.attributeDescriptions[0].offset = 0;
 
    pipelineAttributes.attributeDescriptions[1].binding = 1;
    pipelineAttributes.attributeDescriptions[1].location = 1;
    pipelineAttributes.attributeDescriptions[1].format
    = VK_FORMAT_R32G32_SFLOAT;
    pipelineAttributes.attributeDescriptions[1].offset = sizeof(glm::vec2);
 
    pipelineAttributes.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
    pipelineAttributes.frontFace = VK_FRONT_FACE_CLOCKWISE;
 
    pipelineAttributes.colorBlendAttachment.blendEnable = VK_TRUE;
    pipelineAttributes.colorBlendAttachment.colorWriteMask
    = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
    | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    pipelineAttributes.colorBlendAttachment.srcColorBlendFactor
    = VK_BLEND_FACTOR_SRC_ALPHA;
    pipelineAttributes.colorBlendAttachment.dstColorBlendFactor
    = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    pipelineAttributes.colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
    pipelineAttributes.colorBlendAttachment.srcAlphaBlendFactor
    = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    pipelineAttributes.colorBlendAttachment.dstAlphaBlendFactor
    = VK_BLEND_FACTOR_ZERO;
    pipelineAttributes.colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
 
    return pipelineAttributes;
}

References Chronos::Engine::PipelineAttributes::attributeDescriptions, Chronos::Engine::PipelineAttributes::bindingDescriptions, Chronos::Engine::PipelineAttributes::colorBlendAttachment, Chronos::Engine::PipelineAttributes::frontFace, and Chronos::Engine::PipelineAttributes::topology.

init()

void Chronos::Engine::Text::init	(	Chronos::Engine::Device *	device,
		VkCommandPool	commandPool,
		Chronos::Engine::SwapChain *	swapChain,
		VkSampler	textureSampler,
		VkRenderPass *	renderPass,
		Chronos::Engine::FontTypes	fontStyle
	)

Initializes the font object and creates the necessary objects.

Parameters

device	The device to use for creating the objects.
commandPool	The command pool to use for rendering
swapChain	The swapchain to use for rendering
textureSampler	The texture sampler to use for fonts
renderPass	The renderpass to use for rendering
fontStyle	The font style to use for rendering

Definition at line 28 of file text.cpp.

{
 
    // set the fontstyle
    this->fontStyle = fontStyle;
 
    // initalize the font
    uint32_t fontWidth = fontStyle.fontWidth;
    uint32_t fontHeight = fontStyle.fontHeight;
    firstChar = fontStyle.firstChar;
 
    // unsigned char fontpixels[fontHeight][256];
    // this causes a memory leak... too bad, MSVC is fucked
    // MSVC can't take variable multi dimensional arrays, else the above
    // commented line would have worked.
    fontpixels = new unsigned char[fontHeight][256];
    fontStyle.getFontData(stbFontData, fontpixels, fontHeight);
 
    // create the font texture from the raw data
    /*
    freetype-devel, use this instead and refer
    https://github.com/RahulVadhyar/StreetChase/blob/main/TextClass.hpp to
    render and freetype font.
    */
    fontTexture.create(*device, commandPool, (void*)&(fontpixels)[0][0],
    static_cast<size_t>(fontWidth), static_cast<size_t>(fontHeight),
    static_cast<VkDeviceSize>(fontWidth * fontHeight), VK_FORMAT_R8_UNORM,
    "Text Texture");
 
    // create the vertex buffer
    VkDeviceSize bufferSize = maxTextLength * sizeof(glm::vec4);
    Chronos::Engine::createBuffer(*device, bufferSize,
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
        | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, // want to be visible to
                            // host and device
    &vertexBuffer, &vertexBufferMemory);
 
    // create the uniform buffers for color changing
    colorBuffers.resize(MAX_FRAMES_IN_FLIGHT);
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
    colorBuffers[i].create(*device);
    }
    Chronos::Engine::Object::init(device, commandPool, swapChain,
    textureSampler, renderPass, Chronos::Engine::ObjectType::TypeText,
    textVert_spv, textVert_spv_len,
     textFrag_spv, textFrag_spv_len);
}

References colorBuffers, Chronos::Engine::Object::commandPool, Chronos::Engine::Texture::create(), Chronos::Engine::createBuffer(), Chronos::Engine::Object::device, Chronos::Engine::FontTypes::firstChar, firstChar, Chronos::Engine::FontTypes::fontHeight, fontpixels, fontStyle, fontTexture, Chronos::Engine::FontTypes::fontWidth, Chronos::Engine::FontTypes::getFontData, Chronos::Engine::Object::init(), MAX_FRAMES_IN_FLIGHT, maxTextLength, Chronos::Engine::Object::renderPass, stbFontData, Chronos::Engine::Object::swapChain, Chronos::Engine::Object::textureSampler, Chronos::Engine::TypeText, vertexBuffer, and vertexBufferMemory.

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Chronos::Engine::Text::render ( uint32_t  currentFrame, uint32_t  imageIndex, float  bgColor[3], VkViewport &  viewport, VkRect2D &  scissor, std::vector< VkCommandBuffer > &  commandBuffers  )

overridevirtual

Records the commands needed for rendering the text .

When this function is called, it records the commands that are needed for rendering the text stored in this class.

Parameters

currentFrame	The current frame number to render to.
imageIndex	The index of the framebuffer associated with the current frame
bgColor	The background color to use for rendering the text.

Implements Chronos::Engine::Object.

Definition at line 319 of file text.cpp.

{
    vkCmdBindPipeline(commandBuffers[currentFrame],
    VK_PIPELINE_BIND_POINT_GRAPHICS, this->graphicsPipeline);
    vkCmdSetViewport(commandBuffers[currentFrame], 0, 1, &viewport);
    vkCmdSetScissor(commandBuffers[currentFrame], 0, 1, &scissor);
    VkBuffer vertexBuffers[] = { this->vertexBuffer };
    VkDeviceSize offsets[] = { 0 };
    vkCmdBindVertexBuffers(
    commandBuffers[currentFrame], 0, 1, vertexBuffers, offsets);
    vkCmdBindVertexBuffers(
    commandBuffers[currentFrame], 1, 1, vertexBuffers, offsets);
    vkCmdBindDescriptorSets(commandBuffers[currentFrame],
    VK_PIPELINE_BIND_POINT_GRAPHICS, this->pipelineLayout, 0, 1,
    &this->descriptorSets[currentFrame], 0, nullptr);
    for (uint32_t j = 0; j < this->numLetters; j++) {
    vkCmdDraw(commandBuffers[currentFrame], 4, 1, j * 4, 0);
    }
}

update()

void Chronos::Engine::Text::update ( uint32_t  currentFrame )

overridevirtual

Updates the attributes(like position, color, etc) of the text.

This function is used to update the attributes of the text. It is called by the FontManager class. It does this by updating the uniform buffer.

Implements Chronos::Engine::Object.

Definition at line 310 of file text.cpp.

{
    updateBuffer();
    uniformBuffers[currentFrame].update(swapChain->swapChainExtent, params.x,
    params.y, params.rotation + 90, 1.0f, -1.0f);
    colorBuffers[currentFrame].update(
    { params.color[0], params.color[1], params.color[2] });
}

updateBuffer()

void Chronos::Engine::Text::updateBuffer ( )

private

Updates the buffer with the new text.

Definition at line 222 of file text.cpp.

{
    // update the vertex buffer with new text on update
    if (vkMapMemory(device->device, vertexBufferMemory, 0, VK_WHOLE_SIZE, 0,
        (void**)&mappedMemory)
    != VK_SUCCESS) {
    throw std::runtime_error("failed to map memory!");
    }
 
    numLetters = 0;
 
    assert(mappedMemory != nullptr);
 
    const float charW = 1.5f * params.scale / swapChain->swapChainExtent.width;
    const float charH = 1.5f * params.scale / swapChain->swapChainExtent.height;
 
    float fbW = (float)swapChain->swapChainExtent.width;
    float fbH = (float)swapChain->swapChainExtent.height;
    float x = (0 / fbW * 2.0f);
    float y = (0 / fbH * 2.0f);
 
    // Calculate text width
    float textWidth = 0;
    for (auto letter : params.text) {
    stb_fontchar* charData = &stbFontData[(uint32_t)letter - firstChar];
    textWidth += charData->advance * charW;
    }
    // switch (alignment) {
    // case Right:
    //     x -= textWidth;
    //     break;
    // case Center:
    x -= textWidth / 2.0f;
    //     break;
    // case Left:
    //     break;
    // }
 
    // Generate a uv mapped quad per char in the new text
    for (auto letter : params.text) {
    stb_fontchar* charData = &stbFontData[(uint32_t)letter - firstChar];
 
    mappedMemory->x = (x + (float)charData->x0 * charW);
    mappedMemory->y = (y + (float)charData->y0 * charH);
    mappedMemory->z = charData->s0;
    mappedMemory->w = charData->t0;
    mappedMemory++;
 
    mappedMemory->x = (x + (float)charData->x1 * charW);
    mappedMemory->y = (y + (float)charData->y0 * charH);
    mappedMemory->z = charData->s1;
    mappedMemory->w = charData->t0;
    mappedMemory++;
 
    mappedMemory->x = (x + (float)charData->x0 * charW);
    mappedMemory->y = (y + (float)charData->y1 * charH);
    mappedMemory->z = charData->s0;
    mappedMemory->w = charData->t1;
    mappedMemory++;
 
    mappedMemory->x = (x + (float)charData->x1 * charW);
    mappedMemory->y = (y + (float)charData->y1 * charH);
    mappedMemory->z = charData->s1;
    mappedMemory->w = charData->t1;
    mappedMemory++;
 
    x += charData->advance * charW;
    numLetters++;
    }
 
    vkUnmapMemory(device->device, vertexBufferMemory);
    mappedMemory = nullptr;
}

Member Data Documentation

colorBuffers

std::vector<Chronos::Engine::ColorBuffer> Chronos::Engine::Text::colorBuffers

private

Definition at line 171 of file text.hpp.

firstChar

uint32_t Chronos::Engine::Text::firstChar = 'a'

private

Definition at line 173 of file text.hpp.

fontpixels

unsigned char(* Chronos::Engine::Text::fontpixels)[256]

private

Definition at line 212 of file text.hpp.

fontStyle

FontTypes Chronos::Engine::Text::fontStyle

private

Definition at line 175 of file text.hpp.

fontTexture

Chronos::Engine::Texture Chronos::Engine::Text::fontTexture

private

The font texture

Definition at line 169 of file text.hpp.

mappedMemory

glm::vec4* Chronos::Engine::Text::mappedMemory

private

The mapped memory to the vertex buffer

Definition at line 210 of file text.hpp.

maxTextLength

uint32_t Chronos::Engine::Text::maxTextLength = 2048

private

Maximum number of characters that can be rendered.

Definition at line 161 of file text.hpp.

numLetters

uint32_t Chronos::Engine::Text::numLetters

The total number of letters to render.

Definition at line 149 of file text.hpp.

params

Chronos::Engine::TextParams Chronos::Engine::Text::params

Various parameters of the text that are set by the user.

Definition at line 154 of file text.hpp.

stbFontData

stb_fontchar Chronos::Engine::Text::stbFontData[STB_FONT_consolas_24_latin1_NUM_CHARS]

private

Definition at line 157 of file text.hpp.

vertexBuffer

VkBuffer Chronos::Engine::Text::vertexBuffer

The vertices of each character used for rendering.

Definition at line 144 of file text.hpp.

vertexBufferMemory

VkDeviceMemory Chronos::Engine::Text::vertexBufferMemory

private

The vertex buffer memory.

Definition at line 165 of file text.hpp.

---

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

• Source/Rendering/Objects/Text/text.hpp
• Source/Rendering/Objects/Text/text.cpp