Start of a movement system with collisions against AABBs

src/Engine/Collision/Collision.cpp

@@ -199,6 +199,46 @@ bool RayVsModel(const Ray& ray,
     return hit;
 }
 
+bool AABBvsTriangles(const AABB& box, const std::vector<RawModel::Vertex>& modelVertices, const std::vector<unsigned int>& modelIndices, const glm::mat4& modelMatrix, glm::vec3& outResolutionVector)
+{
+    bool hit = false;
+    
+    const glm::vec3& origin = box.Origin();
+    const glm::vec3& min = box.MinCorner();
+    const glm::vec3& max = box.MaxCorner();
+
+    outResolutionVector.x = INFINITY;
+
+    for (int i = 0; i < modelIndices.size(); ++i) {
+        glm::vec3 p = modelVertices[i].Position;
+        p = glm::vec3(modelMatrix * glm::vec4(p.x, p.y, p.z, 1));
+
+        float distFromOrigin = glm::abs(origin.x - p.x);
+        float penetration = box.HalfSize().x - distFromOrigin;
+        if (penetration > 0 && penetration < glm::abs(outResolutionVector.x)) {
+            if (p.x > origin.x) {
+                outResolutionVector.x = -penetration;
+            } else {
+                outResolutionVector.x = penetration;
+            }
+            hit = true;
+        }
+        //glm::vec3 pLocal = origin - p;
+        //for (int axis = 0; axis < 3; ++axis) {
+        //    if (p[axis] < min[axis] || p[axis] > max[axis]) {
+        //        continue;
+        //    }
+
+        //    if (glm::abs(pLocal[axis]) < box.HalfSize()[axis]) {
+        //        outResolutionVector[axis] = (glm::sign(pLocal[axis]) * box.HalfSize()[axis]) - pLocal[axis];
+        //        hit = true;
+        //    }
+        //}
+    }
+
+    return hit;
+}
+
 bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon)
 {
     const glm::vec3& ma1 = first.MaxCorner();

src/Engine/Collision/CollisionSystem.cpp

@@ -17,6 +17,7 @@ void CollisionSystem::UpdateComponent(World* world, ComponentWrapper& cAABB, dou
         return;
     }
 
+    // Collide against octree
     std::vector<AABB> octreeResult;
     m_Octree->BoxesInSameRegion(*boundingBox, octreeResult);
     for (auto& boxB : octreeResult) {
@@ -28,6 +29,28 @@ void CollisionSystem::UpdateComponent(World* world, ComponentWrapper& cAABB, dou
             (glm::vec3&)cTransform["Position"] += resolutionVector;
         }
     }
+
+    // HACK: Temporarily collide against all collidable models since they're not in the octree yet
+    //auto otherCollidables = world->GetComponents("Model");
+    //for (auto& cModel : *otherCollidables) {
+    //    if (cModel.EntityID == entity) {
+    //        continue;
+    //    }
+    //    if (!world->HasComponent(cModel.EntityID, "Collidable")) {
+    //        continue;
+    //    }
+
+    //    auto absPosition = RenderQueueFactory::AbsolutePosition(world, cModel.EntityID);
+    //    auto absOrientation = RenderQueueFactory::AbsoluteOrientation(world, cModel.EntityID);
+    //    auto absScale = RenderQueueFactory::AbsoluteScale(world, cModel.EntityID);
+    //    glm::mat4 modelMatrix = glm::translate(absPosition); // *glm::toMat4(absOrientation) * glm::scale(absScale);
+
+    //    auto model = ResourceManager::Load<Model>(cModel["Resource"]);
+    //    glm::vec3 resolutionVector;
+    //    if (Collision::AABBvsTriangles(boxA, model->m_Vertices, model->m_Indices, modelMatrix, resolutionVector)) {
+    //        (glm::vec3&)cTransform["Position"] += resolutionVector;
+    //    }
+    //}
 }
 
 bool CollisionSystem::OnKeyUp(const Events::KeyUp & event)