Manages loading, caching, and GPU residency of all model/mesh resources. More...

#include <model_cache.hpp>

Inherits rendering_engine::IRendererObserver.

Public Member Functions
	ModelCache (IRenderer *renderer)
	Construct a ModelCache and register it with the given renderer. More...

	~ModelCache ()
	Destructor. Releases all resources and unregisters observer. More...

void	LoadModelsFromFolder (std::string pathToFolder)
	Load all models found in the specified folder into RAM. More...

void	LoadModelsFromPackage ()
	Load all models from the packed asset container. More...

void	CreateQuad2D ()
	Creates a built-in 2D quad mesh. More...

void	LoadCustomMesh (std::string meshName, std::vector< glm::vec2 > positions2D, std::vector< glm::vec2 > texCoords, std::vector< glm::vec4 > colors, std::vector< std::uint32_t > indices)

std::string	UploadModelToRAM (std::string path)
	Load a single model from file into RAM. More...

std::string	UploadModelToRAM (std::string fileName, std::vector< uint8_t > const &fileBytes)
	Load a single model into RAM from a raw file buffer. More...

void	UploadModelToGPU (std::string filename)
	Upload a cached model's mesh data to the GPU. More...

void	ReleaseModelFromGPU (std::string filename)
	Release a model's mesh data from GPU memory. More...

void	ReleaseAllFromGPU ()
	Release all model mesh data from GPU memory. More...

void	ReleaseAll ()
	Remove all models from both GPU and RAM, clearing the cache. More...

std::shared_ptr< MeshDataGpu >	GetMeshResources (std::string filename)
	Get a shared pointer to the MeshDataGpu for a model. More...

IMeshRenderResources *	GetMeshRenderResources (std::string filename)
	Get the IMeshRenderResources interface for a model's GPU resources. More...

size_t	GetSizeInRAM () const
	Get the total size (in bytes) of all models loaded in RAM. More...

size_t	GetSizeInGPU () const
	Get the total size (in bytes) of all models currently resident on GPU. More...

Public Member Functions inherited from rendering_engine::IRendererObserver
virtual void	OnRenderResourcesRelease ()=0
	Renderer callback: release all GPU resources (used during device loss/reset). More...

virtual void	OnRenderResourcesRebuild ()=0
	Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild). More...

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

Protected Member Functions
void	OnRenderResourcesRelease () override
	Renderer callback: release all GPU resources (used during device loss/reset). More...

void	OnRenderResourcesRebuild () override
	Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild). More...

Protected Attributes
IRenderer *	mRenderer

std::unordered_map< std::string, std::shared_ptr< MeshDataGpu > >	mModels

size_t	mTotalSizeRAM

size_t	mTotalSizeGPU

Detailed Description

Manages loading, caching, and GPU residency of all model/mesh resources.

Responsible for importing model files into RAM, uploading mesh data to GPU memory, and managing the lifetime and statistics of all managed models in the rendering engine. Also observes renderer resource lifecycle events (release/rebuild).

Definition at line 29 of file model_cache.hpp.

Constructor & Destructor Documentation

◆ ModelCache()

rendering_engine::ModelCache::ModelCache ( IRenderer * renderer )

Construct a ModelCache and register it with the given renderer.

Parameters

renderer Pointer to the owning IRenderer implementation.

Definition at line 13 of file model_cache.cpp.

    :
    mRenderer(renderer),
    mTotalSizeRAM(0),
    mTotalSizeGPU(0)
{
    LOG_DEBUG("ModelCache created.");
    mRenderer->RegisterObserver(this);
}

◆ ~ModelCache()

rendering_engine::ModelCache::~ModelCache ( )

Destructor. Releases all resources and unregisters observer.

Definition at line 23 of file model_cache.cpp.

{
    LOG_DEBUG("ModelCache destroyed.");
    mRenderer->UnregisterObserver(this);
}

Member Function Documentation

