Merge branch 'master' into CoolDeathAnimation

# Conflicts:
#	include/Engine/Rendering/ModelJob.h
#	resources/Shaders/ForwardPlus.frag.glsl
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/RenderSystem.cpp

src/Game/Game.cpp

@@ -10,6 +10,8 @@
 #include "Core/EntityFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
 #include "Game/Systems/WeaponSystem.h"
+#include "Game/Systems/PlayerHUD.h"
+#include "Game/Systems/LifetimeSystem.h"
 #include "../Engine/Rendering/AnimationSystem.h"
 
 Game::Game(int argc, char* argv[])
@@ -85,10 +87,13 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer);
+    m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<CollidableOctreeSystem>(updateOrderLevel, m_OctreeCollision);
+    m_SystemPipeline->AddSystem<PlayerHUD>(updateOrderLevel);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
+
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);

src/Game/Systems/LifetimeSystem.cpp

@@ -0,0 +1,27 @@
+#include "Systems/LifetimeSystem.h"
+
+void LifetimeSystem::Update(double dt)
+{
+    for (auto& e : m_Deletions) {
+        m_World->DeleteEntity(e.ID);
+    }
+    m_Deletions.clear();
+}
+
+void LifetimeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cLifetime, double dt)
+{
+    if (dt == 0.0) {
+        return;
+    }
+
+    if (!entity.Valid()) {
+        return;
+    }
+
+    double& lifetime = cLifetime["Lifetime"];
+    lifetime -= dt;
+
+    if (lifetime <= 0.0) {
+        m_Deletions.push_back(entity);
+    }
+}

src/Game/Systems/PlayerHUD.cpp

@@ -0,0 +1,57 @@
+#include "Game/Systems/PlayerHUD.h"
+
+PlayerHUD::PlayerHUD(World* world, EventBroker* eventBrokerer)
+    :System(world, eventBrokerer)
+    , m_World(world)
+    , m_EventBroker(eventBrokerer)
+{
+    
+    
+}
+
+PlayerHUD::~PlayerHUD()
+{
+    
+
+}
+
+void PlayerHUD::Update(double dt)
+{
+    auto healthHUDs = m_World->GetComponents("HealthHUD");
+    if (healthHUDs == nullptr) {
+        return;
+    }
+
+    for (auto& healthHUDComponent : *healthHUDs) {
+        EntityWrapper entity = EntityWrapper(m_World, healthHUDComponent.EntityID);
+
+        EntityWrapper entityIDParent = entity;
+        while (entityIDParent.Parent().Valid()) {
+            entityIDParent = entityIDParent.Parent();
+                
+            if (entityIDParent.HasComponent("Health")) {
+                break;
+            }
+        }
+
+        if (entityIDParent.HasComponent("Health")) {
+
+            if (entity.HasComponent("Text")) {
+                std::string s = "";
+                s = s + std::to_string((int)(double)entityIDParent["Health"]["Health"]);
+                s = s + "/";
+                s = s + std::to_string((int)(double)entityIDParent["Health"]["MaxHealth"]);
+                float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
+                (glm::vec4&)entity["Text"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, 1.f);
+                entity["Text"]["Content"] = s;
+            }
+
+            if(entity.HasComponent("Fill")) {
+                float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
+                (glm::vec4&)entity["Fill"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, 0.f);
+                (double&)entity["Fill"]["Percentage"] = healthPercentage;
+
+            }
+        }
+    }
+}

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -102,10 +102,10 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     }
 
     // TODO: Set the player name to whatever
-    //EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
-    //if (playerName.Valid()) {
-    //    playerName["Text"]["Content"] = ???;
-    //}
+    EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
+    if (playerName.Valid()) {
+        playerName["Text"]["Content"] = e.PlayerName;
+    }
 
     return true;
 }

src/Game/Systems/SpawnerSystem.cpp

@@ -50,7 +50,8 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
 
     // Set its position and orientation to that of the SpawnPoint
     spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
-    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint.World, spawnPoint.ID));
+    // TODO: Quaternions, bitch
+    //spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint.World, spawnPoint.ID));
 
     return spawnedEntity;
 }

src/Game/Systems/WeaponSystem.cpp

@@ -25,24 +25,68 @@ bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e)
 
 bool WeaponSystem::OnInputCommand(const Events::InputCommand& e)
 {
-    // Only shoot if the player is alive
-    if (!m_LocalPlayer.Valid()) {
-        return false;
-    }
-
     if (e.Command == "PrimaryFire" && e.Value > 0) {
         Events::Shoot eShoot;
-        eShoot.Player = m_LocalPlayer;
+        if (e.PlayerID == -1) {
+            eShoot.Player = m_LocalPlayer;
+        } else {
+            eShoot.Player = e.Player;
+        }
         m_EventBroker->Publish(eShoot);
     }
 
     return true;
 }
 
-bool WeaponSystem::OnShoot(const Events::Shoot& eShoot) 
+bool WeaponSystem::OnShoot(Events::Shoot& eShoot) 
 {
+    if (!eShoot.Player.Valid()) {
+        return false;
+    }
+
     // TODO: Weapon firing effects here
 
+    auto rayRed = ResourceManager::Load<EntityFile>("Schema/Entities/RayRed.xml");
+    auto rayBlue = ResourceManager::Load<EntityFile>("Schema/Entities/RayBlue.xml");
+
+    EntityWrapper weapon = eShoot.Player.FirstChildByName("WeaponMuzzle");
+    if (weapon.Valid()) {
+        EntityWrapper ray;
+        if ((ComponentInfo::EnumType)eShoot.Player["Team"]["Team"] == eShoot.Player["Team"]["Team"].Enum("Red")) {
+            EntityFileParser parser(rayRed);
+            EntityID rayID = parser.MergeEntities(m_World);
+            ray = EntityWrapper(m_World, rayID);
+        } else {
+            EntityFileParser parser(rayBlue);
+            EntityID rayID = parser.MergeEntities(m_World);
+            ray = EntityWrapper(m_World, rayID);
+        }
+
+        glm::mat4 transformation = Transform::AbsoluteTransformation(weapon);
+        glm::vec3 scale;
+        glm::vec3 translation;
+        glm::quat orientation;
+        glm::vec3 skew;
+        glm::vec4 perspective;
+        glm::decompose(transformation, scale, orientation, translation, skew, perspective);
+        
+        // Matrix to euler angles
+        glm::vec3 euler;
+        euler.y = glm::asin(-transformation[0][2]);
+        if (cos(euler.y) != 0) {
+            euler.x = atan2(transformation[1][2], transformation[2][2]);
+            euler.z = atan2(transformation[0][1], transformation[0][0]);
+        } else {
+            euler.x = atan2(-transformation[2][0], transformation[1][1]);
+            euler.z = 0;
+        }
+
+        //LOG_DEBUG("rotation: %f %f %f", euler.x, euler.y, euler.z);
+        (glm::vec3&)ray["Transform"]["Position"] = translation;
+        (glm::vec3&)ray["Transform"]["Orientation"] = euler;
+        //(glm::vec3&)ray["Transform"]["Orientation"] = Transform::AbsoluteOrientationEuler(weapon);
+    }
+
     // Only run further picking code client-side!
     if (eShoot.Player != m_LocalPlayer) {
         return false;