Added a TriggerSystem, seems to work as intended.

src/Engine/Collision/Collision.cpp

@@ -154,4 +154,18 @@ bool RayVsModel(const Ray& ray,
     return hit;
 }
 
+bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon)
+{
+    const glm::vec3& ma1 = first.MaxCorner();
+    const glm::vec3& ma2 = first.MaxCorner();
+    const glm::vec3& mi1 = second.MinCorner();
+    const glm::vec3& mi2 = second.MinCorner();
+    return (std::abs(ma1.x - ma2.x) < epsilon) &&
+        (std::abs(mi1.x - mi2.x) < epsilon) &&
+        (std::abs(ma1.z - ma2.z) < epsilon) &&
+        (std::abs(mi1.z - mi2.z) < epsilon) &&
+        (std::abs(ma1.y - ma2.y) < epsilon) &&
+        (std::abs(mi1.y - mi2.y) < epsilon);
+}
+
 }

src/Engine/Collision/TriggerSystem.cpp

@@ -1,22 +1,123 @@
 #include "Collision/TriggerSystem.h"
+#include "Collision/Collision.h"
 #include "Core/AABB.h"
+#include "Rendering/Model.h"
 
 void TriggerSystem::Update(World* world, ComponentWrapper& trigger, double dt)
 {
+    //Currently only players can trigger things.
     auto players = world->GetComponents("Player");
     if (players == nullptr) {
         return;
     }
-    //WTODO: Assumes box exists.
-    ComponentWrapper& cBox = world->GetComponent(trigger.EntityID, "AABB");
-    AABB aabb;
-    aabb.CreateFromCenter(cBox["BoxCenter"], cBox["BoxSize"]);
-    for (auto& c : *players) {
-
-        Events::TriggerEnter e;
-        e.Trigger = trigger.EntityID;
-        e.Entity = 41;
-        m_EventBroker->Publish(e);
+    EntityID tId = trigger.EntityID;
+    AABB triggerBox;
+    //The trigger *should* have a bounding box, or something, to test against so it can be triggered.
+    if (!getEntityBox(world, tId, triggerBox)) {
+        return;
+    }
+    for (auto& pc : *players) {
+        EntityID pId = pc.EntityID;
+        AABB playerBox;
+        //The player can't trigger anything without an AABB.
+        if (!getEntityBox(world, pId, playerBox)) {
+            continue;
+        }
+        if (!Collision::AABBVsAABB(triggerBox, playerBox)) {
+            //Entity is not touching the trigger,
+            //Throw event if it was previously.
+            if (throwLeaveIfWasInTrigger(m_EntitiesTouchingTrigger[tId], pId, tId)) {
+                continue;
+            }
+            //This only occurs if the entity was completely inside the trigger one frame, 
+            //then completely outside the trigger, e.g. when dying and respawning.
+            throwLeaveIfWasInTrigger(m_EntitiesCompletelyInTrigger[tId], pId, tId);
+        } else {
+            //Entity is at least touching the trigger.
+            AABB completelyInsideBox;
+            completelyInsideBox.CreateFromCenter(triggerBox.Center(), triggerBox.Size() - playerBox.Size());
+            if (Collision::AABBVsAABB(completelyInsideBox, playerBox)) {
+                //Entity is completely inside the trigger.
+                //If it was only touching before, it is erased.
+                m_EntitiesTouchingTrigger[tId].erase(pId);
+                std::unordered_set<EntityID>& completeSet = m_EntitiesCompletelyInTrigger[tId];
+                if (completeSet.count(pId) == 0) {
+                    //If it wasn't completely in the trigger, throw Enter and add to the set.
+                    completeSet.insert(pId);
+                    publish<Events::TriggerEnter>(pId, tId);
+                }
+            } else {
+                //Entity is only touching the trigger.
+                std::unordered_set<EntityID>& touchSet = m_EntitiesTouchingTrigger[tId];
+                std::unordered_set<EntityID>& completeSet = m_EntitiesCompletelyInTrigger[tId];
+                const auto& it = completeSet.find(pId);
+                //If it was completely inside before.
+                if (it != completeSet.end()) {
+                    completeSet.erase(it);
+                    touchSet.insert(pId);
+                    //If it was completely outside before.
+                } else if (touchSet.count(pId) == 0) {
+                    publish<Events::TriggerTouch>(pId, tId);
+                    touchSet.insert(pId);
+                }
+                //Else, it was touching the trigger last frame too and nothing is done.
+            }
+        }
     }
 }
 
+bool TriggerSystem::getEntityBox(World* world, EntityID id, AABB& outBox)
+{
+    //TODO: Improve checking if component exists. Remove try
+    bool retry;
+    do {
+        retry = false;
+        try {
+            ComponentWrapper& cBox = world->GetComponent(id, "AABB");
+            outBox.CreateFromCenter(cBox["BoxCenter"], cBox["BoxSize"]);
+        } catch (std::out_of_range e) {
+            retry = true;
+            attachAABBComponentFromModel(world, id);
+        }
+    } while (retry);
+    return true;
+}
+
+bool TriggerSystem::throwLeaveIfWasInTrigger(std::unordered_set<EntityID>& triggerSet, EntityID pId, EntityID tId)
+{
+    const auto& it = triggerSet.find(pId);
+    if (it != triggerSet.end()) {
+        //If it was in the trigger, but not anymore, throw leaveEvent and erase from the set.
+        triggerSet.erase(it);
+        publish<Events::TriggerLeave>(pId, tId);
+        return true;
+    }
+    return false;
+}
+
+void TriggerSystem::attachAABBComponentFromModel(World* world, EntityID id)
+{
+    ComponentWrapper model = world->GetComponent(id, "Model");
+    ComponentWrapper transform = world->GetComponent(id, "Transform");
+    ComponentWrapper collision = world->AttachComponent(id, "AABB");
+    Model* modelRes = ResourceManager::Load<Model>(model["Resource"]);
+    
+    glm::mat4 modelMatrix = modelRes->m_Matrix * 
+        glm::translate(glm::mat4(), (glm::vec3)transform["Position"]) * 
+        glm::toMat4((glm::quat)transform["Orientation"]) * 
+        glm::scale((glm::vec3)transform["Scale"]);
+
+    glm::vec3 mini = glm::vec3(INFINITY, INFINITY, INFINITY);
+    glm::vec3 maxi = glm::vec3(-INFINITY, -INFINITY, -INFINITY);
+    for (const auto& v : modelRes->m_Vertices) {
+        const auto& wPos = modelMatrix * glm::vec4(v.Position.x, v.Position.y, v.Position.z, 1);
+        maxi.x = std::max(wPos.x, maxi.x);
+        maxi.y = std::max(wPos.y, maxi.y);
+        maxi.z = std::max(wPos.z, maxi.z);
+        mini.x = std::min(wPos.x, mini.x);
+        mini.y = std::min(wPos.y, mini.y);
+        mini.z = std::min(wPos.z, mini.z);
+    }
+    collision["BoxCenter"] = 0.5f * (maxi + mini);
+    collision["BoxSize"] = maxi - mini;
+}

src/Engine/Core/OctTree.cpp

@@ -21,16 +21,6 @@ bool isFirstLower(const ChildInfo& first, const ChildInfo& second)
     return first.Distance < second.Distance;
 }
 
-bool isSameBoxProbably(const AABB& first, const AABB& second)
-{
-    const float EPS = 0.0001f;
-    const auto& ma = first.MaxCorner();
-    const auto& mi = first.MinCorner();
-    return (std::abs(ma.x - mi.x) < EPS) &&
-        (std::abs(ma.z - mi.z) < EPS) &&
-        (std::abs(ma.y - mi.y) < EPS);
-}
-
 }
 
 OctTree::OctTree()
@@ -228,7 +218,7 @@ bool OctTree::OctChild::BoxCollides(const AABB& boxToTest, AABB& outBoxIntersect
         for (int i : m_DynamicObjIndices) {
             if (!m_DynamicObjectsRef[i].Checked) {
                 const AABB& objBox = m_DynamicObjectsRef[i].Box;
-                if (!isSameBoxProbably(boxToTest, objBox) &&
+                if (!Collision::IsSameBoxProbably(boxToTest, objBox) &&
                     Collision::AABBVsAABB(boxToTest, objBox)) {
                     outBoxIntersected = objBox;
                     return true;