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. More...
	~SceneManager ()
	Destructor. Cleans up resources and active scenes. More...
virtual void	Initialize ()
	Initializes the current scene and related caches. More...
virtual void	Update (float deltaTime)
	Updates the currently active scene. More...
virtual void	Draw ()
	Draws the active scene using the associated renderer. More...
virtual void	Shutdown ()
	Releases all scene-related resources and shuts down the manager. More...
IApplication *	GetApplication ()
	Returns the application associated with this SceneManager. More...
void	LoadScene (std::string sceneName)
	Loads a new scene by name. More...
RenderResourceContext	GetRenderResourceContext () const
	Retrieves the current RenderResourceContext. More...
std::shared_ptr< TextRenderer >	GetTextRenderer ()

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

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 42 of file scene_manager.hpp.

Member Typedef Documentation

Factory

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

Definition at line 45 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 17 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 25 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 181 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 128 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 148 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 153 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 164 of file scene_manager.cpp.

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

GetTextRenderer()

std::shared_ptr< TextRenderer > rendering_engine::SceneManager::GetTextRenderer

(

)

Definition at line 193 of file scene_manager.cpp.

{
    return mTextRenderer;
}

Initialize()

void rendering_engine::SceneManager::Initialize ( )

virtual

Initializes the current scene and related caches.

Definition at line 29 of file scene_manager.cpp.

{
    const auto start = std::chrono::steady_clock::now();
 
    // 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);
    mModelCache->CreateQuad2D();
 
    mMaterialCache = std::make_shared<MaterialCache>(mRenderer);
    mMaterialCache->CreateBuildInMaterials();
 
    mTextRenderer = std::make_shared<TextRenderer>(GetRenderResourceContext());
    mTextRenderer->StoreFontAtlasesInFiles(false);
 
    if (Utility::IsPackageProvided())
    {
        LOG_INFO("Loading assets from package.");
        mTextureCache->LoadTexturesFromPackage();
        mModelCache->LoadModelsFromPackage();
        mTextRenderer->LoadFontsFromPackage();
    }
    else
    {
        LOG_INFO("Loading assets from folders.");
        const auto textureFolder = Utility::GetTextureFolderPath();
        mTextureCache->LoadTexturesFromFolder(textureFolder.string());
        const auto modelsFolder = Utility::GetModelsFolderPath();
        mModelCache->LoadModelsFromFolder(modelsFolder.string());
        const auto fontsFolder = Utility::GetFontsFolderPath();
        mTextRenderer->LoadFontsFromFolder(fontsFolder.string());
    }
 
    if(!GetMap().empty())
    {
        const std::string startScene = sStartSceneName;
 
        if(!startScene.empty())
        {
            LoadScene(startScene);
        }
    }
    const auto end = std::chrono::steady_clock::now();
    const float initMs =
        std::chrono::duration<float, std::milli>(end - start).count();
 
    LOG_INFO("SceneManager initialized in " +
        std::to_string(initMs) + " ms.");
}

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 159 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 175 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 136 of file scene_manager.cpp.

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

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 94 of file scene_manager.cpp.

{
    if (mNextScene)
    {
        using clock = std::chrono::steady_clock;
        auto start = clock::now();
 
        std::string oldSceneName = mCurrentScene ? typeid(*mCurrentScene).name() : "None";
        std::string newSceneName = typeid(*mNextScene).name();
 
        if (mCurrentScene)
        {
            mCurrentScene->Shutdown();
        }
 
        mCurrentScene = std::move(mNextScene);
 
        LOG_INFO("Switching scene: " + oldSceneName + " -> " + newSceneName);
 
        mCurrentScene->Initialize();
        mNextScene = nullptr;
 
        auto end = clock::now();
        auto durationMs = std::chrono::duration<float, std::milli>(end - start).count();
 
        LOG_INFO("Scene '" + newSceneName + "' loaded in " + std::to_string(durationMs) + " ms");
    }
 
    if (mCurrentScene)
    {
        mCurrentScene->Update(deltaTime);
    }
}

Member Data Documentation

sStartSceneName

std::string rendering_engine::SceneManager::sStartSceneName

inlinestatic

Definition at line 129 of file scene_manager.hpp.

---

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

• scene_manager.hpp
• scene_manager.cpp