Scene.h

Go to the documentation of this file.

#pragma once
 
#include "Actor.h"
#include "Engine/Asset/AssetRegistry.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Entity/SpawnContext.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;
    class AssetRegistry;
}  // namespace Engine::Core
 
namespace Engine::Entities {
    class Scene;
    class StaticMeshActor;
 
    namespace detail {
        struct GltfSpawnPlanData;
 
        struct GltfSpawnNode {
            Assets::GltfRenderableHandle renderable;
            Assets::GeometryMeshHandle geometryMesh;
            Asset::MeshPath         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 );
        GltfSpawnPlan prepareGltfSpawnPlan( Scene * scene, Assets::GltfHandle gltf );
 
        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");
            static_assert(
                std::is_constructible_v<T, const SpawnContext&, Args...>,
                "Actor types spawned with Scene::spawnActor must be constructible as "
                "T(const SpawnContext&, ...actorSpecificArgs)."
            );
            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);
                const SpawnContext context{node, this};
 
                T* rawPtr = new T(context, 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)
        {
            Core::AssetRegistry* registry = scene != nullptr ? scene->getAssetRegistry() : nullptr;
            if (registry != nullptr)
            {
                return spawnAll<ActorT>(scene, registry->gltfs().load(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;
        }
 
        template<typename ActorT = StaticMeshActor>
        static std::vector<ActorT*> spawnAll(
            Scene* scene,
            Assets::GltfHandle gltf)
        {
            detail::GltfSpawnPlan spawnPlan = detail::prepareGltfSpawnPlan(scene, gltf);
 
            std::vector<ActorT*> spawnedActors;
            spawnedActors.reserve(spawnPlan.meshNodes.size());
 
            for (detail::GltfSpawnNode& spawnNode : spawnPlan.meshNodes) {
                ActorT* actor = nullptr;
 
                if constexpr (std::is_constructible_v<ActorT, const SpawnContext&, Assets::GltfRenderableHandle>)
                {
                    if (spawnNode.renderable)
                    {
                        actor = scene->spawnActor<ActorT>(spawnNode.transform, spawnNode.renderable);
                    }
                }
 
                if (actor == nullptr)
                {
                    if constexpr (std::is_constructible_v<ActorT, const SpawnContext&, Assets::GeometryMeshHandle>)
                    {
                        if (spawnNode.geometryMesh)
                        {
                            actor = scene->spawnActor<ActorT>(spawnNode.transform, spawnNode.geometryMesh);
                        }
                    }
                }
 
                if (actor == nullptr)
                {
                    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);
        void destroyActorImmediate(Entities::Actor* actor);
        void flushPendingActorDestruction();
 
        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;
        [[nodiscard]] Core::AssetRegistry* getAssetRegistry() const;

        void setAssetManager( Core::AssetManager * manager);
        void setAssetRegistry( Core::AssetRegistry * registry);

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