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. More...

	~MaterialCache ()
	Destructor. Automatically unregisters from the renderer. More...

void	CreateBuildInMaterials ()
	Creates built-in materials for testing or demonstration. More...

void	AddMaterial (MaterialSettings matSettings)
	Adds a new Material instance using the provided settings. More...

Material *	GetMaterial (std::string materialName)
	Retrieves a pointer to a Material instance by name. More...

void	RemoveMaterial (std::string materialName)
	Removes a material from the cache. More...

void	ReleaseAll ()
	Releases all GPU resources associated with cached materials. 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< 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 11 of file material_cache.cpp.

    :
    mRenderer(renderer)
{
    LOG_DEBUG("MaterialCache created.");
    mRenderer->RegisterObserver(this);
}

◆ ~MaterialCache()

rendering_engine::MaterialCache::~MaterialCache ( )

Destructor. Automatically unregisters from the renderer.

Definition at line 19 of file material_cache.cpp.

{
    LOG_DEBUG("MaterialCache destroyed.");
    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 99 of file material_cache.cpp.

{
    if (matSettings.materialName.empty())
    {
        LOG_ERROR("Attempted to add material with empty name.");
        return;
    }
 
    auto it = mMaterials.find(matSettings.materialName);
    if (it != mMaterials.end() && it->second)
    {
        LOG_WARNING("Replacing existing material: " + matSettings.materialName);
        it->second->ReleaseRenderResources();
    }
 
    mMaterials[matSettings.materialName] =
        std::make_shared<Material>(mRenderer, matSettings);
    LOG_DEBUG("Material added: " + matSettings.materialName);
}

◆ 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 25 of file material_cache.cpp.

{
    LOG_INFO("Creating built-in materials...");
    auto start = std::chrono::steady_clock::now();
    // 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");
    }
    LOG_DEBUG("Creating material: BasicTexture3D");
    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");
    }
    LOG_DEBUG("Creating material: FlatColorFiltering");
    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");
    }
    LOG_DEBUG("Creating material: Quad2D");
    testSprite2dMat->InitializeRenderResources();
 
    MaterialSettings rectangle2D;
    rectangle2D.materialName = std::string{ "Rectangle2D" };
    rectangle2D.materialDomain = MaterialDomain::Sprite2D;
    rectangle2D.shadingModel = ShadingModel::Unlit;
    rectangle2D.blendMode = BlendMode::Translucent;
    rectangle2D.parameterLayout = &Rectangle2DLayout;
 
    AddMaterial(rectangle2D);
    Material* rectangle2DMat = GetMaterial(rectangle2D.materialName);
    rectangle2DMat->SetVec4("Color", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
    LOG_DEBUG("Creating material: Rectangle2D");
    rectangle2DMat->InitializeRenderResources();
 
    auto end = std::chrono::steady_clock::now();
    float totalMs =
        std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("Built-in materials created in " +
        std::to_string(totalMs) + " ms.");
}

◆ 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 119 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 153 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 145 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 139 of file material_cache.cpp.

{
    LOG_INFO("Releasing all materials.");
    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 129 of file material_cache.cpp.

{
    if (auto it = mMaterials.find(materialName); it != mMaterials.end())
    {
        LOG_INFO("Removing material: " + materialName);
        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:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MaterialCache()

◆ ~MaterialCache()

Member Function Documentation

◆ AddMaterial()

◆ CreateBuildInMaterials()

◆ GetMaterial()

◆ OnRenderResourcesRebuild()

◆ OnRenderResourcesRelease()

◆ ReleaseAll()

◆ RemoveMaterial()

Member Data Documentation

◆ mMaterials

◆ mRenderer