rendering_engine::MeshDataGpu Class Reference

Manages mesh data in RAM and GPU, including upload and release operations. More...

#include <mesh_data_gpu.hpp>

Public Member Functions
	MeshDataGpu (IRenderer *renderer)
	Constructs an empty MeshDataGpu object.
	MeshDataGpu (const std::string &filename, IRenderer *renderer)
	Construct a MeshDataGpu instance.
	MeshDataGpu (std::vector< uint8_t > const &fileBytes, IRenderer *renderer)
	Constructs a MeshDataGpu instance from in-memory model data.
	~MeshDataGpu ()
	Destructor. Releases GPU resources if allocated.
void	UploadToGPU ()
	Upload mesh data to the GPU using the current mesh type.
void	ReleaseFromGPU ()
	Release GPU resources associated with this mesh.
bool	IsOnGPU () const
	Check if mesh data is currently uploaded to GPU.
void	CreateQuad2D ()
	Creates a 1�1 unit quad centered at the origin.
size_t	GetGpuVertexBufferSize () const
	Get the size (in bytes) of the vertex buffer on GPU.
size_t	GetGpuIndexBufferSize () const
	Get the size (in bytes) of the index buffer on GPU.
size_t	GetCpuVertexBufferSize () const
	Get the size (in bytes) of the vertex buffer in RAM.
size_t	GetCpuIndexBufferSize () const
	Get the size (in bytes) of the index buffer in RAM.
IMeshRenderResources *	GetMeshRenderResources ()
	Get the interface for mesh GPU resources (Vulkan or other backend).
const std::vector< glm::vec2 > &	GetPositions2D () const
	Returns a constant reference to the 2D vertex positions.
const std::vector< glm::vec3 > &	GetPositions () const
	Returns a constant reference to the 3D vertex positions.
const std::vector< glm::vec4 > &	GetColors () const
	Returns a constant reference to the vertex colors.
const std::vector< glm::vec3 > &	GetNormals () const
	Returns a constant reference to the vertex normals.
const std::vector< glm::vec2 > &	GetTexCoords () const
	Returns a constant reference to the texture coordinates.
const std::vector< glm::vec3 > &	GetTangents () const
	Returns a constant reference to the vertex tangents.
const std::vector< uint32_t > &	GetIndices () const
	Returns a constant reference to the mesh indices.

Protected Member Functions
void	LoadModel (std::string path)
	Load a model from file and extract mesh data to RAM.
void	LoadModel (std::vector< uint8_t > const &fileBytes)
void	CalculateMeshParameters ()
	Calculate and cache sizes of RAM buffers for statistics or debugging.
std::vector< Vertex2D >	ComposeVertex2DBuffer ()
	Compose a vertex buffer for 2D meshes (e.g., sprites).
std::vector< VertexPositionColorTexture >	ComposeUnlitBuffer ()
	Compose a vertex buffer for unlit 3D meshes (e.g., billboards, particles).
std::vector< VertexPositionColorTextureNormalTangent >	ComposeLitBuffer ()
	Compose a vertex buffer for lit 3D meshes (with normals, tangents).

Detailed Description

Manages mesh data in RAM and GPU, including upload and release operations.

Supports on-demand composition of different vertex buffer formats and maintains all intermediate mesh data required for rendering or further processing (e.g., collision).

Definition at line 36 of file mesh_data_gpu.hpp.

Constructor & Destructor Documentation

MeshDataGpu() [1/3]

rendering_engine::MeshDataGpu::MeshDataGpu

(

IRenderer *

renderer

)

Constructs an empty MeshDataGpu object.

This constructor is typically used when the mesh data will be filled or generated procedurally before being uploaded to the GPU.

Parameters

renderer

Pointer to the rendering backend interface.

Definition at line 8 of file mesh_data_gpu.cpp.

    :
    mRenderer(renderer),
    mGpuHandle(nullptr),
    mSizeOfVerticesBytes(0),
    mSizeOfIndicesBytes(0),
    mMeshType(MeshType::None)
{
}

MeshDataGpu() [2/3]

rendering_engine::MeshDataGpu::MeshDataGpu	(	const std::string &	filename,
		IRenderer *	renderer )

Construct a MeshDataGpu instance.

Parameters

filename	Path to the model file
renderer	Pointer to the rendering backend interface.

Definition at line 17 of file mesh_data_gpu.cpp.

    :
    mRenderer(renderer),
    mGpuHandle(nullptr),
    mSizeOfVerticesBytes(0),
    mSizeOfIndicesBytes(0),
    mMeshType(MeshType::None)
{
    LoadModel(filename);
}

MeshDataGpu() [3/3]

rendering_engine::MeshDataGpu::MeshDataGpu	(	std::vector< uint8_t > const &	fileBytes,
		IRenderer *	renderer )

