Made CollisionSystem aware of entities

include/Engine/Collision/Collision.h

@@ -59,7 +59,6 @@ bool AABBVsAABB(const AABB& a, const AABB& b);
 //Return true if the boxes are intersecting.
 //Also outputs the minimum translation that box [a] would need in order to resolve collision.
 bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
-bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon = 0.0001f);
 
 // Calculates an absolute AABB from an entity AABB component
 boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity);

include/Engine/Collision/CollisionSystem.h

@@ -7,7 +7,6 @@
 #include "../Common.h"
 #include "../Core/System.h"
 #include "../Core/EventBroker.h"
-#include "../Core/EKeyUp.h"
 #include "../Core/Octree.h"
 #include "EntityAABB.h"
 
@@ -18,20 +17,13 @@ public:
         : System(world, eventBroker)
         , PureSystem("Collidable")
         , m_Octree(octree)
-        , zPress(false)
-    {
-        //TODO: Debug stuff, remove later.
-        EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &CollisionSystem::OnKeyUp);
-    }
+    { }
 
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override;
 
 private:
     Octree<EntityAABB>* m_Octree;
-    bool zPress;
-
-    EventRelay<CollisionSystem, Events::KeyUp> m_EKeyUp;
-    bool OnKeyUp(const Events::KeyUp &event);
+    std::vector<EntityAABB> m_OctreeResult;
 };
 
 #endif

src/Engine/Collision/Collision.cpp

@@ -239,20 +239,6 @@ bool AABBvsTriangles(const AABB& box, const std::vector<RawModel::Vertex>& model
     return hit;
 }
 
-bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon)
-{
-    const glm::vec3& ma1 = first.MaxCorner();
-    const glm::vec3& ma2 = second.MaxCorner();
-    const glm::vec3& mi1 = first.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);
-}
-
 bool attachAABBComponentFromModel(World* world, EntityID id)
 {
     if (!world->HasComponent(id, "Model")) {

src/Engine/Collision/CollisionSystem.cpp

@@ -16,22 +16,20 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     ComponentWrapper& cTransform = entity["Transform"];
     EntityAABB& boxA = *boundingBox;
 
-    //Press 'Z' to enable/disable collision.
-    if (zPress) {
-        return;
-    }
-
-    // Collide against octree
-    std::vector<EntityAABB> octreeResult;
-    m_Octree->ObjectsInSameRegion(*boundingBox, octreeResult);
-    for (auto& boxB : octreeResult) {
+    // Collide against octree items
+    m_OctreeResult.clear();
+    m_Octree->ObjectsInSameRegion(*boundingBox, m_OctreeResult);
+    for (auto& boxB : m_OctreeResult) {
         glm::vec3 resolutionVector;
-        if (Collision::IsSameBoxProbably(boxA, boxB)) {
+        if (boxA.Entity == boxB.Entity) {
             continue;
         }
+
         if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             (glm::vec3&)cTransform["Position"] += resolutionVector;
-            ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+            if (resolutionVector.y > 0) {
+                ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+            }
         }
     }
 
@@ -56,12 +54,4 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     //        (glm::vec3&)cTransform["Position"] += resolutionVector;
     //    }
     //}
-}
-
-bool CollisionSystem::OnKeyUp(const Events::KeyUp & event)
-{
-    if (event.KeyCode == GLFW_KEY_Z) {
-        zPress = !zPress;
-    }
-    return false;
-}
+}

src/Engine/Core/Octree.cpp

@@ -105,8 +105,7 @@ bool Child::BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected) const
         for (int i : m_DynamicObjIndices) {
             if (!m_DynamicObjectsRef[i].Checked) {
                 const AABB& objBox = *m_DynamicObjectsRef[i].Box;
-                if (!Collision::IsSameBoxProbably(boxToTest, objBox) &&
-                    Collision::AABBVsAABB(boxToTest, objBox)) {
+                if (Collision::AABBVsAABB(boxToTest, objBox)) {
                     outBoxIntersected = objBox;
                     return true;
                 }

src/Game/Game.cpp

@@ -89,6 +89,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<CollidableOctreeSystem>(updateOrderLevel, m_OctreeCollision);
@@ -100,7 +101,6 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeCollision);
     ++updateOrderLevel;
-    m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);

src/Game/Systems/PlayerMovementSystem.cpp

@@ -80,14 +80,14 @@ void PlayerMovementSystem::Update(double dt)
                 velocity.y += 4.f;
             }
 
-            //if (player.HasComponent("AABB")) {
-            //    glm::vec3& size = player["AABB"]["Size"];
-            //    if (controller->Crouching()) {
-            //        size = glm::vec3(1.f, 1.f, 1.f);
-            //    } else {
-            //        size = glm::vec3(1.f, 1.6f, 1.f);
-            //    }
-            //}
+            if (player.HasComponent("AABB")) {
+                glm::vec3& size = player["AABB"]["Size"];
+                if (controller->Crouching()) {
+                    size = glm::vec3(1.f, 1.f, 1.f);
+                } else {
+                    size = glm::vec3(1.f, 1.6f, 1.f);
+                }
+            }
 
             // Animations
             EntityWrapper playerModel = player.FirstChildByName("PlayerModel");