rendering_engine::SceneManager Class Reference

Manages scenes, resource caches, and scene transitions within the rendering engine. More...

#include <scene_manager.hpp>

Public Types
using	Factory = std::function<std::unique_ptr<Scene>(SceneManager&)>

Public Member Functions
	SceneManager (IRenderer *renderer, IApplication *app)
	Constructs a SceneManager instance.
	~SceneManager ()
	Destructor. Cleans up resources and active scenes.
virtual void	Initialize ()
	Initializes the current scene and related caches.
virtual void	Update (float deltaTime)
	Updates the currently active scene.
virtual void	Draw ()
	Draws the active scene using the associated renderer.
virtual void	Shutdown ()
	Releases all scene-related resources and shuts down the manager.
IApplication *	GetApplication ()
	Returns the application associated with this SceneManager.
void	LoadScene (std::string sceneName)
	Loads a new scene by name.
RenderResourceContext	GetRenderResourceContext () const
	Retrieves the current RenderResourceContext.

Static Public Member Functions
static std::vector< std::pair< std::string, Factory > > &	GetPendingRegistrations ()
	Type alias for the factory used to create scenes.
static bool	RegisterScene (const std::string &name, Factory factory)
	Registers a scene type with a name string.
static std::unique_ptr< Scene >	CreateScene (const std::string &name, SceneManager &sm)
	Creates a scene instance by its registered name.

Static Public Attributes
static std::string	sStartSceneName

Detailed Description

Manages scenes, resource caches, and scene transitions within the rendering engine.

SceneManager handles the creation, updating, and rendering of scenes. It maintains ownership of core caches (TextureCache, ModelCache, MaterialCache), and provides the RenderResourceContext that allows drawable objects to access shared rendering resources.

The class also supports dynamic scene registration through factories, enabling runtime creation of scenes by name.

See also

Scene, RenderResourceContext, TextureCache, ModelCache, MaterialCache

Definition at line 41 of file scene_manager.hpp.

Member Typedef Documentation

Factory

using rendering_engine::SceneManager::Factory = std::function<std::unique_ptr<Scene>(SceneManager&)>

Definition at line 44 of file scene_manager.hpp.

Constructor & Destructor Documentation

SceneManager()

rendering_engine::SceneManager::SceneManager	(	IRenderer *	renderer,
		IApplication *	app )

Constructs a SceneManager instance.

Parameters

renderer	Pointer to the active renderer instance.
app	Pointer to the owning application instance.

Definition at line 13 of file scene_manager.cpp.

    :
    mRenderer(renderer),
    mApp(app),
    mCurrentScene(nullptr),
    mNextScene(nullptr)
{}

~SceneManager()

rendering_engine::SceneManager::~SceneManager

(

)

Destructor. Cleans up resources and active scenes.

Definition at line 21 of file scene_manager.cpp.

{
}

Member Function Documentation

CreateScene()

std::unique_ptr< Scene > rendering_engine::SceneManager::CreateScene ( const std::string & name, SceneManager & sm )

static

Creates a scene instance by its registered name.

Parameters

name	The name of the registered scene type.
sm	Reference to the SceneManager creating the scene.

Returns

Unique pointer to the newly created Scene instance.

Definition at line 145 of file scene_manager.cpp.

{
    std::unique_ptr<Scene> scene = nullptr;
    auto& map = GetMap();
    auto it = map.find(name);
    if (it != map.end())
    {
        scene = (it->second)(sm);
    }
    return scene;
}

Draw()

void rendering_engine::SceneManager::Draw ( )

virtual

Draws the active scene using the associated renderer.

Definition at line 93 of file scene_manager.cpp.

{
    if (mCurrentScene)
    {
        mCurrentScene->Draw();
    }
}

GetApplication()

IApplication * rendering_engine::SceneManager::GetApplication

(

)

Returns the application associated with this SceneManager.

Returns

Pointer to the IApplication instance.

Definition at line 112 of file scene_manager.cpp.

{
    return mApp;
}

GetPendingRegistrations()

std::vector< std::pair< std::string, SceneManager::Factory > > & rendering_engine::SceneManager::GetPendingRegistrations ( )

static

Type alias for the factory used to create scenes.

Definition at line 117 of file scene_manager.cpp.

{
    static std::vector<std::pair<std::string, Factory>> pending;
    return pending;
}

GetRenderResourceContext()

