feat: implement contact listeners

destrum/src/Scene/Scene.cpp

@@ -23,7 +23,12 @@ namespace {
 }
 
 Scene::Scene(const std::string& name)
-    : m_name(name),
+    : Scene(name, std::make_unique<JoltPhysicsWorld>()) {
+}
+
+Scene::Scene(const std::string& name, std::unique_ptr<PhysicsWorld> physicsWorld)
+    : m_Physics(std::move(physicsWorld)),
+      m_name(name),
       m_id(++m_idCounter) {
 }
 

destrum/src/Scene/SceneManager.cpp

@@ -8,50 +8,40 @@
 #include <destrum/Util/DeltaTime.h>
 
 Scene& SceneManager::GetCurrentScene() const {
-    if (m_scenes.empty()) {
-        throw std::out_of_range("No scenes are available");
+    if (m_activeScenes.empty()) {
+        throw std::out_of_range("No active scenes are available");
     }
-
-    if (m_ActiveSceneIndex < 0 || m_ActiveSceneIndex >= static_cast<int>(m_scenes.size())) {
-        throw std::out_of_range("Active scene index is invalid");
-    }
-
-    return *m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)];
+    return *m_activeScenes.front();
 }
 
 void SceneManager::Update(float dt) {
-    if (m_scenes.empty()) return;
-    (void)GetCurrentScene();
-    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
-    scene->Update(dt);
+    for (const auto& scene : m_activeScenes) {
+        scene->Update(dt);
+    }
 }
 
 void SceneManager::FixedUpdate(float dt) {
-    if (m_scenes.empty()) return;
-    (void)GetCurrentScene();
-    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
-    scene->FixedUpdate(dt);
+    for (const auto& scene : m_activeScenes) {
+        scene->FixedUpdate(dt);
+    }
 }
 
 void SceneManager::LateUpdate(float dt) {
-    if (m_scenes.empty()) return;
-    (void)GetCurrentScene();
-    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
-    scene->LateUpdate(dt);
+    for (const auto& scene : m_activeScenes) {
+        scene->LateUpdate(dt);
+    }
 }
 
 void SceneManager::Render(const RenderContext& ctx) {
-    if (m_scenes.empty()) return;
-    (void)GetCurrentScene();
-    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
-    scene->Render(ctx);
+    for (const auto& scene : m_activeScenes) {
+        scene->Render(ctx);
+    }
 }
 
 void SceneManager::RenderImgui() {
-    if (m_scenes.empty()) return;
-    (void)GetCurrentScene();
-    const auto scene = m_scenes.at(static_cast<std::size_t>(m_ActiveSceneIndex));
-    scene->RenderImgui();
+    for (const auto& scene : m_activeScenes) {
+        scene->RenderImgui();
+    }
 }
 
 void SceneManager::HandleGameObjectDestroy() {
@@ -61,7 +51,7 @@ void SceneManager::HandleGameObjectDestroy() {
 }
 
 void SceneManager::DestroyGameObjects() {
-    for (const auto& scene: m_scenes) {
+    for (const auto& scene : m_scenes) {
         scene->DestroyGameObjects();
     }
 }
@@ -73,37 +63,22 @@ void SceneManager::UnloadAllScenes() {
 }
 
 void SceneManager::HandleSceneDestroy() {
-    const std::shared_ptr<Scene> activeScene =
-        m_ActiveSceneIndex >= 0 &&
-        m_ActiveSceneIndex < static_cast<int>(m_scenes.size())
-            ? m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]
-            : nullptr;
-
     for (auto it = m_scenes.begin(); it != m_scenes.end();) {
         if ((*it)->IsBeingUnloaded()) {
+            const auto activeIt = std::find(m_activeScenes.begin(), m_activeScenes.end(), *it);
+            if (activeIt != m_activeScenes.end()) {
+                m_activeScenes.erase(activeIt);
+            }
             it = m_scenes.erase(it);
         } else {
             ++it;
         }
     }
 
-    if (m_scenes.empty()) {
-        m_ActiveSceneIndex = 0;
-        return;
-    }
-
-    if (activeScene != nullptr) {
-        const auto activeIt = std::find(m_scenes.begin(), m_scenes.end(), activeScene);
-        if (activeIt != m_scenes.end()) {
-            m_ActiveSceneIndex = static_cast<int>(std::distance(m_scenes.begin(), activeIt));
-            return;
-        }
-    }
-
-    m_ActiveSceneIndex = std::clamp(
-        m_ActiveSceneIndex,
-        0,
-        static_cast<int>(m_scenes.size()) - 1);
+    // Remove any stale active scenes that are no longer in the scene list.
+    std::erase_if(m_activeScenes, [this](const auto& scene) {
+        return std::find(m_scenes.begin(), m_scenes.end(), scene) == m_scenes.end();
+    });
 }
 
 void SceneManager::HandleScene() {
@@ -113,7 +88,6 @@ void SceneManager::HandleScene() {
 
 void SceneManager::Destroy() {
     if (m_scenes.empty()) {
-        m_ActiveSceneIndex = 0;
         return;
     }
 
@@ -124,25 +98,60 @@ void SceneManager::Destroy() {
 }
 
 void SceneManager::SwitchScene(int index) {
-    // InputManager::GetInstance().RemoveAllBindings();
-
     if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
         throw std::out_of_range("Scene index out of range");
     }
-    if (index == m_ActiveSceneIndex) {
-        return;
-    }
 
-    m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]->UnloadBindings();
-    m_ActiveSceneIndex = index;
-    m_scenes[static_cast<std::size_t>(m_ActiveSceneIndex)]->LoadBindings();
+    for (const auto& scene : m_activeScenes) {
+        scene->UnloadBindings();
+    }
+    m_activeScenes.clear();
+    m_activeScenes.push_back(m_scenes[static_cast<std::size_t>(index)]);
+    m_activeScenes.back()->LoadBindings();
 }
 
-Scene &SceneManager::CreateScene(const std::string &name) {
+void SceneManager::AddActiveScene(int index) {
+    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
+        throw std::out_of_range("Scene index out of range");
+    }
+
+    const auto& scene = m_scenes[static_cast<std::size_t>(index)];
+    if (std::find(m_activeScenes.begin(), m_activeScenes.end(), scene) == m_activeScenes.end()) {
+        scene->LoadBindings();
+        m_activeScenes.push_back(scene);
+    }
+}
+
+void SceneManager::RemoveActiveScene(int index) {
+    if (index < 0 || index >= static_cast<int>(m_scenes.size())) {
+        throw std::out_of_range("Scene index out of range");
+    }
+
+    const auto& scene = m_scenes[static_cast<std::size_t>(index)];
+    const auto it = std::find(m_activeScenes.begin(), m_activeScenes.end(), scene);
+    if (it != m_activeScenes.end()) {
+        (*it)->UnloadBindings();
+        m_activeScenes.erase(it);
+    }
+}
+
+int SceneManager::GetActiveSceneId() const {
+    if (m_scenes.empty() || m_activeScenes.empty()) {
+        return -1;
+    }
+
+    const auto it = std::find(m_scenes.begin(), m_scenes.end(), m_activeScenes.front());
+    if (it == m_scenes.end()) {
+        return -1;
+    }
+    return static_cast<int>(std::distance(m_scenes.begin(), it));
+}
+
+Scene& SceneManager::CreateScene(const std::string& name) {
     const auto scene = std::shared_ptr<Scene>(new Scene(name));
     m_scenes.push_back(scene);
     if (m_scenes.size() == 1) {
-        m_ActiveSceneIndex = 0;
+        m_activeScenes.push_back(scene);
     }
     return *scene;
-}
+}