Scene.h

Go to the documentation of this file.

#pragma once
 
#include "Actor.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Entity.h"
 
#include <filesystem>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace Engine
{
    class EngineKern;
}  // namespace Engine
 
namespace Engine::Core
{
    class AssetManager;
}  // namespace Engine::Core
 
namespace Engine::Entities {
    class Scene;
    class StaticMeshActor;
 
    namespace detail {
        struct GltfSpawnPlanData;
 
        struct GltfSpawnNode {
            Asset::Path         meshPath;
            Ecs::Transform transform;
            size_t              modelNodeIndex = 0;
        };
 
        struct GltfSpawnPlan {
            std::shared_ptr<const GltfSpawnPlanData> data;
            std::vector<GltfSpawnNode>               meshNodes;
        };
 
        GltfSpawnPlan prepareGltfSpawnPlan( Scene * scene, const std::filesystem::path & gltfPath );
 
        void applyGltfNodeExtensions(
            Actor *               actor,
            const GltfSpawnPlan & plan,
            const GltfSpawnNode & spawnNode
        );
    }  // namespace detail

    class Scene : public Core::ITickable {
    public:
        Scene();
        ~Scene() override;

        template<typename T, typename... Args>
        T* spawnActor(const Ecs::Transform& spawnTransform, Args&&... args) {
            static_assert(std::is_base_of_v<Entities::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<Entities::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()));
            }
        }

        template<typename ActorT = StaticMeshActor>
        static std::vector<ActorT*> spawnAll(
            Scene* scene,
            const std::filesystem::path& gltfPath)
        {
            detail::GltfSpawnPlan spawnPlan = detail::prepareGltfSpawnPlan( scene, gltfPath );
 
            std::vector<ActorT*> spawnedActors;
            spawnedActors.reserve( spawnPlan.meshNodes.size() );
 
            for ( detail::GltfSpawnNode & spawnNode : spawnPlan.meshNodes ) {
                auto* actor = scene->spawnActor<ActorT>(spawnNode.transform, std::move(spawnNode.meshPath));
                spawnedActors.push_back(actor);
                detail::applyGltfNodeExtensions( actor, spawnPlan, spawnNode );
            }
 
            return spawnedActors;
        }
 
        void destroyActor(Entities::Actor* actor);
 
        virtual void loadContent();
        virtual void unloadContent();
 
        [[nodiscard]] std::vector<Entities::Entity*> getEntities() const;

        void reserveActorCapacity(size_t additionalActors);
 
        void cleanup();
        [[nodiscard]] Core::SceneManager* getSceneManager() const;

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

        void setAssetManager( Core::AssetManager * manager);

        [[nodiscard]] EngineKern* getEngine() const { return engine_; }
        [[nodiscard]] SceneGraph* getSceneGraph() const { return sceneGraph.get(); }
 
    protected:
        EngineKern* engine_ = nullptr;
        Core::AssetManager * assetManager = nullptr;
    private:
 
        std::unique_ptr<SceneGraph> sceneGraph;
 
        std::vector<Entity*> entities;
    };
}