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

include/Engine/Collision/Collision.h

@@ -28,6 +28,21 @@ bool RayVsAABB(const Ray& ray, const AABB& box);
 //Return true if the ray hits the box, also outputs distance from ray origin to intersection point in [outDistance].
 bool RayVsAABB(const Ray& ray, const AABB& box, float& outDistance);
 
+//Return true if the ray hits the triangle.
+bool RayVsTriangle(const Ray& ray,
+    const glm::vec3& v0,
+    const glm::vec3& v1,
+    const glm::vec3& v2,
+    bool trueOnNegativeDistance = false);
+//Return true if the ray hits the triangle, and the distance is less than outDistance.
+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 = false);
 //Return true if the ray hits any of the triangles in the model. Stops checking when a hit is detected.
 bool RayVsModel(const Ray& ray, 
     const std::vector<RawModel::Vertex>& modelVertices,
@@ -52,6 +67,9 @@ 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);
 
 //Return true if the boxes are intersecting.

include/Engine/Core/ComponentWrapper.h

@@ -43,6 +43,11 @@ struct ComponentWrapper
     // Specialization for string literals
     template <std::size_t N>
     void SetField(std::string name, const char(&value)[N]) { Field<std::string>(name) = std::string(value); }
+
+    void Copy(ComponentWrapper& destination)
+    {
+        memcpy(destination.Data, this->Data, Info.Stride);
+    }
     
     struct SubscriptProxy
     {

include/Engine/Core/EPickupSpawned.h

@@ -0,0 +1,17 @@
+#ifndef EPickupSpawned_h__
+#define EPickupSpawned_h__
+
+#include "Core/Event.h"
+#include "Core/EntityWrapper.h"
+
+namespace Events
+{
+
+struct PickupSpawned : Event
+{
+    EntityWrapper Pickup;
+};
+
+}
+
+#endif

include/Engine/Core/EPlayerDamage.h

@@ -9,6 +9,7 @@ namespace Events
 
 struct PlayerDamage : Event
 {
+    //NOTE: this struct is missing information on what the damageSource is
     EntityWrapper Player;
     double Damage;
 };

include/Engine/Core/EPlayerDeath.h

@@ -2,7 +2,7 @@
 #define EPlayerDeath_h__
 
 #include "EventBroker.h"
-#include "../Core/Entity.h"
+#include "../Core/EntityWrapper.h"
 
 namespace Events
 {
@@ -10,8 +10,7 @@ namespace Events
 struct PlayerDeath : Event
 {
     //KilledBy,KilledByWhat is optional for now. It might be used later in the playerlog-system
-    EntityID KilledBy;
-    EntityID PlayerID;
+    EntityWrapper Player;
     std::string KilledByWhat;
 };
 

include/Engine/Core/EPlayerHealthPickup.h

@@ -2,16 +2,16 @@
 #define EPlayerHealthPickup_h__
 
 #include "EventBroker.h"
-#include "../Core/Entity.h"
+#include "../Core/EntityWrapper.h"
 
 namespace Events
 {
 
-struct PlayerHealthPickup : Event
-{
-    double HealthAmount;
-    EntityID PlayerHealedID;
-};
+    struct PlayerHealthPickup : Event
+    {
+        EntityWrapper Player;
+        double HealthAmount;
+    };
 
 }
 

include/Engine/Core/MemoryPool.h

@@ -102,7 +102,7 @@ public:
 			m_ExtraMemory.push_back((char*)malloc(m_Stride));
 			//We should preferably not enter here to avoid performance issues. Set more numMaxElements in constructor instead.
             if (!DisableMemoryPool::Value) {
-			    LOG_WARNING("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
+			    LOG_DEBUG("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
             }
 			return m_ExtraMemory.back();
 		}

include/Engine/Core/Octree.h

@@ -111,7 +111,7 @@ struct Child
     std::vector<ContainedObject>& m_StaticObjectsRef;
     std::vector<ContainedObject>& m_DynamicObjectsRef;
 
-    bool hasChildren() const;
+    inline bool hasChildren() const { return m_Children[0] != nullptr; }
     int childIndexContainingPoint(const glm::vec3& point) const;
     std::vector<int> childIndicesContainingBox(const AABB& box) const;
 };

include/Engine/Core/Ray.h

@@ -7,6 +7,10 @@
 class Ray
 {
 public:
+    Ray()
+        : m_Origin(glm::vec3(0.f))
+        , m_Direction(glm::vec3(0, 0, 1))
+    {}
     Ray(const glm::vec3& origin, const glm::vec3& dir)
         : m_Origin(origin)
         , m_Direction(glm::normalize(dir))

include/Engine/Core/Transform.h

@@ -18,6 +18,7 @@ glm::vec3 AbsoluteScale(EntityWrapper entity);
 glm::vec3 AbsoluteScale(World* world, EntityID entity);
 glm::mat4 ModelMatrix(EntityWrapper entity);
 glm::mat4 ModelMatrix(EntityID entity, World* world);
+glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
 
 }
 

include/Game/Systems/HealthSystem.h

@@ -12,6 +12,7 @@
 
 #include <tuple>
 #include <vector>
+#include <algorithm>
 
 class HealthSystem : public PureSystem
 {
@@ -26,7 +27,7 @@ private:
     EventRelay<HealthSystem, Events::PlayerDamage> m_EPlayerDamage;
     bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e);
     EventRelay<HealthSystem, Events::PlayerHealthPickup> m_EPlayerHealthPickup;
-    bool HealthSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup& e);
+    bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e);
 
     //vector which will keep track of health changes
     std::vector<std::tuple<EntityID, double>> m_DeltaHealthVector;