◆ CreateQuad2D()

void rendering_engine::ModelCache::CreateQuad2D ( )

Creates a built-in 2D quad mesh.

This helper is used by 2D systems (e.g., UI, sprites) to create a reusable quad mesh without external model files.

Definition at line 90 of file model_cache.cpp.

{
    mModels["Quad2D"] = std::make_shared<MeshDataGpu>(mRenderer);
    mModels["Quad2D"]->CreateQuad2D();
 
    const size_t sizeVertices = mModels.at("Quad2D")->GetCpuVertexBufferSize();
    mTotalSizeRAM += sizeVertices;
    const size_t sizeIndices = mModels.at("Quad2D")->GetCpuIndexBufferSize();
    mTotalSizeRAM += sizeIndices;
}

◆ GetMeshRenderResources()

IMeshRenderResources * rendering_engine::ModelCache::GetMeshRenderResources ( std::string filename )

Get the IMeshRenderResources interface for a model's GPU resources.

Parameters

filename The model's cache key (filename without extension).

Returns: Pointer to IMeshRenderResources, or nullptr if not found or not on GPU.

Definition at line 269 of file model_cache.cpp.

{
    if (auto search = mModels.find(filename); search == mModels.end())
    {
        return nullptr;
    }
 
    return mModels.at(filename)->GetMeshRenderResources();
}

◆ GetMeshResources()

std::shared_ptr< MeshDataGpu > rendering_engine::ModelCache::GetMeshResources ( std::string filename )

Get a shared pointer to the MeshDataGpu for a model.

Parameters

filename The model's cache key (filename without extension).

Returns: Shared pointer to MeshDataGpu, or nullptr if not found.

Definition at line 259 of file model_cache.cpp.

{
    auto search = mModels.find(filename);
    if (search == mModels.end())
    {
        return nullptr;
    }
    return search->second;
}

◆ GetSizeInGPU()

size_t rendering_engine::ModelCache::GetSizeInGPU ( ) const

inline

Get the total size (in bytes) of all models currently resident on GPU.

Returns: Total GPU usage in bytes.

Definition at line 284 of file model_cache.cpp.

{
    return mTotalSizeGPU;
}

◆ GetSizeInRAM()

size_t rendering_engine::ModelCache::GetSizeInRAM ( ) const

inline

Get the total size (in bytes) of all models loaded in RAM.

Returns: Total RAM usage in bytes.

Definition at line 279 of file model_cache.cpp.

{
    return mTotalSizeRAM;
}

◆ LoadCustomMesh()

void rendering_engine::ModelCache::LoadCustomMesh	(	std::string	meshName,
		std::vector< glm::vec2 >	positions2D,
		std::vector< glm::vec2 >	texCoords,
		std::vector< glm::vec4 >	colors,
		std::vector< std::uint32_t >	indices
	)

Definition at line 101 of file model_cache.cpp.

{
    LOG_DEBUG("Loading custom mesh: " + meshName);
    auto start = std::chrono::steady_clock::now();
    auto search = mModels.find(meshName);
    if (search != mModels.end())
    {
        mTotalSizeRAM -= search->second->GetCpuVertexBufferSize();
        mTotalSizeRAM -= search->second->GetCpuIndexBufferSize();
        ReleaseModelFromGPU(meshName);
    }
 
    mModels[meshName] = std::make_shared<MeshDataGpu>(mRenderer);
    mModels[meshName]->LoadCustomMesh(positions2D, texCoords, colors, indices);
 
    const size_t sizeVertices = mModels.at(meshName)->GetCpuVertexBufferSize();
    mTotalSizeRAM += sizeVertices;
    const size_t sizeIndices = mModels.at(meshName)->GetCpuIndexBufferSize();
    mTotalSizeRAM += sizeIndices;
 
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_DEBUG("Custom mesh loaded: " + meshName +
        " (RAM: " +
        std::to_string(sizeVertices + sizeIndices) +
        " bytes, " + std::to_string(ms) + " ms)");
}

