Merge remote-tracking branch 'origin/master' into Sound

src/Engine/Collision/Collision.cpp

@@ -4,6 +4,7 @@
 #include "Engine/GLM.h"
 #include "Core/World.h"
 #include "Rendering/Model.h"
+#include "imgui/imgui.h"
 
 namespace Collision
 {
@@ -116,36 +117,79 @@ bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation)
     return glm::all(axisesIntersecting);
 }
 
+bool RayVsTriangle(const Ray& ray,
+    const glm::vec3& v0,
+    const glm::vec3& v1,
+    const glm::vec3& v2,
+    bool trueOnNegativeDistance)
+{
+    glm::vec3 e1 = v1 - v0;		//v1 - v0
+    glm::vec3 e2 = v2 - v0;		//v2 - v0
+    glm::vec3 m = ray.Origin() - v0;
+    glm::vec3 MxE1 = glm::cross(m, e1);
+    glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);
+    float DetInv = glm::dot(e1, DxE2);
+    if (std::abs(DetInv) < FLT_EPSILON) {
+        return false;
+    }
+    DetInv = 1.0f / DetInv;
+    float u = glm::dot(m, DxE2) * DetInv;
+    float v = glm::dot(ray.Direction(), MxE1) * DetInv;
+    //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
+    if ((u + 0.001f) < 0 || (v + 0.001f) < 0 || 1 < u + v) {
+        return false;
+    }
+    //Here, u and v are positive, u+v <= 1, and if distance is positive - triangle is hit.
+    return trueOnNegativeDistance || 0 <= glm::dot(e2, MxE1) * DetInv;
+}
+
 bool RayVsModel(const Ray& ray,
     const std::vector<RawModel::Vertex>& modelVertices,
     const std::vector<unsigned int>& modelIndices)
 {
     for (int i = 0; i < modelIndices.size(); ++i) {
         glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
-        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
-        glm::vec3 m = ray.Origin() - v0;
-        glm::vec3 MxE1 = glm::cross(m, e1);
-        glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);
-        float DetInv = glm::dot(e1, DxE2);
-        if (std::abs(DetInv) < FLT_EPSILON) {
-            continue;
-        }
-        DetInv = 1.0f / DetInv;
-        float u = glm::dot(m, DxE2) * DetInv;
-        float v = glm::dot(ray.Direction(), MxE1) * DetInv;
-        //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
-        if ((u + 0.001f) < 0 || (v + 0.001f) < 0 || 1 < u + v) {
-            continue;
-        }
-        //Here, u and v are positive, u+v <= 1, and if distance is positive - triangle is hit.
-        if (0 <= glm::dot(e2, MxE1) * DetInv) {
+        glm::vec3 v1 = modelVertices[modelIndices[++i]].Position;
+        glm::vec3 v2 = modelVertices[modelIndices[++i]].Position;
+        if (RayVsTriangle(ray, v0, v1, v2)) {
             return true;
         }
     }
     return false;
 }
 