include/Game/Systems/PickupSpawnSystem.h

@@ -0,0 +1,33 @@
+#ifndef PickupSpawnSystem_h__
+#define PickupSpawnSystem_h__
+
+#include "Core/System.h"
+#include "Core/Transform.h"
+#include "Core/ResourceManager.h"
+#include "Core/EntityFileParser.h"
+#include "Core/EPickupSpawned.h"
+#include "Core/EPlayerHealthPickup.h"
+#include "Engine/Collision/ETrigger.h"
+#include "Common.h"
+#include <tuple>
+
+class PickupSpawnSystem : public ImpureSystem
+{
+public:
+    PickupSpawnSystem(World* world, EventBroker* eventBroker);
+
+    virtual void Update(double dt) override;
+
+private:
+    EventRelay<PickupSpawnSystem, Events::TriggerTouch> m_ETriggerTouch;
+    bool OnTriggerTouch(Events::TriggerTouch& e);
+
+    struct NewHealthPickup {
+        glm::vec3 Pos;
+        double HealthGain;
+        double RespawnTimer;
+        double DecreaseThisRespawnTimer;
+    };
+    std::vector<NewHealthPickup> m_ETriggerTouchVector;
+};
+#endif

include/Game/Systems/PlayerDeathSystem.h

@@ -0,0 +1,29 @@
+#ifndef PlayerDeathSystem_h__
+#define PlayerDeathSystem_h__
+
+#include "Core/System.h"
+#include "Input/EInputCommand.h"
+#include "GLM.h"
+#include "Rendering/ESetCamera.h"
+#include "Core/ConfigFile.h"
+
+#include "Core/EntityFile.h"
+#include "Core/EntityFileParser.h"
+
+#include "Core/EPlayerDeath.h"
+
+class PlayerDeathSystem : public ImpureSystem
+{
+public:
+    PlayerDeathSystem(World* world, EventBroker* eventBroker);
+
+    virtual void Update(double dt) override;
+
+private:
+    EventRelay<PlayerDeathSystem, Events::PlayerDeath> m_OnPlayerDeath;
+    bool OnPlayerDeath(Events::PlayerDeath& e);
+
+    void createDeathEffect(EntityWrapper player);
+
+};
+#endif

include/Game/Systems/PlayerSpawnSystem.h

@@ -3,6 +3,7 @@
 #include "Systems/SpawnerSystem.h"
 #include "Events/ESpawnerSpawn.h"
 #include "Core/EPlayerSpawned.h"
+#include "Core/EPlayerDeath.h"
 #include "Rendering/ESetCamera.h"
 #include "Core/ConfigFile.h"