Collision perf: first test collcab aabb with actor aabb.

When searching for colliding nodes in the pre-buffered `contactable_point_pool`, first check if the collcab AABB intersects with the 'collision partner' actor's AABB, only then search the actor's nodes for intersection.
To do this, we need to know where each actor starts and ends in the `contactable_point_pool`. For this purpose, `struct ColActor` was added.

Author: ohlidalp

source/main/ForwardDeclarations.h

@@ -101,6 +101,8 @@ namespace RoR
     struct GuiManagerImpl;
     class  HydraxWater;
     class  InputEngine;
+    class  InterPointColDetector;
+    class  IntraPointColDetector;
     class  IWater;
     class  Landusemap;
     class  LanguageEngine;

source/main/physics/Actor.cpp

@@ -938,12 +938,13 @@ Vector3 Actor::calculateCollisionOffset(Vector3 direction)
                     node_t* na = &actor->ar_nodes[actor->ar_cabs[tmpv + 1]];
                     node_t* nb = &actor->ar_nodes[actor->ar_cabs[tmpv + 2]];
 
-                    m_intra_point_col_detector->query(no->AbsPosition - collision_offset,
+                    collision = m_intra_point_col_detector->QueryCollisionsWithAllPartners(
+                        no->AbsPosition - collision_offset,
                         na->AbsPosition - collision_offset,
                         nb->AbsPosition - collision_offset,
                         actor->ar_collision_range * 3.0f);
 
-                    if (collision = !m_intra_point_col_detector->hit_list.empty())
+                    if (collision)
                         break;
                 }
 
@@ -988,12 +989,13 @@ Vector3 Actor::calculateCollisionOffset(Vector3 direction)
                 node_t* na = &ar_nodes[ar_cabs[tmpv + 1]];
                 node_t* nb = &ar_nodes[ar_cabs[tmpv + 2]];
 
-                m_inter_point_col_detector->query(no->AbsPosition + collision_offset,
+                collision = m_inter_point_col_detector->QueryCollisionsWithAllPartners(
+                    no->AbsPosition + collision_offset,
                     na->AbsPosition + collision_offset,
                     nb->AbsPosition + collision_offset,
                     ar_collision_range * 3.0f);
 
-                if (collision = !m_inter_point_col_detector->hit_list.empty())
+                if (collision)
                     break;
             }
         }

source/main/physics/Actor.h

@@ -533,8 +533,8 @@ class Actor : public RefCountingObject<Actor>
     int               m_num_proped_wheels = 0;          //!< Physics attr, filled at spawn - Number of propelled wheels.
     float             m_avg_proped_wheel_radius = 0.f;    //!< Physics attr, filled at spawn - Average proped wheel radius.
     float             m_avionic_chatter_timer = 11.f;      //!< Sound fx state (some pseudo random number,  doesn't matter)
-    PointColDetector* m_inter_point_col_detector = nullptr;   //!< Physics
-    PointColDetector* m_intra_point_col_detector = nullptr;   //!< Physics
+    InterPointColDetector* m_inter_point_col_detector = nullptr;   //!< Physics
+    IntraPointColDetector* m_intra_point_col_detector = nullptr;   //!< Physics
 
     Ogre::Vector3     m_avg_node_position = Ogre::Vector3::ZERO;          //!< average node position
     Ogre::Real        m_min_camera_radius = 0.f;

source/main/physics/ActorSpawner.cpp

@@ -370,12 +370,12 @@ void ActorSpawner::InitializeRig()
 
     if (!App::sim_no_collisions->getBool())
     {
-        m_actor->m_inter_point_col_detector = new PointColDetector(m_actor);
+        m_actor->m_inter_point_col_detector = new InterPointColDetector(m_actor);
     }
 
     if (!App::sim_no_self_collisions->getBool())
     {
-        m_actor->m_intra_point_col_detector = new PointColDetector(m_actor);
+        m_actor->m_intra_point_col_detector = new IntraPointColDetector(m_actor);
     }
 
     m_actor->ar_submesh_ground_model = App::GetGameContext()->GetTerrain()->GetCollisions()->defaultgm;