+bool RayVsTriangle(const Ray& ray,
+    const glm::vec3& v0,
+    const glm::vec3& v1,
+    const glm::vec3& v2,
+    float& outDistance,
+    float& outUCoord,
+    float& outVCoord,
+    bool trueOnNegativeDistance)
+{
+    glm::vec3 e1 = v1 - v0;		//v1 - v0
+    glm::vec3 e2 = v2 - v0;		//v2 - v0
+    glm::vec3 m = ray.Origin() - v0;
+    glm::vec3 MxE1 = glm::cross(m, e1);
+    glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);//pVec
+    float DetInv = glm::dot(e1, DxE2);
+    if (std::abs(DetInv) < FLT_EPSILON) {
+        return false;
+    }
+    DetInv = 1.0f / DetInv;
+    float dist = glm::dot(e2, MxE1) * DetInv;
+    if (dist >= outDistance) {
+        return false;
+    }
+    outDistance = dist;
+    outUCoord = glm::dot(m, DxE2) * DetInv;
+    outVCoord  = glm::dot(ray.Direction(), MxE1) * DetInv;
+
+    //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
+    //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
+    return (0 <= (outUCoord + 0.001f) && 0 <= (outVCoord + 0.001f) && outUCoord + outVCoord <= 1 && (trueOnNegativeDistance || 0 <= dist));
+}
+
 bool RayVsModel(const Ray& ray,
     const std::vector<RawModel::Vertex>& modelVertices,
     const std::vector<unsigned int>& modelIndices,
@@ -157,26 +201,12 @@ bool RayVsModel(const Ray& ray,
     bool hit = false;
     for (int i = 0; i < modelIndices.size(); ++i) {
         glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
-        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
-        glm::vec3 m = ray.Origin() - v0;
-        glm::vec3 MxE1 = glm::cross(m, e1);
-        glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);//pVec
-        float DetInv = glm::dot(e1, DxE2);
-        if (std::abs(DetInv) < FLT_EPSILON) {
-            continue;
-        }
-        DetInv = 1.0f / DetInv;
-        float dist = glm::dot(e2, MxE1) * DetInv;
-        if (dist >= outDistance) {
-            continue;
-        }
-        float u = glm::dot(m, DxE2) * DetInv;
-        float v = glm::dot(ray.Direction(), MxE1) * DetInv;
-
-        //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
-        //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
-        if (0 <= (u + 0.001f) && 0 <= (v + 0.001f) && u + v <= 1 && 0 <= dist) {
+        glm::vec3 v1 = modelVertices[modelIndices[++i]].Position;
+        glm::vec3 v2 = modelVertices[modelIndices[++i]].Position;
+        float dist;
+        float u;
+        float v;
+        if (RayVsTriangle(ray, v0, v1, v2, dist, u, v)) {
             outDistance = dist;
             outUCoord = u;
             outVCoord = v;
@@ -199,43 +229,338 @@ 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)
+constexpr inline int signNonZero(float x)
 {
-    bool hit = false;
-    
+    return x < 0 ? -1 : 1;
+}
+
+inline glm::vec3 signNonZero(const glm::vec3& x)
+{
+    glm::vec3 r;
+    for (int i = 0; i < 3; ++i) {
+        r[i] = (float)signNonZero(x[i]);
+    }
+    return r;
+}
+
+template<typename T>
+bool vectorHasLength(const T& vec)
+{
+    return glm::any(glm::greaterThan(glm::abs(vec), T(0.0001f)));
+}
+
+bool rectangleVsTriangle(const glm::vec2& boxMin,
+    const glm::vec2& boxMax,
+    const std::array<glm::vec2, 3>& triPos,
+    glm::vec2& resolutionDirection,
+    float& resolutionDistanceSq,
+    bool& pushedFromTriNormal)
+{
+    pushedFromTriNormal = false;
+    resolutionDistanceSq = INFINITY;
+    //Project along box normals (coordinate axes, since it's axis-aligned).
+    for (int ax = 0; ax < 2; ++ax) {
+        float minTri = INFINITY;
+        float maxTri = -INFINITY;
+        for (const glm::vec2& t : triPos) {
+            minTri = std::min(t[ax], minTri);
+            maxTri = std::max(t[ax], maxTri);
+        }
+        if (boxMax[ax] <= minTri || maxTri <= boxMin[ax]) {
+            return false;
+        }
+
+        //Here: maxBox > minTri && minBox < maxTri
+        //Left is negative.
+        float leftRes = minTri - boxMax[ax];
+        float rightRes = maxTri - boxMin[ax];
+        float push = rightRes < -leftRes ? rightRes : leftRes;
+        float absPushSq = abs(push);
+        absPushSq *= absPushSq;
+
+        if (absPushSq < resolutionDistanceSq) {
+            resolutionDistanceSq = absPushSq;
+            resolutionDirection[1 - ax] = 0.f;
+            resolutionDirection[ax] = push;
+        }
+    }
+    //Project along triangle normals.
+    //Put edges into normal vector, make normals in the loop.
+    std::array<glm::vec2, 3> triNormals = {
+        triPos[1] - triPos[0],
+        triPos[2] - triPos[1],
+        triPos[0] - triPos[2]
+    };
+    std::array<glm::vec2, 4> boxPos = {
+        boxMax,
+        glm::vec2(boxMax.x, boxMin.y),
+        glm::vec2(boxMin.x, boxMax.y),
+        boxMin
+    };
+    for (auto& normal : triNormals) {
+        if (!vectorHasLength(normal)) {
+            continue;
+        }
+        //Rotate edge to a normal.
+        normal = glm::normalize(glm::vec2(-normal.y, normal.x));
+        //Project triangle onto the normal.
+        float minTri = INFINITY;
+        float maxTri = -INFINITY;
+        for (const glm::vec2& point : triPos) {
+            float dot = glm::dot(normal, point);
+            minTri = std::min(dot, minTri);
+            maxTri = std::max(dot, maxTri);
+        }
+        //Project box onto the normal.
+        float minBox = INFINITY;
+        float maxBox = -INFINITY;
+        for (const glm::vec2& point : boxPos) {
+            float dot = glm::dot(normal, point);
+            minBox = std::min(dot, minBox);
+            maxBox = std::max(dot, maxBox);
+        }
+        if (maxBox <= minTri || maxTri <= minBox) {
+            return false;
+        }
+
+        //Here: maxBox > minTri && minBox < maxTri
+        //Left is negative.
+        float leftRes = minTri - maxBox;
+        float rightRes = maxTri - minBox;
+        float push = rightRes < -leftRes ? rightRes : leftRes;
+        float absPushSq = abs(push);
+        absPushSq *= absPushSq;
+        
+        if (absPushSq < resolutionDistanceSq) {
+            resolutionDistanceSq = absPushSq;
+            resolutionDirection = push * normal;
+            pushedFromTriNormal = true;
+        }
+    }
+    return true;
+}
+
+constexpr float SlopeConstant(float degrees)
+{
+    return (1.0f - degrees / 90.f);
+}
+
+//Returns true if the angle between horizon and the collision surface is less than 45 degrees. 
+constexpr bool FaceIsGround(float faceNormalY)
+{
+    //TODO: Perhaps the 45 degrees could be saved in a component or in the config..
+    return faceNormalY > SlopeConstant(45.0f);
+}
+
+//An array containing 3 int pairs { 0, 2 }, { 0, 1 }, { 1, 2 }
+constexpr std::array<std::pair<int, int>, 3> dimensionPairs({ std::pair<int, int>(0, 2), std::pair<int, int>(0, 1), std::pair<int, int>(1, 2) });
+
+bool AABBvsTriangle(const AABB& box, 
+    const std::array<glm::vec3, 3>& triPos, 
+    const glm::vec3& originalBoxVelocity,
+    float verticalStepHeight,
+    bool& isOnGround,
+    glm::vec3& boxVelocity,
+    glm::vec3& outResolution)
+{
+    //Check so we don't have a zero area triangle when calculating the normal.
+    //Also, don't check a triangle facing away from the player.
+    //Less checks, and we should be able to walk out from models if we are trapped inside.
+    glm::vec3 triNormal = glm::cross(triPos[1] - triPos[0], triPos[2] - triPos[0]);
+    if (!vectorHasLength(triNormal) || (glm::dot(triNormal, originalBoxVelocity) > 0)) {
+        return false;
+    }
+    triNormal = glm::normalize(triNormal);
+
+    enum BoxTriResolveCase
+    {
+        ResolveDimX,
+        ResolveDimY,
+        ResolveDimZ,
+        Line,       //Box edge colliding with triangle line.
+        Corner      //Box corner colliding with the triangle face.
+    };
+    struct Resolution
+    {
+        Resolution()
+            : DistanceSq(INFINITY)
+            , Vector(0.f)
+        {}
+        BoxTriResolveCase Case;
+        float DistanceSq;
+        glm::vec3 Vector;
+    };
+    //The smallest resolution that solves the collision.
+    Resolution resolveShortest;
+    //The smallest resolution that solves the collision, that resolves upwards.
+    Resolution resolveUpwards;
+    //If player stands on the ground and collides with a ground triangle, 
+    //we might step up onto it if the step is small enough.
+    bool canStairStepUp = isOnGround && FaceIsGround(triNormal.y);
+
     const glm::vec3& origin = box.Origin();
+    const glm::vec3& half = box.HalfSize();
     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;
+    //For each projection in xy-, xz-, and yx-planes.
+    for (std::pair<int, int> dim : dimensionPairs) {
+        //2D Triangle.
+        //Project triangle.
+        std::array<glm::vec2, 3> t2D = {
+            glm::vec2(triPos[0][dim.first], triPos[0][dim.second]),
+            glm::vec2(triPos[1][dim.first], triPos[1][dim.second]),
+            glm::vec2(triPos[2][dim.first], triPos[2][dim.second])
+        };
+        //Project box.
+        glm::vec2 boxMin(min[dim.first], min[dim.second]);
+        glm::vec2 boxMax(max[dim.first], max[dim.second]);
+        glm::vec2 resolutionVector;
+        float resolutionDist;
+        bool pushedFromTriangleLine;
+        //if projections don't overlap, return false.
+        if (!rectangleVsTriangle(boxMin, boxMax, t2D, resolutionVector, resolutionDist, pushedFromTriangleLine)) {
+            return false;
+        } else {
+            //Overwrite the smallest resolution if this is smaller.
+            if (resolutionDist < resolveShortest.DistanceSq) {
+                resolveShortest.Vector = glm::vec3(0.f);
+                resolveShortest.Vector[dim.first] = resolutionVector.x;
+                resolveShortest.Vector[dim.second] = resolutionVector.y;
+                resolveShortest.DistanceSq = resolutionDist;
+                //If we pushed away from triangle line (edge), or if we 
+                //move the player along one coordinate axis (pick the dimension that isn't zero).
+                resolveShortest.Case = pushedFromTriangleLine ? Line : static_cast<BoxTriResolveCase>((abs(resolveShortest.Vector[dim.first]) < 0.0001f) ? dim.second : dim.first);
+            }
+            //Overwrite the smallest upward resolution if this is smaller, and resolves upwards.
+            constexpr int yAxis = 1;
+            bool resIsUpwardsIn3D = dim.first == yAxis && resolutionVector.x > 0 || dim.second == yAxis && resolutionVector.y > 0;
+            if (canStairStepUp && resIsUpwardsIn3D && resolutionDist < resolveUpwards.DistanceSq) {
+                resolveUpwards.Vector = glm::vec3(0.f);
+                resolveUpwards.Vector[dim.first] = resolutionVector.x;
+                resolveUpwards.Vector[dim.second] = resolutionVector.y;
+                resolveUpwards.DistanceSq = resolutionDist;
+                //If we pushed away from triangle line (edge), or if we 
+                //move the player along one coordinate axis (pick the dimension that isn't zero).
+                resolveUpwards.Case = pushedFromTriangleLine ? Line : static_cast<BoxTriResolveCase>((abs(resolveUpwards.Vector[dim.first]) < 0.0001f) ? dim.second : dim.first);
             }
-            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;
-        //    }
-        //}
     }
 
+    //If the triangle does intersect any of the cube diagonals, it will 
+    //intersect the cube diagonal that comes
+    //closest to being perpendicular to the plane of the triangle.
+    glm::vec3 diagonal = signNonZero(triNormal) * half;
+    //The triangle plane contains all points P in dot(triNormal, P) == dot(triNormal, v0)
+    //The diagonal line contains all points P in P = origin + diagonal * t.
+    float t = glm::dot(triNormal, triPos[0] - origin) / glm::dot(triNormal, diagonal);
+    //If intersection point between plane and diagonal is within the box.
+    if (glm::abs(t) > 1) {
+        return false;
+    }
+    glm::vec3 cornerResolution = (1+t) * diagonal;
+    //Overwrite the smallest resolution if cornerResolution is smaller.
+    float lenSq = glm::length2(cornerResolution);
+    if (lenSq < resolveShortest.DistanceSq) {
+        resolveShortest.Vector = cornerResolution;
+        resolveShortest.Case = Corner;
+    }
+    if (canStairStepUp && cornerResolution.y > 0 && lenSq < resolveUpwards.DistanceSq) {
+        resolveUpwards.Vector = cornerResolution;
+        resolveUpwards.Case = Corner;
+        resolveUpwards.DistanceSq = lenSq;
+    }
+
+    //Force the resolution upwards if it is smaller than the threshold verticalStepHeight.
+    //Else take the shortest resolution.
+    bool takeUp = resolveUpwards.Vector.y > 0 && resolveUpwards.Vector.y < verticalStepHeight;
+    Resolution& bestResolve = takeUp ? resolveUpwards : resolveShortest;
+    outResolution = bestResolve.Vector;
+
+    glm::vec3 projNorm;
+    switch (bestResolve.Case) {
+    case ResolveDimY:
+        boxVelocity.y = 0.f;
+        if (outResolution.y > 0)
+            isOnGround = true;
+    case ResolveDimX:
+    case ResolveDimZ:
+        //If we get here, the resolution is along one coordinate axis.
+        //set velocity to 0 in y if it is along y-axis.
+        return true;
+    case Line:
+        projNorm = glm::normalize(outResolution);
+        break;
+    case Corner:
+        projNorm = triNormal;
+        break;
+    default:
+        break;
+    }
+
+    //If the collision was not on steep wall or similarly (e.g. walking on the ground), force resolution in y only.
+    if (FaceIsGround(projNorm.y)) {
+        //Ensure that the player always is moved upwards, instead of sliding down.
+        float len = glm::length(outResolution);
+        float ang = glm::half_pi<float>() - glm::acos(outResolution.y / len);
+        if (len > 0.0000001f && ang > 0.0000001f) {
+            outResolution.x = 0;
+            outResolution.y = len / glm::sin(ang);
+            outResolution.z = 0;
+        }
+        //Also zero the vertical velocity, if it is positive, else project it onto the normal.
+        //Project the velocity onto the normal of the hit line/face.
+        //w = v - <v,n>*n, |n|==1.
+        boxVelocity.y = std::min(boxVelocity.y - glm::dot(boxVelocity, projNorm) * projNorm.y, 0.f);
+        isOnGround = true;
+    } else {
+        //Enter here if the triangle is a steep slope, and it is not facing downwards.
+        //Project the velocity onto the normal of the hit line/face.
+        //w = v - <v,n>*n, |n|==1.
+        //"ice cream"-effect, air resistance + projected velocity.
+        if (!isOnGround) {
+            boxVelocity = boxVelocity - glm::dot(boxVelocity, projNorm) * projNorm;
+        }
+    }
+    return true;
+}
+
+bool AABBvsTriangles(const AABB& box, 
+    const std::vector<RawModel::Vertex>& modelVertices, 
+    const std::vector<unsigned int>& modelIndices, 
+    const glm::mat4& modelMatrix,
+    glm::vec3& boxVelocity,
+    float verticalStepHeight,
+    bool& isOnGround,
+    glm::vec3& outResolutionVector)
+{
+    bool hit = false;
+
+    bool everHitTheGround = false;
+    AABB newBox = box;
+    outResolutionVector = glm::vec3(0.f);
+    glm::vec3 originalBoxVelocity(boxVelocity);
+    for (int i = 0; i < modelIndices.size(); ) {
+        std::array<glm::vec3, 3> triVertices = {
+            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
+            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix),
+            Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix)
+        };
+        glm::vec3 outVec;
+        bool collideWithGround = isOnGround;
+        if (AABBvsTriangle(newBox, triVertices, originalBoxVelocity, verticalStepHeight, collideWithGround, boxVelocity, outVec)) {
+            hit = true;
+            outResolutionVector += outVec;
+            newBox = AABB::FromOriginSize(newBox.Origin() + outVec, newBox.Size());
+            if (collideWithGround) {
+                everHitTheGround = isOnGround = true;
+            }
+        }
+    }
+
+    if (!everHitTheGround) {
+        isOnGround = false;
+    }
     return hit;
 }
 

src/Engine/Collision/CollisionSystem.cpp

@@ -1,6 +1,7 @@
 #include "Collision/Collision.h"
 #include "Collision/CollisionSystem.h"
 #include "Core/AABB.h"
+#include "Rendering/Model.h"
 
 void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
@@ -25,33 +26,34 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             continue;
         }
 
-        if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
+        if (boxB.Entity.HasComponent("Model") && Collision::AABBVsAABB(boxA, boxB)) {
+            //Here we know boxB is a entity with Collideable, AABB, and Model.
+            RawModel* model;
+            try {
+                model = ResourceManager::Load<RawModel, true>(boxB.Entity["Model"]["Resource"]);
+            } catch (const std::exception&) {
+                continue;
+            }
+
+            glm::mat4 modelMatrix = Transform::ModelMatrix(boxB.Entity);
+
+            glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
+            bool isOnGround = (bool)cPhysics["IsOnGround"];
+            float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
+            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;
+            }
+        } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
+            //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
-            if (resolutionVector.y > 0) {
+            (bool)cPhysics["IsOnGround"] = resolutionVector.y > 0;
+            if ((bool)cPhysics["IsOnGround"]){
                 ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
             }
         }
     }