Constructs a MeshDataGpu instance from in-memory model data.

This version loads a model directly from a raw file buffer in memory. It allows meshes to be created from packed assets, archives, network transfers, or any other non-filesystem source. After loading the model, vertex and index data are uploaded to GPU buffers the same way as in the file-based constructor.

Parameters

fileBytes	Raw contents of the model file.
renderer	Pointer to the rendering backend interface.

Definition at line 28 of file mesh_data_gpu.cpp.

    :
    mRenderer(renderer),
    mGpuHandle(nullptr),
    mSizeOfVerticesBytes(0),
    mSizeOfIndicesBytes(0),
    mMeshType(MeshType::None)
{
    LoadModel(fileBytes);
}

~MeshDataGpu()

rendering_engine::MeshDataGpu::~MeshDataGpu

(

)

Destructor. Releases GPU resources if allocated.

Definition at line 39 of file mesh_data_gpu.cpp.

{
    ReleaseFromGPU();
}

Member Function Documentation

CalculateMeshParameters()

void rendering_engine::MeshDataGpu::CalculateMeshParameters ( )

protected

Calculate and cache sizes of RAM buffers for statistics or debugging.

Definition at line 229 of file mesh_data_gpu.cpp.

{
    size_t sizeOfVerticesBytes = 0;
    size_t sizeOfIndicesBytes = 0;
 
    sizeOfVerticesBytes += (mPositions2D.size() * sizeof(glm::vec2));
    sizeOfVerticesBytes += (mPositions.size() * sizeof(glm::vec3));
    sizeOfVerticesBytes += (mColor.size() * sizeof(glm::vec4));
    sizeOfVerticesBytes += (mNormals.size() * sizeof(glm::vec3));
    sizeOfVerticesBytes += (mTexCoords.size() * sizeof(glm::vec2));
    sizeOfVerticesBytes += (mTangents.size() * sizeof(glm::vec3));
    
    sizeOfIndicesBytes += (mIndices.size() * sizeof(uint32_t));
 
    mSizeOfVerticesBytes = sizeOfVerticesBytes;
    mSizeOfIndicesBytes = sizeOfIndicesBytes;
}

ComposeLitBuffer()

std::vector< VertexPositionColorTextureNormalTangent > rendering_engine::MeshDataGpu::ComposeLitBuffer ( )

protected

Compose a vertex buffer for lit 3D meshes (with normals, tangents).

Returns

Vector of VertexPositionTextureColorNormalTangent structures.

Definition at line 285 of file mesh_data_gpu.cpp.

{
    std::vector<VertexPositionColorTextureNormalTangent> result;
 
    unsigned int index = 0;
    for (const auto& position : mPositions)
    {
        VertexPositionColorTextureNormalTangent vert;
        vert.position = position;
        vert.color = mColor.empty() ? glm::vec4(1.0f) : mColor[index];
        vert.textureCoordinates = mTexCoords.empty() ? glm::vec2(0.0f) : mTexCoords[index];
        vert.normal = mNormals.empty() ? glm::vec3(0.0f, 0.0f, 1.0f) : mNormals[index];
        vert.tangent = mTangents.empty() ? glm::vec3(1.0f, 0.0f, 0.0f) : mTangents[index];
 
        result.push_back(vert);
        ++index;
    }
 
    return result;
}

ComposeUnlitBuffer()

std::vector< VertexPositionColorTexture > rendering_engine::MeshDataGpu::ComposeUnlitBuffer ( )

protected

Compose a vertex buffer for unlit 3D meshes (e.g., billboards, particles).

Returns

Vector of VertexPositionTextureColor structures.

Definition at line 266 of file mesh_data_gpu.cpp.

{
    std::vector<VertexPositionColorTexture> result;
 
    unsigned int index = 0;
    for (const auto& position : mPositions)
    {
        VertexPositionColorTexture vert;
        vert.position = position;
        vert.color = mColor.empty() ? glm::vec4(1) : mColor[index];
        vert.textureCoordinates = mTexCoords.empty() ? glm::vec2(0.0f) : mTexCoords[index];
 
        result.push_back(vert);
        ++index;
    }
 
    return result;
}

ComposeVertex2DBuffer()

std::vector< Vertex2D > rendering_engine::MeshDataGpu::ComposeVertex2DBuffer ( )

protected

Compose a vertex buffer for 2D meshes (e.g., sprites).

Returns

Vector of Vertex2D structures.

Definition at line 247 of file mesh_data_gpu.cpp.

{
    std::vector<Vertex2D> result;
 
    unsigned int index = 0;
    for (const auto& position : mPositions2D)
    {
        Vertex2D vert;
        vert.position = position;
        vert.color = mColor.empty() ? glm::vec4(1.0f) : mColor[index];
        vert.textureCoordinates = mTexCoords.empty() ? glm::vec2(0.0f) : mTexCoords[index];
 
        result.push_back(vert);
        ++index;
    }
 
    return result;
}