source/main/physics/collision/DynamicCollisions.cpp

@@ -114,8 +114,8 @@ void ResolveCollisionForces(const float penetration_depth,
     no.Forces      -= forcevec * gamma;
 }
 
-
-void RoR::ResolveInterActorCollisions(const float dt, PointColDetector &interPointCD,
+// STUPID OLD CODE: all the following params always belong to the same actor, see `ActorManager::UpdatePhysicsSimulation()`
+void RoR::ResolveInterActorCollisions(const float dt, InterPointColDetector &interPointCD,
         const int free_collcab, int collcabs[], int cabs[],
         collcab_rate_t inter_collcabrate[], node_t nodes[],
         const float collrange,
@@ -137,69 +137,73 @@ void RoR::ResolveInterActorCollisions(const float dt, PointColDetector &interPoi
         const auto na = &nodes[cabs[tmpv+1]];
         const auto nb = &nodes[cabs[tmpv+2]];
 
-        interPointCD.query(no->AbsPosition
-                , na->AbsPosition
-                , nb->AbsPosition, collrange);
+        Ogre::AxisAlignedBox collcab_box;
+        collcab_box.merge(no->AbsPosition);
+        collcab_box.merge(na->AbsPosition);
+        collcab_box.merge(nb->AbsPosition);
+        collcab_box.setMinimum(collcab_box.getMinimum() - collrange);
+        collcab_box.setMaximum(collcab_box.getMaximum() + collrange);
 
-        if (!interPointCD.hit_list.empty())
+        for (const PointColDetector::ColActor& partner: interPointCD.collision_partners)
         {
-            // setup transformation of points to triangle local coordinates
-            const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
-            const CartesianToTriangleTransform transform(triangle);
-
-            for (ColPointID_t i_hit : interPointCD.hit_list)
+            if (interPointCD.QueryCollisionsWithSinglePartner(collcab_box, partner))
             {
-                const PointColDetector::ColPoint& h = interPointCD.contactable_point_pool[i_hit];
-                const ActorPtr& hit_actor = App::GetGameContext()->GetActorManager()->GetActorById(h.actorid);
-                node_t& hitnode = hit_actor->ar_nodes[h.nodenum];
+                // setup transformation of points to triangle local coordinates
+                const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
+                const CartesianToTriangleTransform transform(triangle);
 
-                // transform point to triangle local coordinates
-                const auto local_point = transform(hitnode.AbsPosition);
-
-                // collision test
-                const bool is_colliding = InsideTriangleTest(local_point, collrange);
-                if (is_colliding)
+                for (NodeNum_t hitnode_num: interPointCD.hit_list)
                 {
-                    inter_collcabrate[i].rate = 0;
+                    node_t& hitnode = partner.actor->ar_nodes[hitnode_num];
 
-                    const auto coord = local_point.barycentric;
-                    auto distance   = local_point.distance;
-                    auto normal     = triangle.normal();
+                    // transform point to triangle local coordinates
+                    const auto local_point = transform(hitnode.AbsPosition);
 
-                    // adapt in case the collision is occuring on the backface of the triangle
-                    const auto neighbour_node_ids = hit_actor->ar_node_to_node_connections[h.nodenum];
-                    const bool is_backface = BackfaceCollisionTest(distance, normal, *no, neighbour_node_ids, hit_actor->ar_nodes);
-                    if (is_backface)
+                    // collision test
+                    const bool is_colliding = InsideTriangleTest(local_point, collrange);
+                    if (is_colliding)
                     {
-                        // flip surface normal and distance to triangle plane
-                        normal   = -normal;
-                        distance = -distance;
+                        inter_collcabrate[i].rate = 0;
+
+                        const auto coord = local_point.barycentric;
+                        auto distance   = local_point.distance;
+                        auto normal     = triangle.normal();
+
+                        // adapt in case the collision is occuring on the backface of the triangle
+                        const auto neighbour_node_ids = partner.actor->ar_node_to_node_connections[hitnode_num];
+                        const bool is_backface = BackfaceCollisionTest(distance, normal, *no, neighbour_node_ids, partner.actor->ar_nodes);
+                        if (is_backface)
+                        {
+                            // flip surface normal and distance to triangle plane
+                            normal   = -normal;
+                            distance = -distance;
+                        }
+
+                        const auto penetration_depth = collrange - distance;
+
+                        const bool remote = (partner.actor->ar_state == ActorState::NETWORKED_OK);
+
+                        ResolveCollisionForces(penetration_depth, hitnode, *na, *nb, *no, coord.alpha,
+                                coord.beta, coord.gamma, normal, dt, remote, submesh_ground_model);
+
+                        hitnode.nd_last_collision_gm = &submesh_ground_model;
+                        hitnode.nd_has_mesh_contact = true;
+                        na->nd_has_mesh_contact = true;
+                        nb->nd_has_mesh_contact = true;
+                        no->nd_has_mesh_contact = true;
                     }
-
-                    const auto penetration_depth = collrange - distance;
-
-                    const bool remote = (hit_actor->ar_state == ActorState::NETWORKED_OK);
-
-                    ResolveCollisionForces(penetration_depth, hitnode, *na, *nb, *no, coord.alpha,
-                            coord.beta, coord.gamma, normal, dt, remote, submesh_ground_model);
-
-                    hitnode.nd_last_collision_gm = &submesh_ground_model;
-                    hitnode.nd_has_mesh_contact = true;
-                    na->nd_has_mesh_contact = true;
-                    nb->nd_has_mesh_contact = true;
-                    no->nd_has_mesh_contact = true;
                 }
             }
-        }
-        else
-        {
-            inter_collcabrate[i].rate++;
+            else
+            {
+                inter_collcabrate[i].rate++;
+            }
         }
     }
 }
 
-
-void RoR::ResolveIntraActorCollisions(const float dt, PointColDetector &intraPointCD,
+// STUPID OLD CODE: all the following params always belong to the same actor, see `Actor::CalcCabCollisions()`
+void RoR::ResolveIntraActorCollisions(const float dt, IntraPointColDetector &intraPointCD,
         const int free_collcab, int collcabs[], int cabs[],
         collcab_rate_t intra_collcabrate[], node_t nodes[],
         const float collrange,
@@ -224,64 +228,67 @@ void RoR::ResolveIntraActorCollisions(const float dt, PointColDetector &intraPoi
         const auto na = &nodes[cabs[tmpv+1]];
         const auto nb = &nodes[cabs[tmpv+2]];
 
-        intraPointCD.query(no->AbsPosition
-                , na->AbsPosition
-                , nb->AbsPosition, collrange);
+        Ogre::AxisAlignedBox collcab_box;
+        collcab_box.merge(no->AbsPosition);
+        collcab_box.merge(na->AbsPosition);
+        collcab_box.merge(nb->AbsPosition);
+        collcab_box.setMinimum(collcab_box.getMinimum() - collrange);
+        collcab_box.setMaximum(collcab_box.getMaximum() + collrange);
 
         bool collision = false;
-
-        if (!intraPointCD.hit_list.empty())
+        for (const PointColDetector::ColActor& partner: intraPointCD.collision_partners)
         {
-            // setup transformation of points to triangle local coordinates
-            const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
-            const CartesianToTriangleTransform transform(triangle);
-
-            for (ColPointID_t i_hit : intraPointCD.hit_list)
+            if (intraPointCD.QueryCollisionsWithSinglePartner(collcab_box, partner))
             {
-                const PointColDetector::ColPoint& h = intraPointCD.contactable_point_pool[i_hit];
-                const ActorPtr& hit_actor = App::GetGameContext()->GetActorManager()->GetActorById(h.actorid);
-                node_t& hitnode = hit_actor->ar_nodes[h.nodenum];
-
-                //ignore wheel/chassis self contact
-                if (hitnode.nd_tyre_node) continue;
-                if (no == &hitnode || na == &hitnode || nb == &hitnode) continue;
+                // setup transformation of points to triangle local coordinates
+                const Triangle triangle(na->AbsPosition, nb->AbsPosition, no->AbsPosition);
+                const CartesianToTriangleTransform transform(triangle);
 
-                // transform point to triangle local coordinates
-                const auto local_point = transform(hitnode.AbsPosition);
-
-                // collision test
-                const bool is_colliding = InsideTriangleTest(local_point, collrange);
-                if (is_colliding)
+                for (NodeNum_t hitnode_num: intraPointCD.hit_list)
                 {
-                    collision = true;
+                    node_t& hitnode = partner.actor->ar_nodes[hitnode_num];
+
+                    //ignore wheel/chassis self contact
+                    if (hitnode.nd_tyre_node) continue;
+                    if (no == &hitnode || na == &hitnode || nb == &hitnode) continue;
 
-                    const auto coord = local_point.barycentric;
-                    auto distance = local_point.distance;
-                    auto normal   = triangle.normal();
+                    // transform point to triangle local coordinates
+                    const auto local_point = transform(hitnode.AbsPosition);
 
-                    // adapt in case the collision is occuring on the backface of the triangle
-                    if (distance < 0) 
+                    // collision test
+                    const bool is_colliding = InsideTriangleTest(local_point, collrange);
+                    if (is_colliding)
                     {
-                        // flip surface normal and distance to triangle plane
-                        normal   = -normal;
-                        distance = -distance;
-                    }
+                        collision = true;
+
+                        const auto coord = local_point.barycentric;
+                        auto distance = local_point.distance;
+                        auto normal   = triangle.normal();
 
-                    const auto penetration_depth = collrange - distance;
+                        // adapt in case the collision is occuring on the backface of the triangle
+                        if (distance < 0) 
+                        {
+                            // flip surface normal and distance to triangle plane
+                            normal   = -normal;
+                            distance = -distance;
+                        }
 
-                    ResolveCollisionForces(penetration_depth, hitnode, *na, *nb, *no, coord.alpha,
-                            coord.beta, coord.gamma, normal, dt, false, submesh_ground_model);
+                        const auto penetration_depth = collrange - distance;
+
+                        ResolveCollisionForces(penetration_depth, hitnode, *na, *nb, *no, coord.alpha,
+                                coord.beta, coord.gamma, normal, dt, false, submesh_ground_model);
+                    }
                 }
             }
-        }
 
-        if (collision)
-        {
-            intra_collcabrate[i].rate = -20000;
-        }
-        else
-        {
-            intra_collcabrate[i].rate++;
+            if (collision)
+            {
+                intra_collcabrate[i].rate = -20000;
+            }
+            else
+            {
+                intra_collcabrate[i].rate++;
+            }
         }
     }
 }

source/main/physics/collision/DynamicCollisions.h

@@ -32,13 +32,13 @@ namespace RoR {
 /// @addtogroup Collisions
 /// @{
 
-void ResolveInterActorCollisions(const float dt, PointColDetector &interPointCD,
+void ResolveInterActorCollisions(const float dt, InterPointColDetector &interPointCD,
         const int free_collcab, int collcabs[], int cabs[],
         collcab_rate_t inter_collcabrate[], node_t nodes[],
         const float collrange,
         ground_model_t &submesh_ground_model);
 
-void ResolveIntraActorCollisions(const float dt, PointColDetector &intraPointCD,
+void ResolveIntraActorCollisions(const float dt, IntraPointColDetector &intraPointCD,
         const int free_collcab, int collcabs[], int cabs[],
         collcab_rate_t intra_collcabrate[], node_t nodes[],
         const float collrange,