-
-    // 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;
-    //    }
-    //}
-}
+}

src/Engine/Core/Octree.cpp

@@ -275,9 +275,4 @@ std::vector<int> Child::childIndicesContainingBox(const AABB& box) const
     }
 }
 
-bool Child::hasChildren() const
-{
-    return m_Children[0] != nullptr;
-}
-
 }

src/Engine/Core/Transform.cpp

@@ -97,3 +97,7 @@ glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
     return modelMatrix;
 }
 
+glm::vec3 Transform::TransformPoint(const glm::vec3& point, const glm::mat4& matrix)
+{
+    return glm::vec3(matrix * glm::vec4(point.x, point.y, point.z, 1));
+}

src/Game/Game.cpp

@@ -8,8 +8,10 @@
 #include "Systems/PlayerMovementSystem.h"
 #include "Systems/SpawnerSystem.h"
 #include "Systems/PlayerSpawnSystem.h"
+#include "Systems/PlayerDeathSystem.h"
 #include "Core/EntityFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
+#include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/WeaponSystem.h"
 #include "Game/Systems/PlayerHUD.h"
 #include "Game/Systems/LifetimeSystem.h"
@@ -91,9 +93,11 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PickupSpawnSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<CollidableOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");

src/Game/Systems/HealthSystem.cpp