CreateQuad2D()

void rendering_engine::MeshDataGpu::CreateQuad2D

(

)

Creates a 1�1 unit quad centered at the origin.

The quad spans from -0.5 to +0.5 on both X and Y axes and uses counterclockwise winding. Suitable as a base mesh for sprites or 2D UI elements.

Definition at line 171 of file mesh_data_gpu.cpp.

{
    mPositions2D = { {-0.5f, -0.5f}, { 0.5f, -0.5f}, { 0.5f,  0.5f}, {-0.5f,  0.5f} };
    mTexCoords = { {0.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 0.0f}, {0.0f, 0.0f} };
    mColor = { {1.0f, 0.0f, 0.0f, 1.0f}, {0.0f, 1.0f, 0.0f, 1.0f}, {0.0f, 0.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 1.0f} };
    mIndices = {
            0, 1, 2,  // first triangle
            2, 3, 0   // second triangle
    };
 
    CalculateMeshParameters();
 
    mMeshType = MeshType::Sprite2D;
}

GetColors()

const std::vector< glm::vec4 > & rendering_engine::MeshDataGpu::GetColors ( ) const

inline

Returns a constant reference to the vertex colors.

Definition at line 142 of file mesh_data_gpu.hpp.

{ return mColor; }

GetCpuIndexBufferSize()

size_t rendering_engine::MeshDataGpu::GetCpuIndexBufferSize

(

)

const

Get the size (in bytes) of the index buffer in RAM.

Returns

Size in bytes of the CPU-side index data.

Definition at line 215 of file mesh_data_gpu.cpp.

{
    return mSizeOfIndicesBytes;
}

GetCpuVertexBufferSize()

size_t rendering_engine::MeshDataGpu::GetCpuVertexBufferSize

(

)

const

Get the size (in bytes) of the vertex buffer in RAM.

Returns

Size in bytes of the CPU-side vertex data.

Definition at line 210 of file mesh_data_gpu.cpp.

{
    return mSizeOfVerticesBytes;
}

GetGpuIndexBufferSize()

size_t rendering_engine::MeshDataGpu::GetGpuIndexBufferSize

(

)

const

Get the size (in bytes) of the index buffer on GPU.

Returns

Size in bytes of the GPU index buffer.

Definition at line 198 of file mesh_data_gpu.cpp.

{
    size_t result = 0;
 
    if (mGpuHandle)
    {
        result = mGpuHandle->GetIndexBufferSize();
    }
 
    return result;
}

GetGpuVertexBufferSize()

size_t rendering_engine::MeshDataGpu::GetGpuVertexBufferSize

(

)

const

Get the size (in bytes) of the vertex buffer on GPU.

Returns

Size in bytes of the GPU vertex buffer.

Definition at line 186 of file mesh_data_gpu.cpp.

{
    size_t result = 0;
 
    if (mGpuHandle)
    {
        result = mGpuHandle->GetVertexBufferSize();
    }
 
    return result;
}

GetIndices()

const std::vector< uint32_t > & rendering_engine::MeshDataGpu::GetIndices ( ) const

inline

Returns a constant reference to the mesh indices.

Definition at line 162 of file mesh_data_gpu.hpp.

{ return mIndices; }

GetMeshRenderResources()

IMeshRenderResources * rendering_engine::MeshDataGpu::GetMeshRenderResources

(

)

Get the interface for mesh GPU resources (Vulkan or other backend).

Returns

Pointer to the backend-specific IMeshRenderResources implementation.

Definition at line 220 of file mesh_data_gpu.cpp.

{
    if (!IsOnGPU())
    {
        UploadToGPU();
    }
    return mGpuHandle.get();
}

GetNormals()

const std::vector< glm::vec3 > & rendering_engine::MeshDataGpu::GetNormals ( ) const

inline

Returns a constant reference to the vertex normals.

Definition at line 147 of file mesh_data_gpu.hpp.

{ return mNormals; }

GetPositions()

const std::vector< glm::vec3 > & rendering_engine::MeshDataGpu::GetPositions ( ) const

inline

Returns a constant reference to the 3D vertex positions.

Definition at line 137 of file mesh_data_gpu.hpp.

{ return mPositions; }

GetPositions2D()

const std::vector< glm::vec2 > & rendering_engine::MeshDataGpu::GetPositions2D ( ) const

inline

Returns a constant reference to the 2D vertex positions.

Definition at line 132 of file mesh_data_gpu.hpp.

{ return mPositions2D; }

GetTangents()

const std::vector< glm::vec3 > & rendering_engine::MeshDataGpu::GetTangents ( ) const

inline

