Scene.h

#pragma once
 
#include "Actor.h"
#include "Engine/Asset/AssetRegistry.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Entity/EntityContainer.h"
#include "Engine/Entity/SpawnContext.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Entity.h"
 
#include <filesystem>
#include <memory>
#include <optional>
#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;

    struct SceneLightingSettings
    {
        float sunBrightness = 2.65f;
        float shInfluence = 0.40f;
        float lightmapSunRemoval = 0.35f;
        float lightmapBrightness = 1.0f;
    };
 
    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 <class T, typename... Args>
        T* spawnEntity(Args&&... args)
        {
            static_assert(std::is_base_of_v<Entities::Entity, T>, "T must derive from Entity");
            TRACY_ZONE_SCOPED_NAMED("Spawn entity of class");
 
            return entities_.spawnEntity<T>(std::forward<Args>(args)...);
        }

        void destroyEntity(Entity* entity );

        template<class 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};
 
                auto actor = std::make_unique<T>(context, std::forward<Args>(args)...);
                T* rawPtr = actor.get();
                rawPtr->sceneNode = node;
                return entities_.adoptEntity(std::move(actor));
            } catch (const std::exception &e) {
                throw std::runtime_error("Failed to spawn actor: " + std::string(e.what()));
            }
        }

        template<typename T, typename... Args>
        T* spawnActorAttached(
            const Ecs::Transform& localTransform,
            Actor& parent,
            Args&&... args
        ) {
            return spawnActorAttached<T>( localTransform, parent.getSceneNode(), std::forward<Args>( args )... );
        }

        template<typename T, typename... Args>
        T* spawnActorAttached(
            const Ecs::Transform& localTransform,
            const std::shared_ptr<SceneNode>& parentNode,
            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::spawnActorAttached must be constructible as "
                "T(const SpawnContext&, ...actorSpecificArgs)."
            );
            TRACY_ZONE_SCOPED_NAMED("Spawned attached actor of class");
 
            try {
                if (!sceneGraph || !parentNode) {
                    throw std::runtime_error("Failed to spawn attached Actor with parent node");
                }
 
                std::shared_ptr<Entities::SceneNode> node = NodeFactory::createNode(parentNode, false);
                node->setLocalModelMatrix(localTransform.matrix);
                const SpawnContext context{node, this};
 
                auto actor = std::make_unique<T>(context, std::forward<Args>(args)...);
                T* rawPtr = actor.get();
                rawPtr->sceneNode = node;
                return entities_.adoptEntity(std::move(actor));
            } catch (const std::exception &e) {
                throw std::runtime_error("Failed to spawn attached 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();

        void flushPendingEntityDestruction();

        virtual void loadContent();

        virtual void unloadContent();

        [[nodiscard]] std::vector<Entities::Entity*> getEntities() const;

        template<typename Func>
        void forEachEntity(Func&& func) const
        {
            entities_.forEachEntity(std::forward<Func>(func));
        }

        [[nodiscard]] EntityContainer& getEntityContainer();

        [[nodiscard]] const EntityContainer& getEntityContainer() 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]] SceneGraph* getSceneGraph() const { return sceneGraph.get(); }

        void setLightingOverride( const SceneLightingSettings & settings ) { lightingOverride_ = settings; }

        void clearLightingOverride() { lightingOverride_.reset(); }
 
        [[nodiscard]] bool hasLightingOverride() const { return lightingOverride_.has_value(); }
        [[nodiscard]] SceneLightingSettings * getLightingOverride()
        {
            return lightingOverride_ ? &*lightingOverride_ : nullptr;
        }
        [[nodiscard]] const SceneLightingSettings * getLightingOverride() const
        {
            return lightingOverride_ ? &*lightingOverride_ : nullptr;
        }
 
    protected:
        Core::AssetManager * assetManager = nullptr;  
        Core::AssetRegistry * assetRegistry = nullptr;  
    private:
 
        std::unique_ptr<SceneGraph> sceneGraph;
 
        EntityContainer entities_;
        std::optional<SceneLightingSettings> lightingOverride_;
    };
}