@@ -11,38 +11,6 @@ HealthSystem::HealthSystem(World* m_World, EventBroker* eventBroker)
 
 void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
-    //if entityID of health is 9 then the players ID is also 9 (player,health are connected to the same entity)
-    double maxHealth = (double)component["MaxHealth"];
-
-    //process the DeltaHealthVector and change the entitys health accordingly
-    for (size_t i = m_DeltaHealthVector.size(); i > 0; i--)
-    {
-        auto deltaHP = m_DeltaHealthVector[i - 1];
-        //if we have a healthchange for the current player and health is greater than 0, then apply it
-        if (std::get<0>(deltaHP) == component.EntityID && (double)component["Health"] > 0.0f) {
-            //get the deltaHP value from the tuple and make sure you dont get more than maxHealth
-            double newHealth = std::min((double)component["Health"] + (double)std::get<1>(deltaHP), maxHealth);
-            component["Health"] = newHealth;
-            m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + i - 1);
-            //check if health is <= 0
-            if ((double)component["Health"] <= 0.0f) {
-                component["Health"] = 0.0;
-                //publish death event
-                Events::PlayerDeath e;
-                e.PlayerID = component.EntityID;
-                m_EventBroker->Publish(e);
-                //clear the remaining hpDeltas for the dead player
-                for (size_t j = m_DeltaHealthVector.size(); j > 0; j--)
-                {
-                    if (std::get<0>(m_DeltaHealthVector[j - 1]) == component.EntityID)
-                        m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + j - 1);
-                }
-                //delete the player and break the loop
-                m_World->DeleteEntity(entity.ID);
-                break;
-            }
-        }
-    }
 }
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
@@ -50,18 +18,24 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     ComponentWrapper cHealth = e.Player["Health"];
     double& health = cHealth["Health"];
     health -= e.Damage;
