Replace infinitely growing weak ptr vector with destruction event in physics engine

Flock/flock/src/FlockApp.cc

@@ -60,6 +60,8 @@ void FlockApp::startupGameCore()
 
     mParticleSystem = std::make_unique<ParticleSystem>();
     mParticleSystem->init();
+
+    mPhysicsEngine.init(mRegistry);
 }
 
 void FlockApp::loadLevel()

Flock/flock/src/logic/physics/PhysicsEngine.cc

@@ -3,22 +3,17 @@
 #include "PointQuery.hh"
 #include "Raycast.hh"
 
+void flock::PhysicsEngine::onSensorDestruction(entt::registry<uint32_t> &ecs, uint32_t entity)
+{
+    SensorC const &sensor = ecs.get<SensorC>(entity);
+    mScene.RemoveBody(sensor.sensor->body);
+}
+
 flock::PhysicsEngine::PhysicsEngine(float timestep) : mScene(q3Scene{timestep}) {}
 
-flock::PhysicsEngine::~PhysicsEngine()
-{
-    /**
-     * Sensors have to get shutdown manually on destruction of the physics engine in order to disable their regular destructor
-     * TODO: Do the entire body destruction based on EnTT component destruction events, this vector will grow indefinitely
-     */
-    for (auto &weakSensor : mPhysicsSensorBackup)
+void flock::PhysicsEngine::init(entt::registry<uint32_t> &reg)
 {
-        if (!weakSensor.expired())
-        {
-            auto lockedSensor = weakSensor.lock();
-            lockedSensor->killOnSceneShutdown();
-        }
-    }
+    reg.destruction<SensorC>().connect<&PhysicsEngine::onSensorDestruction>(this);
 }
 
 void flock::PhysicsEngine::step()
@@ -68,6 +63,5 @@ void flock::PhysicsEngine::syncSensors(entt::registry<uint32_t> &reg)
 flock::SensorC flock::PhysicsEngine::createSensor(uint32_t entity, const glm::vec3 &position, const glm::vec3 &size)
 {
     auto sharedSensor = std::make_shared<PhysicsSensor>(entity, position, size, &mScene);
-    mPhysicsSensorBackup.push_back(sharedSensor);
     return SensorC{sharedSensor};
 }

Flock/flock/src/logic/physics/PhysicsEngine.hh

@@ -20,12 +20,14 @@ class PhysicsEngine
 {
 private:
     q3Scene mScene;
-    std::vector<std::weak_ptr<PhysicsSensor>> mPhysicsSensorBackup;
+
+private:
+    void onSensorDestruction(entt::registry<uint32_t>& ecs, uint32_t entity);
 
 public:
     PhysicsEngine(float timestep);
 
-    ~PhysicsEngine();
+    void init(entt::registry<uint32_t>& reg);
 
     void step();
 

Flock/flock/src/logic/physics/SensorC.hh

@@ -13,31 +13,19 @@ class PhysicsEngine;
 struct PhysicsSensor
 {
 private:
-    q3Scene* const mSceneBackref;
     uint32_t const mEntity;
 
-    bool mSceneAlive = true;
-
-    void killOnSceneShutdown()
-    {
-        mSceneBackref->RemoveBody(body);
-        mSceneAlive = false;
-    }
-
-    friend PhysicsEngine;
-
 public:
     q3Body* body;
 
-    PhysicsSensor(uint32_t ent, glm::vec3 const& position, glm::vec3 const& size, q3Scene* scene)
-      : mSceneBackref(scene), mEntity(ent)
+    PhysicsSensor(uint32_t ent, glm::vec3 const& position, glm::vec3 const& size, q3Scene* scene) : mEntity(ent)
     {
         q3BodyDef bodyDef;
         bodyDef.position = q3Vec3(position.x, position.y, position.z);
         bodyDef.bodyType = eKinematicBody;
         bodyDef.userData = this;
 
-        body = mSceneBackref->CreateBody(bodyDef);
+        body = scene->CreateBody(bodyDef);
 
         q3BoxDef boxDef;
         q3Transform localSpace; // Identity Transform (0,0,0)
@@ -48,12 +36,6 @@ public:
         body->AddBox(boxDef);
     }
 
-    ~PhysicsSensor()
-    {
-        if (mSceneAlive)
-            mSceneBackref->RemoveBody(body);
-    }
-
     void setVelocity(glm::vec3 const& vel) { body->SetLinearVelocity(q3Vec3(vel.x, vel.y, vel.z)); }
 
     constexpr uint32_t getEntity() const noexcept { return mEntity; }