rendering_engine::MaterialCache Class Reference

Manages creation, storage, and lifecycle of Material objects within the rendering engine. More...

#include <material_cache.hpp>

Inherits rendering_engine::IRendererObserver.

Public Member Functions
	MaterialCache (IRenderer *renderer)
	Constructs a MaterialCache and registers it as a renderer observer.
	~MaterialCache ()
	Destructor. Automatically unregisters from the renderer.
void	CreateBuildInMaterials ()
	Creates built-in materials for testing or demonstration.
void	AddMaterial (MaterialSettings matSettings)
	Adds a new Material instance using the provided settings.
Material *	GetMaterial (std::string materialName)
	Retrieves a pointer to a Material instance by name.
void	RemoveMaterial (std::string materialName)
	Removes a material from the cache.
void	ReleaseAll ()
	Releases all GPU resources associated with cached materials.
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< Material > >	mMaterials

Detailed Description

Manages creation, storage, and lifecycle of Material objects within the rendering engine.

MaterialCache serves as a centralized system to instantiate, store, and retrieve materials used in the engine. It supports both manually added materials and, in the future, loading materials from JSON definitions.

See also

Jira EPIC: MAT-101 - Node-Based Material Editor

It observes renderer events (such as swapchain recreation) to reinitialize or release GPU resources tied to materials.

Definition at line 29 of file material_cache.hpp.

Constructor & Destructor Documentation

MaterialCache()

rendering_engine::MaterialCache::MaterialCache

(

IRenderer *

renderer

)

Constructs a MaterialCache and registers it as a renderer observer.

Parameters

renderer

Pointer to the renderer interface used for creating GPU resources.

Definition at line 9 of file material_cache.cpp.

    :
    mRenderer(renderer)
{
    mRenderer->RegisterObserver(this);
}

~MaterialCache()

rendering_engine::MaterialCache::~MaterialCache

(

)

Destructor. Automatically unregisters from the renderer.

Definition at line 16 of file material_cache.cpp.

{
    mRenderer->UnregisterObserver(this);
}

Member Function Documentation

AddMaterial()

void rendering_engine::MaterialCache::AddMaterial

(

MaterialSettings

matSettings

)

Adds a new Material instance using the provided settings.

Parameters

matSettings

MaterialSettings struct containing metadata and configuration for the new material.

If a material with the same name already exists, it will be replaced.

Definition at line 71 of file material_cache.cpp.

{
    if (matSettings.materialName.empty())
    {
        // Log incorrect material name
        return;
    }
    mMaterials[matSettings.materialName] = std::make_shared<Material>(mRenderer, matSettings);
}

CreateBuildInMaterials()

void rendering_engine::MaterialCache::CreateBuildInMaterials

(

)

Creates built-in materials for testing or demonstration.

This is a temporary function to manually define materials in code. In the future, materials will be created by parsing JSON files from a materials folder.

Definition at line 21 of file material_cache.cpp.