-    
+
     if (health <= 0.0) {
-        m_World->DeleteEntity(e.Player.ID);
+        Events::PlayerDeath ePlayerDeath;
+        ePlayerDeath.Player = e.Player;
+        m_EventBroker->Publish(ePlayerDeath);
+        //Note: we will delete the entity in PlayerDeathSystem
     }
 
     return true;
 }
 
-bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e)
+bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e)
 {
-    //save the changed HP to a vector. it will be taken care of in UpdateComponent
-    m_DeltaHealthVector.push_back(std::make_tuple(e.PlayerHealedID, e.HealthAmount));
+    ComponentWrapper cHealth = e.Player["Health"];
+    double& health = cHealth["Health"];
+    health += e.HealthAmount;
+    health = std::min(health, (double)cHealth["MaxHealth"]);
+
     return true;
 }
 

src/Game/Systems/PickupSpawnSystem.cpp

@@ -0,0 +1,66 @@
+#include "Systems/PickupSpawnSystem.h"
+
+PickupSpawnSystem::PickupSpawnSystem(World* m_World, EventBroker* eventBroker)
+    : System(m_World, eventBroker)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &PickupSpawnSystem::OnTriggerTouch);
+}
+
+void PickupSpawnSystem::Update(double dt)
+{
+    for (auto it = m_ETriggerTouchVector.begin(); it != m_ETriggerTouchVector.end(); ++it)
+    {
+        auto& healthPickupPosition = *it;
+        //set the double timer value (value 3)
+        healthPickupPosition.DecreaseThisRespawnTimer -= dt;
+        if (healthPickupPosition.DecreaseThisRespawnTimer < 0) {
+            //spawn and delete the vector item
+            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/HealthPickup.xml");
+            EntityFileParser parser(entityFile);
+            EntityID healthPickupID = parser.MergeEntities(m_World);
+
+            //let the world know a pickup has spawned (graphics effects, etc)
+            Events::PickupSpawned ePickupSpawned;
+            ePickupSpawned.Pickup = EntityWrapper(m_World, healthPickupID);
+            m_EventBroker->Publish(ePickupSpawned);
+
+            //set values from the old entity to the new entity
+            auto& newHealthPickupEntity = EntityWrapper(m_World, healthPickupID);
+            newHealthPickupEntity["Transform"]["Position"] = healthPickupPosition.Pos;
+            newHealthPickupEntity["HealthPickup"]["HealthGain"] = healthPickupPosition.HealthGain;
+            newHealthPickupEntity["HealthPickup"]["RespawnTimer"] = healthPickupPosition.RespawnTimer;
+
+            //erase the current element (healthPickupPosition)
+            m_ETriggerTouchVector.erase(it);
+            break;
+        }
+    }
+}
+
+
+bool PickupSpawnSystem::OnTriggerTouch(Events::TriggerTouch& e)
+{
+    if (!e.Trigger.HasComponent("HealthPickup")) {
+        return false;
+    }
+    double healthGiven = 0.01*(double)e.Trigger["HealthPickup"]["HealthGain"] * (double)e.Entity["Health"]["MaxHealth"];
+    //cant pick up healthpacks if you are already at MaxHealth
+    if ((double)e.Entity["Health"]["Health"] >= (double)e.Entity["Health"]["MaxHealth"]) {
+        return false;
+    }
+
+    //personEntered = e.Entity, thingEntered = e.Trigger
+    Events::PlayerHealthPickup ePlayerHealthPickup;
+    ePlayerHealthPickup.HealthAmount = healthGiven;
+    ePlayerHealthPickup.Player = e.Entity;
+    m_EventBroker->Publish(ePlayerHealthPickup);
+
+    //copy position, healthgain, respawntimer (twice since one of the values will be counted down to 0, the other will be set in the new object)
+    //we need to copy all values since each value can be different for each healthPickup
+    m_ETriggerTouchVector.push_back({ (glm::vec3)e.Trigger["Transform"]["Position"] ,e.Trigger["HealthPickup"]["HealthGain"],
+        e.Trigger["HealthPickup"]["RespawnTimer"],e.Trigger["HealthPickup"]["RespawnTimer"] });
+
+    //delete the healthpickup
+    m_World->DeleteEntity(e.Trigger.ID);
+    return true;
+}

