SceneManager.cpp

#include "components/SceneManager.hpp"
#include "components/GameComponents/ComponentFactory.hpp"
#include "components/GameComponents/BasicComponents.hpp"
#include "components/GameComponents/CharacterComponent.hpp"
#include "components/GameComponents/AudioSourceComponent.hpp"
#include "components/GameComponents/EngineUtility.hpp"
#include "components/GameComponents/UtilityComponents.hpp"
#include "components/GameComponents/BillboardComponent.hpp"
#include "components/GameComponents/ParticleEmitterComponent.hpp"
#include "components/GameObjects/GameObjectFactory.hpp"
#include "components/GameObjects/CameraObject.hpp"
#include "components/GameObjects/LightObject.hpp"
#include "components/GameObjects/FogObject.hpp"
#include "components/GameObjects/Creators/ModelCreator.hpp"
#include "components/PhysicsSystem.hpp"
#include "components/Environment.hpp"
#include "components/VirtualFileSystem.hpp"
#include "backends/vulkan/MeshManager.hpp"
#include "backends/vulkan/Interface.hpp"
#include <memory>
#include <nlohmann/json.hpp>
#include <cstdint>
#include <fstream>
#include <filesystem>
 
namespace vex {
 
    void to_json(nlohmann::json& j, const TransformComponent& t) {
            j = nlohmann::json{
                {"position", t.getLocalPosition()},
                {"rotation", t.getLocalRotation()},
                {"scale",    t.getLocalScale()}
            };
        }
 
        void from_json(const nlohmann::json& j, TransformComponent& t) {
            if(j.contains("position")) t.setLocalPosition(j["position"]);
            if(j.contains("rotation")) t.setLocalRotation(j["rotation"]);
            if(j.contains("scale"))    t.setLocalScale(j["scale"]);
        }
 
 
        void to_json(nlohmann::json& j, const MeshComponent& m) {
                j["path"] = m.meshData.meshPath;
                j["renderType"] = (int)m.renderType;
                j["color"] = m.color;
                j["textureOverrides"] = m.textureOverrides;
            }
 
            void from_json(const nlohmann::json& j, MeshComponent& m) {
                if (j.contains("path")) {
                    std::string path = j["path"];
                    m.meshData.meshPath = path;
                }
                if (j.contains("renderType")) m.renderType = (RenderType)j["renderType"];
                if (j.contains("color")) m.color = j["color"];
                if (j.contains("textureOverrides")) m.textureOverrides = j["textureOverrides"];
            }
 
 
        //REGISTER_COMPONENT(MeshComponent, meshData, renderType, color);
 
