[application] Iterate through root octrees in order of increasing square of distance to camera

Author: IAmNotHanni

include/inexor/vulkan-renderer/application.hpp

@@ -32,6 +32,15 @@ class Application : public VulkanRenderer {
     /// Inexor engine supports a variable number of octrees.
     std::vector<std::shared_ptr<world::Cube>> m_worlds;
 
+    /// If multiple root octrees exist, we check for collisions between camera ray and octree by increasing square of
+    /// the distance between the camera and the root octree's center. This way, we check for collisions with the nearest
+    /// root octrees first. Furthermore, we avoid using a sqrt function for distance calculation, which is an expensive
+    /// calculation to perform.
+    /// The first value of the std::pair is the index in the m_worlds vector, the second value is the square of the
+    /// distance betweeen the camera and the root octree's center.
+    /// We do not perform any memory allocations on m_collision_candidates as long as m_worlds does not change.
+    std::vector<std::pair<std::size_t, float>> m_collision_candidates;
+
     // If the user specified command line argument "--stop-on-validation-message", the program will call
     // std::abort(); after reporting a validation layer (error) message.
     bool m_stop_on_validation_message{false};

src/vulkan-renderer/application.cpp

@@ -200,6 +200,9 @@ void Application::load_octree_geometry(bool initialize) {
     m_worlds.push_back(
         world::create_random_world(2, {10.0f, 0.0f, 0.0f}, initialize ? std::optional(60) : std::nullopt));
 
+    // Reserve memory for collision checks
+    m_collision_candidates.reserve(m_worlds.size());
+
     m_octree_vertices.clear();
     for (const auto &world : m_worlds) {
         for (const auto &polygons : world->polygons(true)) {
@@ -575,22 +578,49 @@ void Application::process_mouse_input() {
 }
 
 void Application::check_octree_collisions() {
-    // Check for collision between camera ray and every octree
-    for (const auto &world : m_worlds) {
-        const auto collision = ray_cube_collision_check(*world, m_camera->position(), m_camera->front());
+    std::size_t candidate_count = 0;
+
+    for (std::size_t i = 0; i < m_worlds.size(); i++) {
+        if (!ray_cube_collision_check(*m_worlds[i], m_camera->position(), m_camera->front())) {
+            continue;
+        }
 
-        if (collision) {
-            const auto intersection = collision.value().intersection();
-            const auto face_normal = collision.value().face();
-            const auto corner = collision.value().corner();
-            const auto edge = collision.value().edge();
+        // Calculate the square of the distance between the octree root's center and the camera
+        const float squared_distance = glm::distance2(m_worlds[i]->center(), m_camera->position());
 
-            spdlog::trace("pos {} {} {} | face {} {} {} | corner {} {} {} | edge {} {} {}", intersection.x,
-                          intersection.y, intersection.z, face_normal.x, face_normal.y, face_normal.z, corner.x,
-                          corner.y, corner.z, edge.x, edge.y, edge.z);
+        // We use the current candidate count as index for filling the vector
+        m_collision_candidates[candidate_count] = std::make_pair(i, squared_distance);
 
-            // Break after one collision.
-            break;
+        // Increment candidate count
+        candidate_count++;
+    }
+
+    // Sort candidates for collisions between camera ray and root octrees by increasing square of the distance between
+    // camera and the root octree's center
+    std::sort(m_collision_candidates.begin(), m_collision_candidates.end(),
+              [](const auto &lhs, const auto &rhs) { return lhs.second < rhs.second; });
+
+    // Loop through all collision candidates in order of increasing square of distance between camera and otree' center
+    // Note that we are only looping through every element of m_worlds in the worst case
+    // This would be the case if all root octrees are in collision with the camera ray
+    for (std::size_t candidate_index = 0; candidate_index < candidate_count; candidate_index++) {
+        if (const auto collision = ray_cube_collision_check(*m_worlds[m_collision_candidates[candidate_index].first],
+                                                            m_camera->position(), m_camera->front())) {
+            if (collision) {
+                const auto &coll = collision.value();
+                const auto intersection = coll.intersection();
+                const auto face_normal = coll.face();
+                const auto corner = coll.corner();
+                const auto edge = coll.edge();
+
+                spdlog::trace("octree #{} | pos {} {} {} | face {} {} {} | corner {} {} {} | edge {} {} {}",
+                              m_collision_candidates[candidate_index].first, intersection.x, intersection.y,
+                              intersection.z, face_normal.x, face_normal.y, face_normal.z, corner.x, corner.y, corner.z,
+                              edge.x, edge.y, edge.z);
+
+                // Stop after one collision
+                break;
+            }
         }
     }
 }