Scene.h

Go to the documentation of this file.

#pragma once
 
#include "Actor.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Entity.h"
 
namespace EngineCore {
    class Transform;
    class SceneManager;
    class SceneGraph;
    class Engine;
    class AssetManager;

    class Scene : public ITickable {
    public:
        Scene();
        virtual ~Scene();

        template<typename T, typename... Args>
        T* spawnActor(const Ecs::LocalTransform& spawnTransform, Args&&... args) {
            static_assert(std::is_base_of_v<Actor, T>, "T must derive from Actor");
            TRACY_ZONE_SCOPED_NAMED("Spawned actor of class");
 
            try {
                if (!sceneGraph) {
                    throw std::runtime_error("Failed to spawn Actor with world node");
                }
                std::shared_ptr<SceneNode> node = sceneGraph->createNode(spawnTransform, sceneGraph->getRoot(), false);
 
                T* rawPtr = new T(node, this, std::forward<Args>(args)...);
                entities.push_back(rawPtr);
 
                rawPtr->sceneNode = node;
                rawPtr->beginPlay();
 
                return rawPtr;
            } catch (const std::exception &e) {
                throw std::runtime_error("Failed to spawn actor: " + std::string(e.what()));
            }
        }
 
        void destroyActor(Actor* actor);
 
        virtual void loadContent();
        virtual void unloadContent();
 
        [[nodiscard]] std::vector<Entity*> getEntities() const;
 
        void cleanup();
        [[nodiscard]] SceneManager* getSceneManager() const;

        [[nodiscard]] AssetManager* getAssetManager() const;

        void setAssetManager(AssetManager* manager);

        [[nodiscard]] Engine* getEngine() const { return engine; }
 
    protected:
        Engine* engine = nullptr;
        AssetManager* assetManager = nullptr;
    private:
 
        std::unique_ptr<SceneGraph> sceneGraph;
 
        std::vector<Entity*> entities;
    };
}