◆ LoadModelsFromFolder()

void rendering_engine::ModelCache::LoadModelsFromFolder ( std::string pathToFolder )

Load all models found in the specified folder into RAM.

Parameters

pathToFolder Path to the directory containing model files.

Definition at line 29 of file model_cache.cpp.

{
    LOG_INFO("Loading models from folder: " + pathToFolder);
    auto start = std::chrono::steady_clock::now();
    // 1. Check if path is valid and exist
    boost::filesystem::path pathToDirectory = boost::filesystem::path(pathToFolder);
    const bool isValidFolderPath = boost::filesystem::exists(boost::filesystem::path(pathToFolder)) && boost::filesystem::is_directory(boost::filesystem::path(pathToFolder));
    if (!isValidFolderPath)
    {
        return;
    }
    // 2. Iterate through files in the folder.
    //    if file is in the list of supported extensions
    for (boost::filesystem::directory_entry& x : boost::filesystem::directory_iterator(pathToDirectory))
    {
        (void)UploadModelToRAM(x.path().string());
    }
 
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Loaded " + std::to_string(mModels.size()) +
        " models from folder in " +
        std::to_string(ms) + " ms. RAM usage: " +
        std::to_string(mTotalSizeRAM) + " bytes.");
}

◆ LoadModelsFromPackage()

void rendering_engine::ModelCache::LoadModelsFromPackage ( )

Load all models from the packed asset container.

This function behaves similarly to LoadModelsFromFolder(), but instead retrieves model files from the packed asset system created by the Packaging Tool. Each packed file is read into memory and processed via UploadModelToRAM(std::string, const std::vector<uint8_t>&).

Only file entries located under the virtual folder: "Models/" are considered.

The resulting MeshDataGpu objects remain cached and ready for GPU upload.

Definition at line 56 of file model_cache.cpp.

{
    LOG_INFO("Loading models from package.");
    auto start = std::chrono::steady_clock::now();
    const auto& entries = Utility::GetPackEntries();
 
    std::string folderEntry = { "Models/" };
    for (auto& entry : entries)
    {
        const std::string& virtualPath = entry.first;
        if (virtualPath.rfind(folderEntry, 0) == 0) // starts with Models/
        {
            std::string modelName = virtualPath.substr(folderEntry.size());
 
            std::vector<uint8_t> binaryFileData = Utility::ReadPackedFile(virtualPath);
            if (binaryFileData.empty())
            {
                LOG_ERROR("Failed to read packed model: " + virtualPath);
                continue;
            }
 
            // Upload to RAM with textureName + binaryFileData
            (void)UploadModelToRAM(modelName, binaryFileData);
        }
    }
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Loaded " + std::to_string(mModels.size()) +
        " models from package in " +
        std::to_string(ms) + " ms. RAM usage: " +
        std::to_string(mTotalSizeRAM) + " bytes.");
}

◆ OnRenderResourcesRebuild()

void rendering_engine::ModelCache::OnRenderResourcesRebuild ( )

overrideprotectedvirtual

Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild).

This method will be called after the device or swapchain is recreated, allowing the observer to re-upload or recreate all necessary resources for rendering.

Implements rendering_engine::IRendererObserver.

Definition at line 294 of file model_cache.cpp.

{
    for (auto& model : mModels)
    {
        model.second->UploadToGPU();
        size_t sizeVertices = model.second->GetGpuVertexBufferSize();
        mTotalSizeGPU += sizeVertices;
        size_t sizeIndices = model.second->GetGpuIndexBufferSize();
        mTotalSizeGPU += sizeIndices;
    }
}

◆ OnRenderResourcesRelease()

void rendering_engine::ModelCache::OnRenderResourcesRelease ( )

overrideprotectedvirtual

Renderer callback: release all GPU resources (used during device loss/reset).