Returns a constant reference to the vertex tangents.

Definition at line 157 of file mesh_data_gpu.hpp.

{ return mTangents; }

GetTexCoords()

const std::vector< glm::vec2 > & rendering_engine::MeshDataGpu::GetTexCoords ( ) const

inline

Returns a constant reference to the texture coordinates.

Definition at line 152 of file mesh_data_gpu.hpp.

{ return mTexCoords; }

IsOnGPU()

bool rendering_engine::MeshDataGpu::IsOnGPU

(

)

const

Check if mesh data is currently uploaded to GPU.

Returns

True if GPU resources are resident, false otherwise.

Definition at line 103 of file mesh_data_gpu.cpp.

{
    bool result = false;
 
    if (mGpuHandle)
    {
        result = mGpuHandle->IsOnGPU();
    }
 
    return result;
}

LoadModel() [1/2]

void rendering_engine::MeshDataGpu::LoadModel ( std::string path )

protected

Load a model from file and extract mesh data to RAM.

Parameters

path	Path to the model file (e.g., FBX).

Definition at line 115 of file mesh_data_gpu.cpp.

{
    std::unique_ptr<Model> model = std::make_unique<Model>(path, true);
 
    if (model)
    {
        if (model->HasMeshes())
        {
            mPositions = model->Meshes()[0]->Vertices();
            
            if (model->Meshes()[0]->VertexColors().size() >= 1)
                mColor = model->Meshes()[0]->VertexColors()[0];
 
            mNormals = model->Meshes()[0]->Normals();
            for (const auto& texCoord : model->Meshes()[0]->TextureCoordinates()[0])
            {
                mTexCoords.push_back(glm::vec2(texCoord.x, texCoord.y));
            }
            mTangents = model->Meshes()[0]->Tangents();
            mIndices = model->Meshes()[0]->Indices();
        }
    }
 
    CalculateMeshParameters();
 
    mMeshType = MeshType::Surface;
}

LoadModel() [2/2]

void rendering_engine::MeshDataGpu::LoadModel ( std::vector< uint8_t > const & fileBytes )

protected

Definition at line 143 of file mesh_data_gpu.cpp.

{
    std::unique_ptr<Model> model = std::make_unique<Model>(fileBytes, true);
 
    if (model)
    {
        if (model->HasMeshes())
        {
            mPositions = model->Meshes()[0]->Vertices();
 
            if (model->Meshes()[0]->VertexColors().size() >= 1)
                mColor = model->Meshes()[0]->VertexColors()[0];
 
            mNormals = model->Meshes()[0]->Normals();
            for (const auto& texCoord : model->Meshes()[0]->TextureCoordinates()[0])
            {
                mTexCoords.push_back(glm::vec2(texCoord.x, texCoord.y));
            }
            mTangents = model->Meshes()[0]->Tangents();
            mIndices = model->Meshes()[0]->Indices();
        }
    }
 
    CalculateMeshParameters();
 
    mMeshType = MeshType::Surface;
}

ReleaseFromGPU()

void rendering_engine::MeshDataGpu::ReleaseFromGPU

(

)

Release GPU resources associated with this mesh.

Definition at line 87 of file mesh_data_gpu.cpp.

{
    if (!mRenderer)
    {
        return;
    }
    if (!mGpuHandle)
    {
        return;
    }
 
    mGpuHandle->Shutdown();
    mGpuHandle.release();
    mGpuHandle = nullptr;
}

UploadToGPU()

void rendering_engine::MeshDataGpu::UploadToGPU

(

)

Upload mesh data to the GPU using the current mesh type.

Definition at line 44 of file mesh_data_gpu.cpp.

{
    if (!mRenderer)
    {
        return;
    }
    if (mGpuHandle)
    {
        if (mGpuHandle->IsOnGPU())
        {
            ReleaseFromGPU();
        }
    }
 
    mGpuHandle = std::unique_ptr<IMeshRenderResources>(mRenderer->ProvideMeshRenderResources());
 
    switch (mMeshType)
    {
        case MeshType::None:
        {
            break;
        }
        case MeshType::Sprite2D:
        {   
            mGpuHandle->CreateVertexBuffer(ComposeVertex2DBuffer());
            mGpuHandle->CreateIndexBuffer(mIndices);
            break;
        }
        case MeshType::Billboard:
        {
            mGpuHandle->CreateVertexBuffer(ComposeUnlitBuffer());
            mGpuHandle->CreateIndexBuffer(mIndices);
            break;
        }
        case MeshType::Surface:
        {
            mGpuHandle->CreateVertexBuffer(ComposeLitBuffer());
            mGpuHandle->CreateIndexBuffer(mIndices);
            break;
        }
    }
}

---

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

• mesh_data_gpu.hpp
• mesh_data_gpu.cpp