SceneManager.h

Go to the documentation of this file.

// File: SceneManager.h
// Description: Manages loading and unloading scenes, is an ancestor to every entity
// Author(s): Aidan Hartman (aidan.hartman@digipen.edu) Base Implementation
//            Marcelo Escamilla (marcelo.escamilla@digipen.edu) ImGui Integration
// 2025 / 10 / 20
// (C) Digipen 2025
// SceneManager.h
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
 
#include "Framework/System.h"
 
class Scene;
class Node;
 
 
struct SceneState
{
    enum state : char
    {
        T        = 'T',
        F        = 'F',
        noEffect = 'o'
    };
 
    state renders  = noEffect;
    state updates  = noEffect;
    state messages = noEffect;
 
    friend auto to_json(json& j, const SceneState& p) -> void
    {
        j = json{
                {"renders", p.renders},
                {"updates", p.updates},
                {"messages", p.messages}
        };
 
    }
 
    friend auto from_json(const json& j, SceneState& p) -> void
    {
        j.at("renders").get_to(p.renders);
        j.at("updates").get_to(p.updates);
        j.at("messages").get_to(p.messages);
    }
};
 
namespace sys
{
class SceneManager : public System
{
public:
    friend Scene;
 
#pragma region static_functions

    static auto getEnum() -> Type
    {
        return Type::SceneManager;
    }

    static auto LoadScene(std::unique_ptr<Node> scene) -> void;

    static auto LoadScene(const std::string& name) -> void;
 
#pragma endregion
 
    SceneManager();
    ~SceneManager() override = default;
    SceneManager(const SceneManager& other);
    SceneManager(SceneManager&& other) noexcept;
    auto operator=(const SceneManager& other) -> SceneManager&;
    auto operator=(SceneManager&& other) noexcept -> SceneManager&;
 
 
#pragma region overridden_functions
 
    auto clone() const -> std::unique_ptr<GameObject> override
    {
        return std::make_unique<SceneManager>(*this);
    }
 
protected:
    auto systemShowMenu() -> void override;
 
public:
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override
    {
    }; // for debug ImGUI
    auto onRender() -> void override;
    auto load(Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;
    auto saveScene(Stream& stream) const -> void;
    [[nodiscard("adding child may fail")]] auto addChild(std::unique_ptr<GameObject> newChild) -> bool override;
 
#pragma endregion
 
#pragma region SceneManager_functions
 

    auto loadScene(std::unique_ptr<Node> scene) -> void;

    auto loadScene(const std::string& name) -> void;

    auto getCurrentScene() const -> GameObject*;
 
    auto registerScene(Scene& scene) -> void;
    auto deregisterScene(Scene& scene) -> void;
 
 
#pragma endregion
 
#pragma region messaging_functions
 
    auto linkMessages() -> void;
    auto receiveResetKeyPressed(const Message* message) -> Message;
 
#pragma endregion
 
private:
#pragma region member_variables
 
    std::vector<Scene*> scenes;
 
#pragma endregion
 
#pragma region helper_functions

    auto pushCorrectState(const Scene& sceneToKeep, SceneState newState, SceneState keepSceneState,
                          std::vector<Scene*>::iterator::value_type scene) -> void;
    auto toAllSceneChildren(Scene* parent, std::function<void(Scene*)> func) -> void;
    auto pushStateToOtherScenes(const Scene& sceneToKeep, SceneState othersState, SceneState keepSceneState) -> void;
 
 
    auto popAllScenes(const Scene& sceneToKeep) -> void;
 
#pragma endregion
 
#pragma region static_variables
 
#pragma endregion
 
 
};
}