EntityWrapper to uniquely identify entities and make using them a little easier

src/Engine/Collision/CollidableOctreeSystem.cpp

@@ -5,16 +5,14 @@ void CollidableOctreeSystem::Update(World* world, double dt)
     m_Octree->ClearDynamicObjects();
 }
 
-void CollidableOctreeSystem::UpdateComponent(World* world, ComponentWrapper& cCollidable, double dt)
+void CollidableOctreeSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
-    EntityID entity = cCollidable.EntityID;
-
-    if (world->HasComponent(entity, "AABB")) {
-        boost::optional<AABB> absoluteAABB = Collision::EntityAbsoluteAABB(world, entity);
+    if (entity.HasComponent("AABB")) {
+        boost::optional<AABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
         if (absoluteAABB) {
             m_Octree->AddDynamicObject(*absoluteAABB);
         }
-    } else if (world->HasComponent(entity, "Model")) {
+    } else if (entity.HasComponent("Model")) {
         // TODO: Derive AABB from model
     }
 }

src/Engine/Collision/Collision.cpp

@@ -283,15 +283,15 @@ bool attachAABBComponentFromModel(World* world, EntityID id)
     return true;
 }
 
-boost::optional<AABB> EntityAbsoluteAABB(World* world, EntityID entity)
+boost::optional<AABB> EntityAbsoluteAABB(EntityWrapper& entity)
 {
-    if (!world->HasComponent(entity, "AABB")) {
+    if (!entity.HasComponent("AABB")) {
         return boost::none;
     }
 
-    ComponentWrapper& cAABB = world->GetComponent(entity, "AABB");
-    glm::vec3 absPosition = RenderQueueFactory::AbsolutePosition(world, entity);
-    glm::vec3 absScale = RenderQueueFactory::AbsoluteScale(world, entity);
+    ComponentWrapper& cAABB = entity["AABB"];
+    glm::vec3 absPosition = RenderQueueFactory::AbsolutePosition(entity.World, entity.ID);
+    glm::vec3 absScale = RenderQueueFactory::AbsoluteScale(entity.World, entity.ID);
     glm::vec3 origin = absPosition + (glm::vec3)cAABB["Origin"];
     glm::vec3 size = (glm::vec3)cAABB["Size"] * absScale;
     return AABB::FromOriginSize(origin, size);

src/Engine/Collision/CollisionSystem.cpp

@@ -2,14 +2,13 @@
 #include "Collision/CollisionSystem.h"
 #include "Core/AABB.h"
 
-void CollisionSystem::UpdateComponent(World* world, ComponentWrapper& cAABB, double dt)
+void CollisionSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
-    EntityID entity = cAABB.EntityID;
-    boost::optional<AABB> boundingBox = Collision::EntityAbsoluteAABB(world, entity);
+    boost::optional<AABB> boundingBox = Collision::EntityAbsoluteAABB(entity);
     if (!boundingBox) {
         return;
     }
-    ComponentWrapper& cTransform = world->GetComponent(entity, "Transform");
+    ComponentWrapper& cTransform = entity["Transform"];
     AABB& boxA = *boundingBox;
 
     //Press 'Z' to enable/disable collision.

src/Engine/Collision/TriggerSystem.cpp

@@ -3,22 +3,22 @@
 #include "Core/AABB.h"
 #include "Rendering/Model.h"
 
-void TriggerSystem::UpdateComponent(World* world, ComponentWrapper& cTrigger, double dt)
+void TriggerSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     //Currently only players can trigger things.
     auto players = world->GetComponents("Player");
     if (players == nullptr) {
         return;
     }
-    EntityID tId = cTrigger.EntityID;
-    boost::optional<AABB> triggerBox = Collision::EntityAbsoluteAABB(world, tId);
+    EntityID tId = component.EntityID;
+    boost::optional<AABB> triggerBox = Collision::EntityAbsoluteAABB(entity);
     //The trigger *should* have a bounding box, or something, to test against so it can be triggered.
     if (!triggerBox) {
         return;
     }
     for (auto& pc : *players) {
         EntityID pId = pc.EntityID;
-        boost::optional<AABB> playerBox = Collision::EntityAbsoluteAABB(world, pId);
+        boost::optional<AABB> playerBox = Collision::EntityAbsoluteAABB(EntityWrapper(world, pId));
         //The player can't trigger anything without an AABB.
         if (!playerBox) {
             continue;

src/Engine/Core/EntityWrapper.cpp

@@ -0,0 +1,28 @@
+#include "Core/EntityWrapper.h"
+#include "Core/World.h"
+
+bool EntityWrapper::operator==(const EntityWrapper& e)
+{
+    return (this->World == e.World) && (this->ID == e.ID);
+}
+
+bool EntityWrapper::HasComponent(const std::string& componentName)
+{
+    return World->HasComponent(ID, componentName);
+}
+
+ComponentWrapper EntityWrapper::operator[](const std::string& componentName)
+{
+    if (World->HasComponent(ID, componentName)) {
+        return World->GetComponent(ID, componentName);
+    } else {
+        LOG_WARNING("EntityWrapper implicitly attached \"%s\" component to #%i as a result of a fetch request!", componentName.c_str(), ID);
+        return World->AttachComponent(ID, componentName);
+    }
+}
+
+EntityWrapper::operator EntityID()
+{
+    return this->ID;
+}
+