This method will be called before any device or swapchain is destroyed, allowing the observer to safely release all handles and deallocate any GPU memory.

Implements rendering_engine::IRendererObserver.

Definition at line 289 of file model_cache.cpp.

{
    ReleaseAllFromGPU();
}

◆ ReleaseAll()

void rendering_engine::ModelCache::ReleaseAll ( )

Remove all models from both GPU and RAM, clearing the cache.

Definition at line 248 of file model_cache.cpp.

{
    LOG_INFO("Releasing all models. RAM usage: " +
        std::to_string(mTotalSizeRAM) +
        ", GPU usage: " +
        std::to_string(mTotalSizeGPU));
    mModels.clear();
    mTotalSizeRAM = 0;
    mTotalSizeGPU = 0;
}

◆ ReleaseAllFromGPU()

void rendering_engine::ModelCache::ReleaseAllFromGPU ( )

Release all model mesh data from GPU memory.

Definition at line 239 of file model_cache.cpp.

{
    for (auto& texture : mModels)
    {
        texture.second->ReleaseFromGPU();
    }
    mTotalSizeGPU = 0;
}

◆ ReleaseModelFromGPU()

void rendering_engine::ModelCache::ReleaseModelFromGPU ( std::string filename )

Release a model's mesh data from GPU memory.

Parameters

filename The model's cache key (filename without extension).

Definition at line 223 of file model_cache.cpp.

{
    if (auto search = mModels.find(filename); search == mModels.end())
    {
        return;
    }
    LOG_DEBUG("Releasing model from GPU: " + filename);
    auto& model = mModels[filename];
    size_t sizeVertices = model->GetGpuVertexBufferSize();
    size_t sizeIndices = model->GetGpuIndexBufferSize();
    model->ReleaseFromGPU();
 
    mTotalSizeGPU -= sizeVertices;
    mTotalSizeGPU -= sizeIndices;
}

◆ UploadModelToGPU()

void rendering_engine::ModelCache::UploadModelToGPU ( std::string filename )

Upload a cached model's mesh data to the GPU.

Parameters

filename The model's cache key (filename without extension).

Definition at line 196 of file model_cache.cpp.

{
    // If texture is not loaded in RAM yet, skip loading to GPU.
    if (auto search = mModels.find(filename); search == mModels.end())
    {
        return;
    }
    if (mModels[filename]->IsOnGPU())
    {
        return;
    }
    LOG_DEBUG("Uploading model to GPU: " + filename);
    auto start = std::chrono::steady_clock::now();
    mModels[filename]->UploadToGPU();
    size_t sizeVertices = mModels[filename]->GetGpuVertexBufferSize();
    mTotalSizeGPU += sizeVertices;
    size_t sizeIndices = mModels[filename]->GetGpuIndexBufferSize();
    mTotalSizeGPU += sizeIndices;
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_DEBUG("Model uploaded to GPU: " + filename +
        " (GPU: " +
        std::to_string(sizeVertices + sizeIndices) +
        " bytes, " + std::to_string(ms) + " ms)");
}

◆ UploadModelToRAM() [1/2]

std::string rendering_engine::ModelCache::UploadModelToRAM	(	std::string	fileName,
		std::vector< uint8_t > const &	fileBytes
	)

Load a single model into RAM from a raw file buffer.

This overload is used when the model originates from a packed asset archive or any virtual filesystem source rather than the OS filesystem.

Parameters

fileName	Cache key (typically relative virtual path, e.g. "Models/cube.fbx").
fileBytes	Raw contents of the model file.

Returns: The cache key on success, or an empty string on failure.

Definition at line 169 of file model_cache.cpp.