src/Game/Systems/PlayerDeathSystem.cpp

@@ -0,0 +1,57 @@
+#include "Systems/PlayerDeathSystem.h"
+
+PlayerDeathSystem::PlayerDeathSystem(World* m_World, EventBroker* eventBroker)
+    : System(m_World, eventBroker)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerDeathSystem::OnPlayerDeath);
+}
+
+void PlayerDeathSystem::Update(double dt)
+{
+}
+
+bool PlayerDeathSystem::OnPlayerDeath(Events::PlayerDeath& e)
+{
+    if (!e.Player.Valid()) {
+        return false;
+    }
+
+    createDeathEffect(e.Player);
+
+    // Delete player
+    m_World->DeleteEntity(e.Player.ID);
+
+    return true;
+}
+
+void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
+{
+    //load the explosioneffect XML
+    auto deathEffect = ResourceManager::Load<EntityFile>("Schema/Entities/PlayerDeathExplosionWithCamera.xml");
+    EntityFileParser parser(deathEffect);
+    EntityID deathEffectID = parser.MergeEntities(m_World);
+    EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
+
+    //components that we need from player
+    auto playerCamera = player.FirstChildByName("Camera");
+    auto playerEntityModel = player.FirstChildByName("PlayerModel")["Model"];
+    auto playerEntityAnimation = player.FirstChildByName("PlayerModel")["Animation"];
+
+    //copy the data from player to explisioneffectmodel
+    playerEntityModel.Copy(deathEffectEW["Model"]);
+    playerEntityAnimation.Copy(deathEffectEW["Animation"]);
+    //freeze the animation
+    deathEffectEW["Animation"]["Speed"] = 0.0;
+
+    //copy the models position,orientation
+    deathEffectEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
+    deathEffectEW["Transform"]["Orientation"] = (glm::vec3)player["Transform"]["Orientation"];
+    //effect,camera is relative to playersPosition
+    //deathEffectEW["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 0, 0);
+
+    //camera (with lifetime) behind the player
+    auto cam = deathEffectEW.FirstChildByName("Camera");
+    Events::SetCamera eSetCamera;
+    eSetCamera.CameraEntity = cam;
+    m_EventBroker->Publish(eSetCamera);
+}