{
    // BasicTexture3D material
    MaterialSettings setBasicTexture3D;
    setBasicTexture3D.materialName = std::string{ "BasicTexture3D" };
    setBasicTexture3D.materialDomain = MaterialDomain::Surface3D;
    setBasicTexture3D.shadingModel = ShadingModel::Unlit;
    setBasicTexture3D.blendMode = BlendMode::Opaque;
 
    AddMaterial(setBasicTexture3D);
    Material* basicTexture3DMat = GetMaterial(setBasicTexture3D.materialName);
    if (basicTexture3DMat)
    {
        basicTexture3DMat->AddTexture("test_cube_color");
        //basicTexture3DMat->AddTexture("PNG_transparency_demonstration_1");
    }
    basicTexture3DMat->InitializeRenderResources();
 
    // FlatColorFiltering material
    MaterialSettings setFlatColorFiltering;
    setFlatColorFiltering.materialName = std::string{ "FlatColorFiltering" };
    setFlatColorFiltering.materialDomain = MaterialDomain::Surface3D;
    setFlatColorFiltering.shadingModel = ShadingModel::Unlit;
    setFlatColorFiltering.blendMode = BlendMode::Opaque;
    
    AddMaterial(setFlatColorFiltering);
    Material* flatColorFilteringMat = GetMaterial(setFlatColorFiltering.materialName);
    if (flatColorFilteringMat)
    {
        flatColorFilteringMat->AddTexture("D4FontTextureSegoeScript");
    }
    flatColorFilteringMat->InitializeRenderResources();
 
    // Test sprite 2d
    MaterialSettings setTestSprite2d;
    setTestSprite2d.materialName = std::string{ "Quad2D" };
    setTestSprite2d.materialDomain = MaterialDomain::Sprite2D;
    setTestSprite2d.shadingModel = ShadingModel::Unlit;
    setTestSprite2d.blendMode = BlendMode::Opaque;
 
    AddMaterial(setTestSprite2d);
    Material* testSprite2dMat = GetMaterial(setTestSprite2d.materialName);
    if (testSprite2dMat)
    {
        testSprite2dMat->AddTexture("PNG_transparency_demonstration_1");
    }
 
    testSprite2dMat->InitializeRenderResources();
}

GetMaterial()

Material * rendering_engine::MaterialCache::GetMaterial

(

std::string

materialName

)

Retrieves a pointer to a Material instance by name.

Parameters

materialName

Name of the material to retrieve.

Returns

Pointer to the Material instance, or nullptr if not found.

Definition at line 81 of file material_cache.cpp.

{
    if (auto search = mMaterials.find(materialName); search == mMaterials.end())
    {
        return nullptr;
    }
 
    return mMaterials.at(materialName).get();
}

OnRenderResourcesRebuild()

void rendering_engine::MaterialCache::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 113 of file material_cache.cpp.

{
    for (auto& material : mMaterials)
    {
        material.second->InitializeRenderResources();
    }
}

OnRenderResourcesRelease()

void rendering_engine::MaterialCache::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 105 of file material_cache.cpp.

{
    for (auto& material : mMaterials)
    {
        material.second->ReleaseRenderResources();
    }
}

ReleaseAll()

void rendering_engine::MaterialCache::ReleaseAll

(

)

Releases all GPU resources associated with cached materials.

Iterates through every material in the cache and calls their resource release routines, freeing descriptor set layouts, pipelines, and any other backend allocations. Unlike RemoveMaterial, this does not erase the material records themselves from the cache, only their GPU-side resources.

• Use when unloading a scene or before destroying the renderer to ensure all GPU resources are released in a controlled manner.
• After calling this, materials remain in the cache but are not renderable until OnRenderResourcesRebuild (or per-material reinitialization) is performed.
• Safe to call multiple times; redundant calls will have no effect once resources are released.

See also

RemoveMaterial()

OnRenderResourcesRelease()

OnRenderResourcesRebuild()

Definition at line 100 of file material_cache.cpp.

{
    OnRenderResourcesRelease();
}

RemoveMaterial()

void rendering_engine::MaterialCache::RemoveMaterial

(

std::string

materialName

)

Removes a material from the cache.

Parameters

materialName

Name of the material to remove.

Definition at line 91 of file material_cache.cpp.

{
    if (auto it = mMaterials.find(materialName); it != mMaterials.end())
    {
        it->second->ReleaseRenderResources();
        mMaterials.erase(it);
    }
}

Member Data Documentation

mMaterials

std::unordered_map<std::string, std::shared_ptr<Material> > rendering_engine::MaterialCache::mMaterials

protected

Definition at line 106 of file material_cache.hpp.

mRenderer

IRenderer* rendering_engine::MaterialCache::mRenderer

protected

Definition at line 105 of file material_cache.hpp.

---

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

• material_cache.hpp
• material_cache.cpp