rendering_engine::ModelCache Class Reference

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.
	~ModelCache ()
	Destructor. Releases all resources and unregisters observer.
void	LoadModelsFromFolder (std::string pathToFolder)
	Load all models found in the specified folder into RAM.
void	LoadModelsFromPackage ()
	Load all models from the packed asset container.
void	CreateQuad2D ()
	Creates a built-in 2D quad mesh.
std::string	UploadModelToRAM (std::string path)
	Load a single model from file into RAM.
std::string	UploadModelToRAM (std::string fileName, std::vector< uint8_t > const &fileBytes)
	Load a single model into RAM from a raw file buffer.
void	UploadModelToGPU (std::string filename)
	Upload a cached model's mesh data to the GPU.
void	ReleaseModelFromGPU (std::string filename)
	Release a model's mesh data from GPU memory.
void	ReleaseAllFromGPU ()
	Release all model mesh data from GPU memory.
void	ReleaseAll ()
	Remove all models from both GPU and RAM, clearing the cache.
std::shared_ptr< MeshDataGpu >	GetMeshResources (std::string filename)
	Get a shared pointer to the MeshDataGpu for a model.
IMeshRenderResources *	GetMeshRenderResources (std::string filename)
	Get the IMeshRenderResources interface for a model's GPU resources.
size_t	GetSizeInRAM () const
	Get the total size (in bytes) of all models loaded in RAM.
size_t	GetSizeInGPU () const
	Get the total size (in bytes) of all models currently resident on GPU.
Public Member Functions inherited from rendering_engine::IRendererObserver
virtual	~IRendererObserver ()=default
	Virtual destructor.

Protected Member Functions
void	OnRenderResourcesRelease () override
	Renderer callback: release all GPU resources (used during device loss/reset).
void	OnRenderResourcesRebuild () override
	Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild).

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 27 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 10 of file model_cache.cpp.

    :
    mRenderer(renderer),
    mTotalSizeRAM(0),
    mTotalSizeGPU(0)
{
    mRenderer->RegisterObserver(this);
}

~ModelCache()

rendering_engine::ModelCache::~ModelCache

(

)

Destructor. Releases all resources and unregisters observer.

Definition at line 19 of file model_cache.cpp.

{
    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 67 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 190 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 180 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 205 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 200 of file model_cache.cpp.

{
    return mTotalSizeRAM;
}

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 24 of file model_cache.cpp.

{
    // 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());
    }
}

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 41 of file model_cache.cpp.

{
    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())
            {
                std::cerr << "[TextureCache] Could not read packed texture: "
                    << virtualPath << std::endl;
                continue;
            }
 
            // Upload to RAM with textureName + binaryFileData
            (void)UploadModelToRAM(modelName, binaryFileData);
        }
    }
}

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 215 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 210 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 173 of file model_cache.cpp.

{
    mModels.clear();
    mTotalSizeRAM = 0;
    mTotalSizeGPU = 0;
}

ReleaseAllFromGPU()

void rendering_engine::ModelCache::ReleaseAllFromGPU

(

)

Release all model mesh data from GPU memory.

Definition at line 164 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 148 of file model_cache.cpp.

{
    if (auto search = mModels.find(filename); search == mModels.end())
    {
        return;
    }
 
    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 129 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;
    }
 
    mModels[filename]->UploadToGPU();
    size_t sizeVertices = mModels[filename]->GetGpuVertexBufferSize();
    mTotalSizeGPU += sizeVertices;
    size_t sizeIndices = mModels[filename]->GetGpuIndexBufferSize();
    mTotalSizeGPU += sizeIndices;
}

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 109 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{};
    }
 
    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;
 
    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 78 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{};
    }
    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;
 
    return filename;
}

Member Data Documentation

mModels

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

protected

Definition at line 150 of file model_cache.hpp.

mRenderer

IRenderer* rendering_engine::ModelCache::mRenderer

protected

Definition at line 149 of file model_cache.hpp.

mTotalSizeGPU

size_t rendering_engine::ModelCache::mTotalSizeGPU

protected

Definition at line 153 of file model_cache.hpp.

mTotalSizeRAM

size_t rendering_engine::ModelCache::mTotalSizeRAM

protected

Definition at line 152 of file model_cache.hpp.

---

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

• model_cache.hpp
• model_cache.cpp