src/Game/Systems/PlayerMovementSystem.cpp

@@ -63,11 +63,13 @@ void PlayerMovementSystem::Update(double dt)
                 }
             }
             glm::vec3& velocity = cPhysics["Velocity"];
-            ImGui::Text("velocity: (%f, %f, %f)", velocity.x, velocity.y, velocity.z);
+            bool isOnGround = (bool)cPhysics["IsOnGround"];
+            ImGui::Text(isOnGround ? "On ground" : "In air");
+            ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             glm::vec3 groundVelocity(0.f, 0.f, 0.f);
-            groundVelocity.x = glm::dot(velocity, glm::vec3(1.f, 0.f, 0.f));
-            groundVelocity.z = glm::dot(velocity, glm::vec3(0.f, 0.f, 1.f));
-            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(wishDirection));
+            groundVelocity.x = velocity.x;
+            groundVelocity.z = velocity.z;
+            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(groundVelocity));
             ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
             float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
             float addSpeed = wishSpeed - currentSpeedProj;
@@ -80,7 +82,7 @@ void PlayerMovementSystem::Update(double dt)
                 ImGui::InputFloat("accel", &accel);
                 static float airAccel = 0.5f;
                 ImGui::InputFloat("airAccel", &airAccel);
-                float actualAccel = (velocity.y != 0) ? airAccel : accel;
+                float actualAccel = isOnGround ? accel : airAccel;
                 static float surfaceFriction = 5.f;
                 ImGui::InputFloat("surfaceFriction", &surfaceFriction);
                 float accelerationSpeed = actualAccel * (float)dt * wishSpeed * surfaceFriction;
@@ -92,7 +94,8 @@ void PlayerMovementSystem::Update(double dt)
             }
 
             //you cant jump and dash at the same time - since there is no friction in the air and we would thus dash much further in the air