{
    auto modelName = boost::filesystem::path(fileName).stem().string();
 
    // If model is already loaded into RAM yet, do not add again.
    if (auto search = mModels.find(modelName); search != mModels.end())
    {
        return std::string{};
    }
    LOG_DEBUG("Uploading model to RAM: " + fileName);
    auto start = std::chrono::steady_clock::now();
    mModels[modelName] = std::make_shared<MeshDataGpu>(fileBytes, mRenderer);
 
    const size_t sizeVertices = mModels.at(modelName)->GetCpuVertexBufferSize();
    mTotalSizeRAM += sizeVertices;
    const size_t sizeIndices = mModels.at(modelName)->GetCpuIndexBufferSize();
    mTotalSizeRAM += sizeIndices;
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Model loaded to RAM: " + fileName +
        " (Vertices+Indices: " +
        std::to_string(sizeVertices + sizeIndices) +
        " bytes, " + std::to_string(ms) + " ms)");
    return modelName;
}

◆ UploadModelToRAM() [2/2]

std::string rendering_engine::ModelCache::UploadModelToRAM ( std::string path )

Load a single model from file into RAM.

Parameters

path	Path to the model file.

Returns: The filename used as a cache key, or empty string on failure.

Definition at line 130 of file model_cache.cpp.

{
    auto filePath = boost::filesystem::path(path);
    if (!boost::filesystem::is_regular_file(filePath))
    {
        return std::string{};
    }
 
    const std::string ext = filePath.extension().string();
    const bool isExtensionSupported = (ext == ".fbx");
    if (!isExtensionSupported)
    {
        return std::string{};
    }
 
    std::string filename = filePath.stem().string();
    // If model is already loaded into RAM yet, do not add again.
    if (auto search = mModels.find(filename); search != mModels.end())
    {
        return std::string{};
    }
    LOG_DEBUG("Uploading model to RAM: " + filename);
    auto start = std::chrono::steady_clock::now();
    mModels[filename] = std::make_shared<MeshDataGpu>(filePath.string(), mRenderer);
 
    const size_t sizeVertices = mModels.at(filename)->GetCpuVertexBufferSize();
    mTotalSizeRAM += sizeVertices;
    const size_t sizeIndices = mModels.at(filename)->GetCpuIndexBufferSize();
    mTotalSizeRAM += sizeIndices;
    auto end = std::chrono::steady_clock::now();
    float ms = std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_DEBUG("Model loaded to RAM: " + filename +
        " (Vertices+Indices: " +
        std::to_string(sizeVertices + sizeIndices) +
        " bytes, " + std::to_string(ms) + " ms)");
    return filename;
}

Member Data Documentation

◆ mModels

std::unordered_map<std::string, std::shared_ptr<MeshDataGpu> > rendering_engine::ModelCache::mModels

protected

Definition at line 158 of file model_cache.hpp.

◆ mRenderer

IRenderer* rendering_engine::ModelCache::mRenderer

protected

Definition at line 157 of file model_cache.hpp.

◆ mTotalSizeGPU

size_t rendering_engine::ModelCache::mTotalSizeGPU

protected

Definition at line 161 of file model_cache.hpp.

◆ mTotalSizeRAM

size_t rendering_engine::ModelCache::mTotalSizeRAM

protected

Definition at line 160 of file model_cache.hpp.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ModelCache()

◆ ~ModelCache()

Member Function Documentation

◆ CreateQuad2D()

◆ GetMeshRenderResources()

◆ GetMeshResources()

◆ GetSizeInGPU()

◆ GetSizeInRAM()

◆ LoadCustomMesh()

◆ LoadModelsFromFolder()

◆ LoadModelsFromPackage()

◆ OnRenderResourcesRebuild()

◆ OnRenderResourcesRelease()

◆ ReleaseAll()

◆ ReleaseAllFromGPU()

◆ ReleaseModelFromGPU()

◆ UploadModelToGPU()

◆ UploadModelToRAM() [1/2]

◆ UploadModelToRAM() [2/2]

Member Data Documentation

◆ mModels

◆ mRenderer

◆ mTotalSizeGPU

◆ mTotalSizeRAM