Merge branch 'BoxModelCollision' into FrustumCulling

# Conflicts:
#	src/Game/Game.cpp

src/Engine/Collision/CollidableOctreeSystem.cpp

@@ -1,18 +0,0 @@
-#include "Collision/CollidableOctreeSystem.h"
-
-void CollidableOctreeSystem::Update(double dt)
-{
-    m_Octree->ClearDynamicObjects();
-}
-
-void CollidableOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
-{
-    if (entity.HasComponent("AABB")) {
-        boost::optional<EntityAABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
-        if (absoluteAABB) {
-            m_Octree->AddDynamicObject(*absoluteAABB);
-        }
-    } else if (entity.HasComponent("Model")) {
-        // TODO: Derive AABB from model
-    }
-}

src/Engine/Collision/Collision.cpp

@@ -564,33 +564,29 @@ bool AABBvsTriangles(const AABB& box,
     return hit;
 }
 
-bool attachAABBComponentFromModel(World* world, EntityID id)
+bool AttachAABBComponentFromModel(EntityWrapper entity)
 {
-    if (!world->HasComponent(id, "Model")) {
+    if (!entity.HasComponent("Model")) {
         return false;
     }
-    ComponentWrapper model = world->GetComponent(id, "Model");
-    ComponentWrapper collision = world->AttachComponent(id, "AABB");
-    Model* modelRes = ResourceManager::Load<Model>(model["Resource"]);
-    if (modelRes == nullptr) {
+    //Derive AABB from model
+    RawModel* model;
+    try {
+        model = ResourceManager::Load<RawModel, true>(entity["Model"]["Resource"]);
+    } catch (const std::exception&) {
         return false;
     }
 
-    glm::mat4 modelMatrix = modelRes->Matrix();
-
-    glm::vec3 mini = glm::vec3(INFINITY, INFINITY, INFINITY);
-    glm::vec3 maxi = glm::vec3(-INFINITY, -INFINITY, -INFINITY);
-    for (const auto& v : modelRes->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);
+    glm::vec3 mini(INFINITY);
+    glm::vec3 maxi(-INFINITY);
+    for (const auto& v : model->m_Vertices) {
+        mini = glm::min(mini, v.Position);
+        maxi = glm::max(maxi, v.Position);
     }
-    collision["Origin"] = 0.5f * (maxi + mini);
-    collision["Size"] = maxi - mini;
+
+    entity.AttachComponent("AABB");
+    entity["AABB"]["Origin"] = 0.5f * (maxi + mini);
+    entity["AABB"]["Size"] = maxi - mini;
     return true;
 }
 

src/Engine/Collision/CollisionSystem.cpp

@@ -20,6 +20,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     // Collide against octree items
     m_OctreeResult.clear();
     m_Octree->ObjectsInSameRegion(*boundingBox, m_OctreeResult);
+    bool everHitTheGround = false;
     for (auto& boxB : m_OctreeResult) {
         glm::vec3 resolutionVector;
         if (boxA.Entity == boxB.Entity) {
@@ -43,17 +44,24 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             if (Collision::AABBvsTriangles(boxA, model->m_Vertices, model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
                 cPhysics["Velocity"] = inOutVelocity;
-                (bool)cPhysics["IsOnGround"] = isOnGround;
-            } else {
-                (bool)cPhysics["IsOnGround"] = false;
+                if (isOnGround) {
+                    everHitTheGround = true;
+                    (bool)cPhysics["IsOnGround"] = true;
+                }
             }
         } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
-            (bool)cPhysics["IsOnGround"] = resolutionVector.y > 0;
-            if ((bool)cPhysics["IsOnGround"]){
+            if (resolutionVector.y > 0) {
+                everHitTheGround = true;
+                (bool)cPhysics["IsOnGround"] = true;
                 ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
             }
         }
     }
+
+    //This should apply air friction and such, iff zero models were hit.
+    if (!everHitTheGround) {
+        (bool)cPhysics["IsOnGround"] = false;
+    }
 }

src/Engine/Collision/FillOctreeSystem.cpp

@@ -0,0 +1,20 @@
+#include "Collision/FillOctreeSystem.h"
+
+void FillOctreeSystem::Update(double dt)
+{
+    m_Octree->ClearDynamicObjects();
+}
+
+void FillOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+{
+    if (!entity.HasComponent("AABB")) {
+        //Derive AABB from model.
+        if (!Collision::AttachAABBComponentFromModel(entity)) {
+            return;
+        }
+    }
+    boost::optional<EntityAABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
+    if (absoluteAABB) {
+        m_Octree->AddDynamicObject(*absoluteAABB);
+    }
+}

src/Engine/Collision/TriggerSystem.cpp

@@ -6,6 +6,10 @@
 void TriggerSystem::UpdateComponent(EntityWrapper& triggerEntity, ComponentWrapper& cTrigger, double dt)
 {
     // The trigger *should* have a bounding box, or something, to test against so it can be triggered.
+    // If it doesn't, add one as big as the model for now, then size can be modified in editor if necessary.
+    if (!triggerEntity.HasComponent("AABB")) {
+        Collision::AttachAABBComponentFromModel(triggerEntity);
+    }
     boost::optional<EntityAABB> triggerBox = Collision::EntityAbsoluteAABB(triggerEntity);
     if (!triggerBox) {
         return;

src/Engine/Core/EntityWrapper.cpp

@@ -16,6 +16,15 @@ bool EntityWrapper::HasComponent(const std::string& componentName)
     return World->HasComponent(ID, componentName);
 }
 
+void EntityWrapper::AttachComponent(const char* componentName)
+{
+    if (!Valid()) {
+        LOG_WARNING("Could not attach \"%s\" component to #%i, component is not valid.", componentName, ID);
+        return;
+    }
+    World->AttachComponent(ID, componentName);
+}
+
 EntityWrapper EntityWrapper::Parent()
 {
     if (this->World == nullptr || this->ID == EntityID_Invalid) {