-            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (velocity.y == 0.f || !controller->DoubleJumping())) {
+            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (isOnGround || !controller->DoubleJumping())) {
+                (bool)cPhysics["IsOnGround"] = false;
                 if (velocity.y == 0.f) {
                     controller->SetDoubleJumping(false);
                 } else {
@@ -153,6 +156,7 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
 
     ComponentWrapper& cPhysics = entity["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
+    bool isOnGround = (bool)cPhysics["IsOnGround"];
 
     // Ground friction
     float speed = glm::length(velocity);
@@ -160,7 +164,7 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
     ImGui::InputFloat("groundFriction", &groundFriction);
     static float airFriction = 0.f;
     ImGui::InputFloat("airFriction", &airFriction);
-    float friction = (velocity.y != 0) ? airFriction : groundFriction;
+    float friction = isOnGround ? groundFriction : airFriction;
     if (speed > 0) {
         float drop = speed * friction * (float)dt;
         float multiplier = glm::max(speed - drop, 0.f) / speed;

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -75,7 +75,9 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     // Check if a player already exists
     if (m_PlayerEntities.count(e.PlayerID) != 0) {
         // TODO: Disallow infinite respawning here
-        m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+        if (m_PlayerEntities[e.PlayerID].Valid()) {
+            m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+        }
     }
 
     // Store the player for future reference

src/Tests/CapturePointTest.cpp

@@ -255,14 +255,14 @@ void CapturePointTest::TestSetup8()
 }
 void CapturePointTest::DoTouchEvent(EntityID whoDidSomething, EntityID onWhatObject) {
     Events::TriggerTouch touchEvent;
-    touchEvent.Entity = whoDidSomething;
-    touchEvent.Trigger = onWhatObject;
+    touchEvent.Entity = EntityWrapper(m_World, whoDidSomething);
+    touchEvent.Trigger = EntityWrapper(m_World, onWhatObject);
     m_EventBroker->Publish(touchEvent);
 }
 void CapturePointTest::DoLeaveEvent(EntityID whoDidSomething, EntityID onWhatObject) {
     Events::TriggerLeave leaveEvent;
-    leaveEvent.Entity = whoDidSomething;
-    leaveEvent.Trigger = onWhatObject;
+    leaveEvent.Entity = EntityWrapper(m_World, whoDidSomething);
+    leaveEvent.Trigger = EntityWrapper(m_World, onWhatObject);
     m_EventBroker->Publish(leaveEvent);
 }
 void CapturePointTest::TestSuccess1() {

src/Tests/CollisionTest.cpp

@@ -29,7 +29,7 @@ void RayTest(std::string fileName) {
     Ray ray(glm::vec3(-50, 0, 0), glm::vec3(1, 0, 0));
     //using a 
     
-    here, else we have to init the renderingsystem
+    //here, else we have to init the renderingsystem
     ResourceManager::RegisterType<RawModel>("RawModel");
     auto unitBox = ResourceManager::Load<RawModel>(fileName);
     BOOST_REQUIRE(unitBox != nullptr);

src/Tests/HealthSystemTest.cpp

@@ -48,42 +48,38 @@ GameHealthSystemTest::GameHealthSystemTest()
     fp.MergeEntities(m_World);
 
     // Create system pipeline
-    m_SystemPipeline = new SystemPipeline(m_World,m_EventBroker);
+    m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker);
     m_SystemPipeline->AddSystem<HealthSystem>(0);
 
     //The Test
     //create entity which has transform,player,model,health in it. i.e. is a player
     EntityID playerID = m_World->CreateEntity();
-    ComponentWrapper transform = m_World->AttachComponent(playerID, "Transform");
-    ComponentWrapper model = m_World->AttachComponent(playerID, "Model");
-    model["Resource"] = "Models/Core/UnitSphere.mesh"; // 360NoScope UnitSphere
     ComponentWrapper player = m_World->AttachComponent(playerID, "Player");
     ComponentWrapper health = m_World->AttachComponent(playerID, "Health");
     healthsID = playerID;
-    double currentHealth = (double)m_World->GetComponent(healthsID, "Health")["Health"];
+
+    EntityID playerID2 = m_World->CreateEntity();
+    ComponentWrapper player2 = m_World->AttachComponent(playerID2, "Player");
+    ComponentWrapper health2 = m_World->AttachComponent(playerID2, "Health");
 
     //heal player with 40
     Events::PlayerHealthPickup e3;
     e3.HealthAmount = 40.0f;
-    e3.PlayerHealedID = healthsID;
+    e3.Player = EntityWrapper(m_World, player.EntityID);
     m_EventBroker->Publish(e3);
+
     //damage player with 50
     Events::PlayerDamage e;
-    e.DamageAmount = 50.0f;
-    e.PlayerDamagedID = healthsID;
+    e.Damage = 50.0f;
+    e.Player = EntityWrapper(m_World, player.EntityID);
     m_EventBroker->Publish(e);
+
     //heal some other player with 40
     Events::PlayerHealthPickup e2;
     e2.HealthAmount = 40.0f;
-    e2.PlayerHealedID = healthsID + 1;
+    e2.Player = EntityWrapper(m_World, player2.EntityID);
     m_EventBroker->Publish(e2);
 
-    EntityID playerID2 = m_World->CreateEntity();
-    ComponentWrapper transform2 = m_World->AttachComponent(playerID2, "Transform");
-    ComponentWrapper model2 = m_World->AttachComponent(playerID2, "Model");
-    model2["Resource"] = "Models/Core/UnitSphere.mesh"; // 360NoScope UnitSphere
-    ComponentWrapper player2 = m_World->AttachComponent(playerID2, "Player");
-    ComponentWrapper health2 = m_World->AttachComponent(playerID2, "Health");
     //END TEST
 }