        #if DEBUG
        template<>
            void vex::GenericComponentInspector<vex::PhysicsComponent>(GameObject& obj) {
                std::string name = typeid(vex::PhysicsComponent).name();
                size_t lastColon = name.rfind("::");
                size_t lastBracket = name.find(']');
                std::string extracted = (lastColon != std::string::npos)
                    ? name.substr(lastColon + 2, (lastBracket != std::string::npos ? lastBracket : name.length()) - (lastColon + 2))
                    : name;
 
                ImGui::PushID(name.c_str());
                if (obj.HasComponent<vex::PhysicsComponent>()) {
                    if (ImGui::CollapsingHeader("PhysicsComponent", ImGuiTreeNodeFlags_DefaultOpen)) {
                        auto& pc = obj.GetComponent<vex::PhysicsComponent>();
                        bool changed = false;
 
                        if (ImReflect::Input("Shape", pc.shape).get<vex::ShapeType>().is_changed()) changed = true;
 
                        if (pc.shape == ShapeType::BOX){
                            changed |= ImGui::DragFloat3("Extents", &pc.boxHalfExtents.x);
                        } else if (pc.shape == ShapeType::ROUNDED_BOX){
                            changed |= ImGui::DragFloat3("Extents", &pc.boxHalfExtents.x);
                            changed |= ImGui::DragFloat("Radius", &pc.roundedRadius);
                        } else if (pc.shape == ShapeType::SPHERE) {
                            changed |= ImGui::DragFloat("Radius", &pc.sphereRadius);
                        } else if (pc.shape == ShapeType::CAPSULE){
                            changed |= ImGui::DragFloat2("Radius", &pc.capsuleRadius);
                            changed |= ImGui::DragFloat2("Height", &pc.capsuleHeight);
                        } else if (pc.shape == ShapeType::CYLINDER){
                            changed |= ImGui::DragFloat2("Radius", &pc.cylinderRadius);
                            changed |= ImGui::DragFloat2("Height", &pc.cylinderHeight);
                        }
 
                        if (ImReflect::Input("BodyType", pc.bodyType).get<vex::BodyType>().is_changed()) changed = true;
                        if (ImReflect::Input("Mass", pc.mass).get<float>().is_changed()) changed = true;
                        if (ImReflect::Input("Friction", pc.friction).get<float>().is_changed()) changed = true;
                        if (ImReflect::Input("Bounciness", pc.bounce).get<float>().is_changed()) changed = true;
                        if (ImReflect::Input("Linear Damping", pc.linearDamping).get<float>().is_changed()) changed = true;
                        if (ImReflect::Input("Angular Damping", pc.angularDamping).get<float>().is_changed()) changed = true;
                        if (ImReflect::Input("Sensor", pc.isSensor).get<bool>().is_changed()) changed = true;
                        if (ImReflect::Input("Allow Sleeping", pc.allowSleeping).get<bool>().is_changed()) changed = true;
                        if (ImReflect::Input("Draw Debug", pc.debugDraw).get<bool>().is_changed()) changed = true;
 
                        pc.updated = changed;
 
                        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.47f, 0.05f, 0.05f, 1.0f));
                        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.71f, 0.10f, 0.10f, 1.0f));
                        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.30f, 0.03f, 0.03f, 1.0f));
                        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.94f, 0.85f, 0.85f, 1.0f)); // White Text
 
                        if (ImGui::Button("Remove")) {
                            obj.GetEngine().getRegistry().remove<vex::PhysicsComponent>(obj.GetEntity());
                        }
 
                        ImGui::PopStyleColor(4);
                    }
                }
                ImGui::PopID();
            }
            #endif
 
 
 
                    #if DEBUG
                    template<>
                        void vex::GenericComponentInspector<vex::TransformComponent>(GameObject& obj) {
                            std::string name = typeid(vex::TransformComponent).name();
                            size_t lastColon = name.rfind("::");
                            size_t lastBracket = name.find(']');
                            std::string extracted = (lastColon != std::string::npos)
                                ? name.substr(lastColon + 2, (lastBracket != std::string::npos ? lastBracket : name.length()) - (lastColon + 2))
                                : name;
 
                            ImGui::PushID(name.c_str());
                            if (obj.HasComponent<vex::TransformComponent>()) {
                                if (ImGui::CollapsingHeader("TransformComponent", ImGuiTreeNodeFlags_DefaultOpen)) {
                                    auto& tc = obj.GetComponent<vex::TransformComponent>();
 
                                    if(( tc.rotation.x == 0 && tc.rotation.y == 0 && tc.rotation.z == 0 )&& (tc.getLocalRotation().x != 0 || tc.getLocalRotation().y != 0 || tc.getLocalRotation().z != 0)){
                                        tc.rotation = tc.getLocalRotation();
                                    }
 
                                    ImGui::DragFloat3("Position", &tc.position.x);
                                    ImGui::DragFloat3("Rotation", &tc.rotation.x);
                                    ImGui::DragFloat3("Scale", &tc.scale.x);
 
                                    tc.convertRot();
 
                                    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.47f, 0.05f, 0.05f, 1.0f));
                                    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.71f, 0.10f, 0.10f, 1.0f));
                                    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.30f, 0.03f, 0.03f, 1.0f));
                                    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.94f, 0.85f, 0.85f, 1.0f));
 
                                    if (ImGui::Button("Remove")) {
                                        obj.GetEngine().getRegistry().remove<vex::PhysicsComponent>(obj.GetEntity());
                                    }
 
                                    ImGui::PopStyleColor(4);
                                }
                            }
                            ImGui::PopID();
                        }
                        #endif
}
 
 
REGISTER_COMPONENT_CUSTOM(vex::TransformComponent, position, rotation, scale);
REGISTER_COMPONENT_CUSTOM(vex::MeshComponent, meshData, renderType, color, textureOverrides);
 
