Turned the Transform namespace into TransformSystem so it would be able to subscribe to EntityDeleted and clean up after itself

src/Engine/Core/Transform.cpp

@@ -1,17 +1,28 @@
-#include "Core/Transform.h"
+#include "Core/TransformSystem.h"
 
-namespace Transform
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::PositionCache;
+std::unordered_map<EntityWrapper, glm::quat> TransformSystem::OrientationCache;
+std::unordered_map<EntityWrapper, glm::vec3> TransformSystem::ScaleCache;
+std::unordered_map<EntityWrapper, glm::mat4> TransformSystem::MatrixCache;
+
+int TransformSystem::RecalculatedPositions = 0;
+int TransformSystem::RecalculatedOrientations = 0;
+int TransformSystem::RecalculatedScales = 0;
+
+TransformSystem::TransformSystem(SystemParams params)
+    : System(params)
 {
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &TransformSystem::OnEntityDeleted);
+}
 
-std::unordered_map<EntityWrapper, glm::vec3> PositionCache;
-std::unordered_map<EntityWrapper, glm::quat> OrientationCache;
-std::unordered_map<EntityWrapper, glm::vec3> ScaleCache;
-std::unordered_map<EntityWrapper, glm::mat4> MatrixCache;
-
-int RecalculatedPositions = 0;
-int RecalculatedOrientations = 0;
-int RecalculatedScales = 0;
-
+bool TransformSystem::OnEntityDeleted(const Events::EntityDeleted& e)
+{
+    // Clean up deleted entity
+    PositionCache.erase(e.DeletedEntity);
+    OrientationCache.erase(e.DeletedEntity);
+    ScaleCache.erase(e.DeletedEntity);
+    MatrixCache.erase(e.DeletedEntity);
+    return true;
 }
 
 //glm::mat4 Transform::AbsoluteTransformation(EntityWrapper entity)
@@ -26,12 +37,12 @@ int RecalculatedScales = 0;
 //    return t;
 //}
 
-glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
+glm::vec3 TransformSystem::AbsolutePosition(World* world, EntityID entity)
 {
-    return Transform::AbsolutePosition(EntityWrapper(world, entity));
+    return TransformSystem::AbsolutePosition(EntityWrapper(world, entity));
 }
 
-glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
+glm::vec3 TransformSystem::AbsolutePosition(EntityWrapper entity)
 {
     if (!entity.Valid()) {
         return glm::vec3();
@@ -45,7 +56,7 @@ glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
     } else {
         EntityWrapper parent = entity.Parent();
         // Calculate position
-        glm::vec3 position = AbsolutePosition(parent) + Transform::AbsoluteOrientation(parent) * (Transform::AbsoluteScale(parent) * (const glm::vec3&)cTransformPosition);
+        glm::vec3 position = AbsolutePosition(parent) + TransformSystem::AbsoluteOrientation(parent) * (TransformSystem::AbsoluteScale(parent) * (const glm::vec3&)cTransformPosition);
         // Cache it
         PositionCache[entity] = position;
         RecalculatedPositions++;
@@ -55,7 +66,7 @@ glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
     }
 }
 
-glm::vec3 Transform::AbsoluteOrientationEuler(EntityWrapper entity)
+glm::vec3 TransformSystem::AbsoluteOrientationEuler(EntityWrapper entity)
 {
     glm::vec3 orientation;
 
@@ -68,12 +79,12 @@ glm::vec3 Transform::AbsoluteOrientationEuler(EntityWrapper entity)
     return orientation;
 }
 
-glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
+glm::quat TransformSystem::AbsoluteOrientation(World* world, EntityID entity)
 {
-    return Transform::AbsoluteOrientation(EntityWrapper(world, entity));
+    return TransformSystem::AbsoluteOrientation(EntityWrapper(world, entity));
 }
 
-glm::quat Transform::AbsoluteOrientation(EntityWrapper entity)
+glm::quat TransformSystem::AbsoluteOrientation(EntityWrapper entity)
 {
     if (!entity.Valid()) {
         return glm::quat();
@@ -97,12 +108,12 @@ glm::quat Transform::AbsoluteOrientation(EntityWrapper entity)
     }
 }
 
-glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
+glm::vec3 TransformSystem::AbsoluteScale(World* world, EntityID entity)
 {
-    return Transform::AbsoluteScale(EntityWrapper(world, entity));
+    return TransformSystem::AbsoluteScale(EntityWrapper(world, entity));
 }
 
-glm::vec3 Transform::AbsoluteScale(EntityWrapper entity)
+glm::vec3 TransformSystem::AbsoluteScale(EntityWrapper entity)
 {
     if (!entity.Valid()) {
         return glm::vec3(1.f);
@@ -126,12 +137,12 @@ glm::vec3 Transform::AbsoluteScale(EntityWrapper entity)
     }
 }
 
-glm::mat4 Transform::ModelMatrix(EntityID entityID, World* world)
+glm::mat4 TransformSystem::ModelMatrix(EntityID entityID, World* world)
 {
     return ModelMatrix(EntityWrapper(world, entityID));
 }
 
-glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
+glm::mat4 TransformSystem::ModelMatrix(EntityWrapper entity)
 {
     auto cacheIt = MatrixCache.find(entity);
     ComponentWrapper cTransform = entity["Transform"];
@@ -145,7 +156,7 @@ glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
     }
 }
 
-glm::vec3 Transform::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
+glm::vec3 TransformSystem::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
 {
     return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
 }