RenderResourceContext rendering_engine::SceneManager::GetRenderResourceContext

(

)

const

Retrieves the current RenderResourceContext.

The RenderResourceContext provides references to shared caches (material, model, texture) and allows drawable objects to access resources during initialization and rendering.

Returns

A RenderResourceContext structure populated with shared cache pointers.

Definition at line 128 of file scene_manager.cpp.

{
    RenderResourceContext rrc;
    rrc.renderer = mRenderer;
    rrc.meshCache = mModelCache.get();
    rrc.textureCache = mTextureCache.get();
    rrc.materialCache = mMaterialCache.get();
 
    return rrc;
}

Initialize()

void rendering_engine::SceneManager::Initialize ( )

virtual

Initializes the current scene and related caches.

Definition at line 25 of file scene_manager.cpp.

{
    // Apply pending registrations once (first initialization only)
    static bool sRegistrationsApplied = false;
    if (!sRegistrationsApplied)
    {
        auto& pending = GetPendingRegistrations();
        for (auto& entry : pending)
        {
            RegisterScene(entry.first, entry.second);
        }
        pending.clear();
        sRegistrationsApplied = true;
    }
    // Innitialize resources in next order.
    // 1. Textures
    // 2. Models
    // 3. Materials
    mTextureCache = std::make_shared<TextureCache>(mRenderer);
    mModelCache = std::make_shared<ModelCache>(mRenderer);
    const auto modelsFolder = Utility::GetModelsFolderPath();
    mModelCache->CreateQuad2D();
 
    if (Utility::IsPackageProvided())
    {
        mTextureCache->LoadTexturesFromPackage();
        mModelCache->LoadModelsFromPackage();
    }
    else
    {
        const auto textureFolder = Utility::GetTextureFolderPath();
        mTextureCache->LoadTexturesFromFolder(textureFolder.string());
        mModelCache->LoadModelsFromFolder(modelsFolder.string());
    }
    mMaterialCache = std::make_shared<MaterialCache>(mRenderer);
    mMaterialCache->CreateBuildInMaterials();
 
    if(!GetMap().empty())
    {
        const std::string startScene = sStartSceneName;
 
        if(!startScene.empty())
        {
            LoadScene(startScene);
        }
    }
}

LoadScene()

void rendering_engine::SceneManager::LoadScene

(

std::string

sceneName

)

Loads a new scene by name.

Parameters

sceneName

The name of the registered scene to load.

If the scene has been registered via SceneAutoRegistrar, it will be instantiated and prepared for initialization on the next update.

Definition at line 123 of file scene_manager.cpp.

{
    mNextScene = CreateScene(sceneName, *this);
}

RegisterScene()

bool rendering_engine::SceneManager::RegisterScene ( const std::string & name, Factory factory )

static

Registers a scene type with a name string.

Parameters

name	Unique string identifier for the scene.
factory	Function that constructs the scene when requested.

Returns

True if registration succeeded, false if a scene with the same name already exists.

Note

Typically used via the REG_SCENE() macro.

Definition at line 139 of file scene_manager.cpp.

{
    auto& map = GetMap();
    return map.emplace(name, std::move(factory)).second;
}

Shutdown()

void rendering_engine::SceneManager::Shutdown ( )

virtual

Releases all scene-related resources and shuts down the manager.

Definition at line 101 of file scene_manager.cpp.

{
    if (mCurrentScene)
    {
        mCurrentScene->Shutdown();
    }
    mMaterialCache->ReleaseAll();
    mModelCache->ReleaseAll();
    mTextureCache->ReleaseAll();
}

Update()

void rendering_engine::SceneManager::Update ( float deltaTime )

virtual

Updates the currently active scene.

Parameters

deltaTime

Time elapsed since the previous frame, in milliseconds.

Definition at line 73 of file scene_manager.cpp.

{
    if (mNextScene)
    {
        if (mCurrentScene)
        {
            mCurrentScene->Shutdown();
        }
 
        mCurrentScene = std::move(mNextScene);
        mCurrentScene->Initialize();
        mNextScene = nullptr;
    }
 
    if (mCurrentScene)
    {
        mCurrentScene->Update(deltaTime);
    }
}

Member Data Documentation

sStartSceneName

std::string rendering_engine::SceneManager::sStartSceneName

inlinestatic

Definition at line 126 of file scene_manager.hpp.

---

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

• scene_manager.hpp
• scene_manager.cpp