[collision-solver] Avoid code duplication

Author: IAmNotHanni

include/inexor/vulkan-renderer/world/collision_solver.hpp

@@ -19,11 +19,24 @@ class OctreeCollisionSolver {
     std::vector<std::pair<std::shared_ptr<world::Cube>, float>> m_collision_candidates{};
     std::shared_mutex m_collision_solver_mutex;
 
+    /// @brief Find all collisions between the given ray and the given octrees, sorted by increasing distance between
+    /// the octree and the camera.
+    /// @param worlds The octrees to check for collision
+    /// @param position The start position of the ray
+    /// @param direction The direction vector of the ray
+    /// @return A vector of the found collisions. If no collisions were found, the vector is empty.
+    [[nodiscard]] std::vector<RayCubeCollision<Cube>>
+    find_all_ray_octree_collisions(const std::vector<std::shared_ptr<world::Cube>> &worlds, glm::vec3 position,
+                                   glm::vec3 direction, bool find_only_one_collision = true);
+
 public:
     /// @brief Default constructor.
     /// @param octree_count The number of octrees
     explicit OctreeCollisionSolver(std::size_t octree_count);
 
+    // TODO: Implement min/max collision distance if required.
+    // TODO: Start sorting only after a certain number of worlds.
+
     /// @brief Find a collision between a ray and an octree which is closest to the camera.
     /// @param worlds The octrees to check for collision
     /// @param position The start position of the ray

src/vulkan-renderer/world/collision_solver.cpp

@@ -14,52 +14,10 @@ OctreeCollisionSolver::OctreeCollisionSolver(const std::size_t octree_count) {
     m_collision_candidates.reserve(octree_count);
 }
 
-std::optional<RayCubeCollision<Cube>>
-OctreeCollisionSolver::find_ray_octree_collision(const std::vector<std::shared_ptr<world::Cube>> &worlds,
-                                                 const glm::vec3 position, const glm::vec3 direction) {
-
-    if (worlds.empty()) {
-        return std::nullopt;
-    }
-
-    // We need a critical section because we are modifying m_collision_candidates.
-    std::scoped_lock lock(m_collision_solver_mutex);
-    {
-        for (const auto &world : worlds) {
-            if (!is_bounding_box_and_bounding_sphere_hit(world, position, direction)) {
-                continue;
-            }
-
-            // TODO: Implement min/max collision distance if required.
-            m_collision_candidates.emplace_back(std::make_pair(world, glm::distance2(position, direction)));
-        }
-
-        // TODO: Start sorting only after a certain number of worlds.
-        // Sort the octree collision candidates by increasing square of distance between cube center and camera.
-        std::sort(m_collision_candidates.begin(), m_collision_candidates.end(),
-                  [](const auto &lhs, const auto &rhs) { return lhs.second < rhs.second; });
-
-        // Check for collision between camera ray and every octree whose bounding box and bounding sphere is hit in
-        // order of increasing squared distance between camera and octree's center.
-        for (const auto &collision_candidate : m_collision_candidates) {
-
-            // Do not make this const auto as we want to return it. This could prevent automatic move semantics.
-            auto collision = ray_cube_collision_check(collision_candidate.first, position, direction);
-
-            if (collision) {
-                return collision;
-            }
-        }
-    }
-    // End of critical section.
-
-    // No collision found with the bounding sphere or bounding box of any of the octrees.
-    return std::nullopt;
-}
-
 std::vector<RayCubeCollision<Cube>>
 OctreeCollisionSolver::find_all_ray_octree_collisions(const std::vector<std::shared_ptr<world::Cube>> &worlds,
-                                                      const glm::vec3 position, const glm::vec3 direction) {
+                                                      const glm::vec3 position, const glm::vec3 direction,
+                                                      bool find_only_one_collision) {
     if (worlds.empty()) {
         return {};
     }
@@ -76,11 +34,9 @@ OctreeCollisionSolver::find_all_ray_octree_collisions(const std::vector<std::sha
                 continue;
             }
 
-            // TODO: Implement min/max collision distance if required.
             m_collision_candidates.emplace_back(std::make_pair(world, glm::distance2(position, direction)));
         }
 
-        // TODO: Start sorting only after a certain number of worlds.
         // Sort the octree collision candidates by increasing square of distance between cube center and camera.
         std::sort(m_collision_candidates.begin(), m_collision_candidates.end(),
                   [](const auto &lhs, const auto &rhs) { return lhs.second < rhs.second; });
@@ -94,6 +50,10 @@ OctreeCollisionSolver::find_all_ray_octree_collisions(const std::vector<std::sha
 
             if (collision) {
                 found_collisions.emplace_back(collision.value());
+
+                if (find_only_one_collision) {
+                    return std::move(found_collisions);
+                }
             }
         }
     }
@@ -102,4 +62,22 @@ OctreeCollisionSolver::find_all_ray_octree_collisions(const std::vector<std::sha
     return std::move(found_collisions);
 }
 
+std::optional<RayCubeCollision<Cube>>
+OctreeCollisionSolver::find_ray_octree_collision(const std::vector<std::shared_ptr<world::Cube>> &worlds,
+                                                 const glm::vec3 position, const glm::vec3 direction) {
+    const auto result = find_all_ray_octree_collisions(worlds, position, direction, true);
+
+    if (!result.empty()) {
+        return result[0];
+    }
+
+    return std::nullopt;
+}
+
+std::vector<RayCubeCollision<Cube>>
+OctreeCollisionSolver::find_all_ray_octree_collisions(const std::vector<std::shared_ptr<world::Cube>> &worlds,
+                                                      const glm::vec3 position, const glm::vec3 direction) {
+    return find_all_ray_octree_collisions(worlds, position, direction, false);
+}
+
 } // namespace inexor::vulkan_renderer::world