REGISTER_COMPONENT(vex::CameraComponent, fov, nearPlane, farPlane);
REGISTER_COMPONENT(vex::LightComponent, color, intensity, radius);
REGISTER_COMPONENT(vex::FogComponent, color, density, start, end);
REGISTER_COMPONENT(vex::CharacterComponent, standingHeight, standingRadius, mass, maxSlopeAngle);
REGISTER_COMPONENT(vex::AudioSourceComponent, audioFilePath, loop, is3D, autoPlay, volume, pitch, distance);
 
REGISTER_COMPONENT(vex::LifetimeComponent, lifespan);
REGISTER_COMPONENT(vex::OscillatorComponent, axis, amplitude, frequency, timeOffset);
REGISTER_COMPONENT(vex::TweenComponent, targetLocalOffset, duration, pingPong);
REGISTER_COMPONENT(vex::BillboardComponent, texturePath, size, color, isTransparent, isUnlit);
REGISTER_COMPONENT(vex::ParticleEmitterComponent, texturePath, isTransparent, isUnlit, active, spawnRate, spawnTimer, gravity, initialVelocity, velocityVariation, particleLife, particleLifeVariation, startSize, endSize, startColor, endColor);
 
//REGISTER_COMPONENT(vex::PhysicsComponent, shape, mass, friction, bounce, linearDamping, angularDamping, allowSleeping);
 
REGISTER_COMPONENT(vex::PhysicsComponent,
    shape,
    bodyType,
    isSensor,
    allowSleeping,
    debugDraw,
 
    mass,
    friction,
    bounce,
    linearDamping,
    angularDamping,
 
    boxHalfExtents,
    roundedRadius,
    sphereRadius,
    capsuleRadius,
    capsuleHeight,
    cylinderRadius,
    cylinderHeight
);
 
namespace vex {
 
    REGISTER_GAME_OBJECT(CameraObject);
    REGISTER_GAME_OBJECT(GameObject);
    REGISTER_GAME_OBJECT(LightObject);
    REGISTER_GAME_OBJECT(FogObject);
    REGISTER_GAME_OBJECT(ModelObject);
 
    void SceneManager::loadScene(const std::string& path, Engine& engine) {
        if (m_isUpdating) {
            m_pendingActions.push_back([this, path, &engine]() {
                clearScenes(engine);
                loadSceneWithoutClearing(path, engine);
            });
            return;
        }
 
        clearScenes(engine);
        loadSceneWithoutClearing(path, engine);
    }
 
void SceneManager::unloadScene(const std::string& path) {
    m_scenes.erase(path);
}
 
void SceneManager::loadSceneWithoutClearing(const std::string& path, Engine& engine) {
    lastSceneName = path;
    m_scenes.emplace(path, std::make_shared<Scene>(path, engine));
    m_scenes[path]->sceneBegin();
}
 
void SceneManager::clearScenes(Engine& engine) {
    engine.getInterface()->WaitForGPUToFinish();
    m_scenes.clear();
 
    auto& registry = engine.getRegistry();
    std::vector<vex::Entity> toDestroy;
 
    vex::View<NameComponent>(registry).each([&](vex::Entity entity, NameComponent& comp) {
        if (!registry.has<PersistentTag>(entity)) {
            toDestroy.push_back(entity);
        }
    });
 
    for (auto entity : toDestroy) {
        registry.destroy(entity);
    }
 
    engine.getInterface()->getMeshManager().clearState();
}
 
void SceneManager::scenesUpdate(float deltaTime){
    m_isUpdating = true;
    for (auto& scene : m_scenes) {
        scene.second->sceneUpdate(deltaTime);
    }
    m_isUpdating = false;
 
    if (!m_pendingActions.empty()) {
        for (auto& action : m_pendingActions) {
            action();
        }
        m_pendingActions.clear();
    }
}
 
std::vector<std::string> SceneManager::GetAllSceneNames() const {
    std::vector<std::string> names;
    names.reserve(m_scenes.size());
 
    for (const auto& [name, scene] : m_scenes) {
        names.push_back(name);
    }
 
    return names;
}
}