ColorFix

asdfsdaferf

include/Engine/Collision/Collision.h

@@ -20,6 +20,9 @@
 class World;
 struct ComponentWrapper;
 
+template<typename T>
+class Octree;
+
 namespace Collision
 {
 //Return true if the ray hits the box.
@@ -44,21 +47,24 @@ bool RayVsTriangle(const Ray& ray,
     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,
-    const std::vector<unsigned int>& modelIndices);
+bool RayVsModel(const Ray& ray,
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix);
 //Return true if the ray hits any of the triangles in the model.
 //Also returns the position of the intersection point. Will loop through all the whole model indices.
 bool RayVsModel(const Ray& ray,
-    const std::vector<RawModel::Vertex>& modelVertices,
+    const RawModel::Vertex* modelVertices,
     const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix,
     glm::vec3& outHitPosition);
 //Return true if the ray hits any of the triangles in the model.
 //Also returns the distance from the ray origin to the closest 
 //intersection point, and the barycentric u,v-coordinates. Will loop through all the whole model indices.
 bool RayVsModel(const Ray& ray,
-    const std::vector<RawModel::Vertex>& modelVertices,
+    const RawModel::Vertex* modelVertices,
     const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix,
     float& outDistance,
     float& outUCoord,
     float& outVCoord);
@@ -81,6 +87,13 @@ bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
 // Calculates an absolute AABB from an entity AABB component
 boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeModelBox = false);
 boost::optional<EntityAABB> AbsoluteAABBExplosionEffect(EntityWrapper& entity);
+//Returns the first entity hit by the input ray. entitiesPotentiallyHitSorted needs to be sorted 
+//by their distance to the ray, e.g. result from Octree<EntityAABB>::ObjectsPossiblyHitByRay.
+//Returns boost::none if none was hit. outDistance will be the distance to the intersection point if the ray intersects.
+boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, std::vector<EntityAABB> entitiesPotentiallyHitSorted, float& outDistance, glm::vec3& outIntersectPos);
+//Returns the first entity hit by the input ray that exists in the octree.
+//outDistance will be the distance to the intersection point if the ray intersects. 
+boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, Octree<EntityAABB>* octree, float& outDistance, glm::vec3& outIntersectPos);
 
 }
 

include/Engine/Core/EAmmoPickup.h

@@ -0,0 +1,18 @@
+#ifndef EAmmoPickup_h__
+#define EAmmoPickup_h__
+
+#include "EventBroker.h"
+#include "../Core/EntityWrapper.h"
+
+namespace Events
+{
+
+    struct AmmoPickup : Event
+    {
+        EntityWrapper Player;
+        int AmmoGain;
+    };
+
+}
+
+#endif

include/Engine/Core/EPlayerDamage.h

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

include/Engine/Core/EShoot.h

@@ -9,7 +9,8 @@ namespace Events
 
 struct Shoot : Event
 {
-    EntityWrapper Player;
+    EntityWrapper Inflictor;
+    double Damage;
 };
 
 }

include/Engine/Core/Octree.h

@@ -41,6 +41,8 @@ public:
     void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects);
     //Get the objects that are inside the frustum, the objects are put in outObjects.
     void ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObjects);
+    //Get objects, which AABB the input ray intersects, the objects are put in outObjects.
+    void ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects);
     //Empty the tree of all objects, static and dynamic.
     void ClearObjects();
     //Empty the tree of all dynamic objects. Static objects remain in the tree.
@@ -100,6 +102,8 @@ struct Child
     void ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects) const;
     template<typename T>
     void ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObjects, bool takeAllDontTest) const;
+    template<typename T>
+    void ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects) const;
     void ClearObjects();
     void ClearDynamicObjects();
     bool RayCollides(const Ray& ray, Output& data) const;
@@ -119,6 +123,15 @@ struct Child
     std::vector<int> childIndicesContainingBox(const AABB& box) const;
 };
 
+//To be able to sort child nodes and contained objects based on distance to ray origin.
+struct RaySorterInfo
+{
+    int Index;
+    float Distance;
+};
+
+bool isFirstLower(const RaySorterInfo& first, const RaySorterInfo& second);
+
 }
 
 template<typename T>
@@ -164,6 +177,13 @@ void Octree<T>::ObjectsInFrustum(const Frustum& frustum, std::vector<T>& outObje
     m_Root->ObjectsInFrustum(frustum, outObjects, false);
 }
 
+template<typename T>
+void Octree<T>::ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects)
+{
+    falsifyObjectChecks();
+    m_Root->ObjectsPossiblyHitByRay(ray, outObjects);
+}
+
 template<typename T>
 void Octree<T>::ClearObjects()
 {
@@ -282,4 +302,59 @@ void OctSpace::Child::ObjectsInFrustum(const Frustum& frustum, std::vector<T>& o
     }
 }
 
+template<typename T>
+void OctSpace::Child::ObjectsPossiblyHitByRay(const Ray& ray, std::vector<T>& outObjects) const
+{
+    //If the node AABB is missed, everything it contains is missed.
+    if (Collision::RayAABBIntr(ray, m_Box)) {
+        //If the ray shoots the tree, and it is a parent.
+        if (hasChildren()) {
+            //Sort children according to their distance from the ray origin.
+            std::vector<RaySorterInfo> childInfos;
+            childInfos.resize(8);
+            for (int i = 0; i < 8; ++i) {
+                childInfos[i] = { i, glm::distance(ray.Origin(), m_Children[i]->m_Box.Origin()) };
+            }
+            std::sort(childInfos.begin(), childInfos.end(), isFirstLower);
+            //Loop through the children, starting with the one closest to the ray origin. I.e the first to be hit.
+            for (const RaySorterInfo& info : childInfos) {
+                m_Children[info.Index]->ObjectsPossiblyHitByRay(ray, outObjects);
+            }
+        } else {
+            //Check against boxes in the node.
+            bool intersected = false;
+            float dist;
+            //Sort all contained objects according to the distance from the ray origin to 
+            //the intersection, if they are intersecting.
+            std::vector<RaySorterInfo> objectHitInfos;
+            objectHitInfos.reserve(m_StaticObjIndices.size() + m_DynamicObjIndices.size());
+            for (int i : m_StaticObjIndices) {
+                //If we haven't tested against this object before, and the ray hits.
+                if (!m_StaticObjectsRef[i].Checked &&
+                        Collision::RayVsAABB(ray, *m_StaticObjectsRef[i].Box, dist)) {
+                    objectHitInfos.push_back({ i, dist });
+                }
+                m_StaticObjectsRef[i].Checked = true;
+            }
+            for (int i : m_DynamicObjIndices) {
+                //If we haven't tested against this object before, and the ray hits.
+                if (!m_DynamicObjectsRef[i].Checked &&
+                        Collision::RayVsAABB(ray, *m_DynamicObjectsRef[i].Box, dist)) {
+                    objectHitInfos.push_back({ i + (int)m_StaticObjIndices.size(), dist });
+                }
+                m_DynamicObjectsRef[i].Checked = true;
+            }
+            std::sort(objectHitInfos.begin(), objectHitInfos.end(), isFirstLower);
+            int startSize = (int)outObjects.size();
+            outObjects.resize(startSize + objectHitInfos.size());
+            for (int i = 0; i < objectHitInfos.size(); ++i) {
+                outObjects[startSize + i] = (objectHitInfos[i].Index < m_StaticObjIndices.size()) ?
+                    *static_cast<T*>(m_StaticObjectsRef[objectHitInfos[i].Index].Box.get()) :
+                    *static_cast<T*>(m_DynamicObjectsRef[objectHitInfos[i].Index - m_StaticObjIndices.size()].Box.get());
+            }
+        }
+    }
+}
+
+
 #endif

include/Engine/GUI/TextureFrame.h

@@ -3,6 +3,7 @@
 
 #include "Frame.h"
 #include "../Rendering/Texture.h"
+#include "../Rendering/Util/CommonFunctions.h"
 
 namespace GUI
 {
@@ -55,10 +56,10 @@ public:
 			return;
 		}
 
-		m_Texture = ResourceManager::Load<Texture>(resourceName);
+		m_Texture = CommonFunctions::LoadTexture(resourceName, false);
 		m_TextureName = resourceName;
 		if (m_Texture == nullptr) {
-			m_Texture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
+			m_Texture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
 		}
 
 		SizeToTexture();

include/Engine/Rendering/Camera.h

@@ -33,6 +33,8 @@ public:
 	glm::mat4 ViewMatrix() const { return m_ViewMatrix; }
     void SetViewMatrix(glm::mat4 val);
 
+    glm::mat4 BillboardMatrix();
+
 	float AspectRatio() const { return m_AspectRatio; }
 	void SetAspectRatio(float val);
 

include/Engine/Rendering/DrawFinalPass.h

@@ -7,6 +7,7 @@
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
 #include "Util/UnorderedMapVec2.h"
+#include "Util/CommonFunctions.h"
 #include "Texture.h"
 
 class DrawFinalPass
@@ -35,6 +36,7 @@ private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
     void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
 
+    void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
     void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
@@ -50,6 +52,7 @@ private:
     Texture* m_BlackTexture;
     Texture* m_NeutralNormalTexture;
     Texture* m_GreyTexture;
+    Texture* m_ErrorTexture;
 
     FrameBuffer m_FinalPassFrameBuffer;
     FrameBuffer m_FinalPassFrameBufferLowRes;
@@ -69,6 +72,7 @@ private:
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
+    ShaderProgram* m_SpriteProgram;
 	ShaderProgram* m_ForwardPlusSplatMapProgram;
     ShaderProgram* m_ShieldToStencilProgram;
     ShaderProgram* m_FillDepthBufferProgram;

include/Engine/Rendering/Model.h

@@ -2,6 +2,7 @@
 #define Model_h__
 
 #include "Rendering/RawModelCustom.h"
+#include "Util/CommonFunctions.h"
 //#include "Rendering/RawModelAssimp.h"
 #include "../OpenGL.h"
 #include "Core/AABB.h"

include/Engine/Rendering/ModelJob.h

@@ -120,6 +120,32 @@ struct ModelJob : RenderJob
 
         if (model->IsSkinned()) {
             Skeleton = Model->m_RawModel->m_Skeleton;
+
+            if (Skeleton != nullptr) {
+                if (world->HasComponent(Entity, "Animation")) {
+                    auto animationComponent = world->GetComponent(Entity, "Animation");
+
+                    for (int i = 1; i <= 3; i++) {
+                        ::Skeleton::AnimationData animationData;
+                        animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationComponent["AnimationName" + std::to_string(i)]);
+                        if (animationData.animation == nullptr) {
+                            continue;
+                        }
+                        animationData.time = (double)animationComponent["Time" + std::to_string(i)];
+                        animationData.weight = (double)animationComponent["Weight" + std::to_string(i)];
+
+                        Animations.push_back(animationData);
+                    }
+                }
+
+                if (world->HasComponent(Entity, "AnimationOffset")) {
+                    auto animationOffsetComponent = world->GetComponent(Entity, "AnimationOffset");
+                    AnimationOffset.animation = model->m_RawModel->m_Skeleton->GetAnimation(animationOffsetComponent["AnimationName"]);
+                    AnimationOffset.time = (double)animationOffsetComponent["Time"];
+                } else {
+                    AnimationOffset.animation = nullptr;
+                }
+            }
         }
             
     };
@@ -140,8 +166,8 @@ struct ModelJob : RenderJob
     glm::vec4 Color;
     const ::Model* Model = nullptr;
     ::Skeleton* Skeleton = nullptr;
-   // const ::Skeleton::Animation* Animation = nullptr;
-
+    std::vector<::Skeleton::AnimationData> Animations;
+    ::Skeleton::AnimationOffset AnimationOffset;
     
 
 

include/Engine/Rendering/PNG.h

@@ -6,9 +6,10 @@
 #include <png.h>
 
 #include "../Common.h"
+#include "../Core/ResourceManager.h"
 #include "Image.h"
 
-class PNG : public Image
+class PNG : public Image, public Resource
 {
 public:
 	PNG(std::string path);

include/Engine/Rendering/RawModelCustom.h

@@ -50,7 +50,7 @@ public:
 	struct TextureProperties {
 		std::string TexturePath;
 		glm::vec2 UVRepeat;
-		std::shared_ptr<::Texture> Texture;	
+		Texture* Texture;	
 	};
 	
     struct MaterialBasic

include/Engine/Rendering/RenderQueue.h

@@ -15,6 +15,7 @@
 #include "PointLightJob.h"
 #include "DirectionalLightJob.h"
 #include "ExplosionEffectJob.h"
+#include "SpriteJob.h"
 
 struct RenderScene
 {
@@ -25,6 +26,7 @@ struct RenderScene
         std::list<std::shared_ptr<RenderJob>> OpaqueShieldedObjects;
         std::list<std::shared_ptr<RenderJob>> TransparentShieldedObjects;
         std::list<std::shared_ptr<RenderJob>> ShieldObjects;
+        std::list<std::shared_ptr<RenderJob>> SpriteJob;
         std::list<std::shared_ptr<RenderJob>> PointLight;
         std::list<std::shared_ptr<RenderJob>> Text;
         std::list<std::shared_ptr<RenderJob>> DirectionalLight;
@@ -41,7 +43,7 @@ struct RenderScene
         Jobs.OpaqueShieldedObjects.clear();
         Jobs.TransparentShieldedObjects.clear();
         Jobs.ShieldObjects.clear();
-        Jobs.Text.clear();
+        Jobs.SpriteJob.clear();
         Jobs.DirectionalLight.clear();
 	}
 };

include/Engine/Rendering/RenderSystem.h

@@ -18,6 +18,7 @@
 #include "../Core/EPlayerSpawned.h"
 #include "../Core/Octree.h"
 #include "../Collision/EntityAABB.h"
+#include "../Core/ConfigFile.h"
 
 class RenderSystem : public ImpureSystem
 {
@@ -47,6 +48,10 @@ private:
     void fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
+    void fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+
+    bool isEntityVisible(EntityWrapper& entity);
+
     bool isChildOfACamera(EntityWrapper entity);
     bool isChildOfCurrentCamera(EntityWrapper entity);
 };

include/Engine/Rendering/Renderer.h

@@ -22,6 +22,7 @@
 #include "../Core/Transform.h"
 #include "imgui/imgui.h"
 #include "TextPass.h"
+#include "Util/CommonFunctions.h"
 
 class Renderer : public IRenderer
 {

include/Engine/Rendering/Skeleton.h

@@ -100,50 +100,29 @@ public:
 
 	int GetBoneID(std::string name);
 
-    void CalculateFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion = false);
-    void CalculateFrameBones(std::vector<AnimationData> animations, bool noRootMotion = false);
+    std::vector<glm::mat4>  GetFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion = false);
+    std::vector<glm::mat4>  GetFrameBones(std::vector<AnimationData> animations, bool noRootMotion = false);
 
     const Animation* GetAnimation(std::string name);
 
-    void  AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, const Bone* bone, glm::mat4 parentMatrix);
-    void  AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, const Bone* bone, glm::mat4 parentMatrix);
+    void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, std::map<int, glm::mat4>& frameBones, const Bone* bone, glm::mat4 parentMatrix);
+    void AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, std::map<int, glm::mat4>& frameBones, const Bone* bone, glm::mat4 parentMatrix);
 
     void PrintSkeleton();
 	void PrintSkeleton(const Bone* parent, int depthCount);
 	std::map<std::string, Animation> Animations;
 
     glm::mat4 GetBoneTransform(const Bone* bone, const Animation* animation, float time, glm::mat4 childMatrix);
+    glm::mat4 GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, AnimationOffset animationOffset, glm::mat4 childMatrix);
+    glm::mat4 GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, glm::mat4 childMatrix);
     int GetKeyframe(const Animation& animation, double time);
 
-
-    std::vector<glm::mat4> GetBones()
-    {
-        std::vector<glm::mat4> finalMatrices;
-        for (auto &kv : m_BoneLocalTransforms) {
-            finalMatrices.push_back(kv.second);
-        }
-        return finalMatrices;;
-    }
-
-    glm::mat4 GetBoneTransformSuper(int boneID)
-    {
-        if(m_BoneTransforms.find(boneID) != m_BoneTransforms.end()) {
-            return m_BoneTransforms.at(boneID);
-        } else {
-            return glm::mat4(1);
-        }
-    }
-
 private:
 
     glm::mat4 GetOffsetTransform(const Bone* bone, AnimationOffset animationOffset);
 
 	std::map<std::string, Bone*> m_BonesByName;
-    float aim = 0.f;
-
-
-    std::map<int, glm::mat4> m_BoneLocalTransforms;
-    std::map<int, glm::mat4> m_BoneTransforms;
+    
 };
 
 #endif

include/Engine/Rendering/SpriteJob.h

@@ -0,0 +1,73 @@
+#ifndef SpriteJob_h__
+#define SpriteJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "Texture.h"
+#include "Model.h"
+#include "RenderJob.h"
+#include "../Core/ResourceManager.h"
+#include "Camera.h"
+#include "../Core/World.h"
+#include "../Core/Transform.h"
+#include "Skeleton.h"
+
+struct SpriteJob : RenderJob
+{
+    SpriteJob(ComponentWrapper cSprite, Camera* camera, glm::mat4 matrix, World* world, glm::vec4 fillColor, float fillPercentage, bool depthSorted)
+        : RenderJob()
+    {
+        Model = ResourceManager::Load<::Model>("Models/Core/UnitQuad.mesh");
+        ::RawModel::MaterialProperties matProp = Model->MaterialGroups().front();
+        TextureID = 0;
+
+        DiffuseTexture = CommonFunctions::LoadTexture(cSprite["DiffuseTexture"], true);
+
+        IncandescenceTexture = CommonFunctions::LoadTexture(cSprite["GlowMap"], true);
+
+        StartIndex = matProp.material->StartIndex;
+        EndIndex = matProp.material->EndIndex;
+        Matrix = matrix;
+        Color = cSprite["Color"];
+        Entity = cSprite.EntityID;
+        Position = Transform::AbsolutePosition(world, cSprite.EntityID);
+        Depth = 0;
+        if (depthSorted) {
+            glm::vec3 viewpos = glm::vec3(camera->ViewMatrix() * glm::vec4(Position, 1));
+            Depth = viewpos.z;
+        }
+        World = world;
+
+        FillColor = fillColor;
+        FillPercentage = fillPercentage;
+    };
+
+    unsigned int TextureID;
+
+    EntityID Entity;
+    glm::mat4 Matrix;
+    const Texture* DiffuseTexture;
+    const Texture* NormalTexture;
+    const Texture* SpecularTexture;
+    const Texture* IncandescenceTexture;
+    float Shininess = 0.f;
+    glm::vec4 Color;
+    glm::vec3 Position;
+    const ::Model* Model = nullptr;
+    unsigned int StartIndex = 0;
+    unsigned int EndIndex = 0;
+    World* World;
+
+    glm::vec4 FillColor = glm::vec4(0);
+    float FillPercentage = 0.0;
+
+    void CalculateHash() override
+    {
+        Hash = TextureID;
+    }
+};
+
+#endif

include/Engine/Rendering/Util/CommonFunctions.h

@@ -4,14 +4,11 @@
 #include "../../Common.h"
 #include "../../OpenGL.h"
 #include "../../GLM.h"
+#include "../Texture.h"
 
-class CommonFuntions
-{
-public:
-    CommonFuntions() = delete;
-
-private:
-
+namespace CommonFunctions
+{ 
+Texture* LoadTexture(std::string path, bool threaded);
 };
 
 #endif

include/Game/Systems/AmmoPickupSystem.h

@@ -0,0 +1,32 @@
+#ifndef AmmoPickupSystem_h__
+#define AmmoPickupSystem_h__
+
+#include "Core/System.h"
+#include "Core/Transform.h"
+#include "Core/ResourceManager.h"
+#include "Core/EntityFileParser.h"
+#include "Core/EPickupSpawned.h"
+#include "Core/EAmmoPickup.h"
+#include "Engine/Collision/ETrigger.h"
+#include "Common.h"
+
+class AmmoPickupSystem : public ImpureSystem
+{
+public:
+    AmmoPickupSystem(SystemParams params);
+
+    virtual void Update(double dt) override;
+
+private:
+    EventRelay<AmmoPickupSystem, Events::TriggerTouch> m_ETriggerTouch;
+    bool OnTriggerTouch(Events::TriggerTouch& e);
+
+    struct NewAmmoPickup {
+        glm::vec3 Pos;
+        double AmmoGain;
+        double RespawnTimer;
+        double DecreaseThisRespawnTimer;
+    };
+    std::vector<NewAmmoPickup> m_ETriggerTouchVector;
+};
+#endif

include/Game/Systems/CapturePointHUDSystem.h

@@ -0,0 +1,22 @@
+#ifndef CapturePointHUDSystem_h__
+#define CapturePointHUDSystem_h__
+
+#include <GLFW/glfw3.h>
+#include <glm/common.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Engine/Collision/ETrigger.h"
+
+class CapturePointHUDSystem : public ImpureSystem
+{
+public:
+    CapturePointHUDSystem(SystemParams params);
+
+    virtual void Update(double dt) override;
+
+private:
+};
+
+#endif

include/Game/Systems/CapturePointSystem.h

@@ -44,7 +44,6 @@ private:
 
     //std::vector<ComponentWrapper>
 
-    const double m_CaptureTimeToTakeOver = 15.0;
     bool m_ResetTimers = false;
 
     //vectors which will keep track of enter/leave changes

include/Game/Systems/DamageIndicatorSystem.h

@@ -0,0 +1,33 @@
+#ifndef DamageIndicatorSystem_h__
+#define DamageIndicatorSystem_h__
+
+#include "Core/System.h"
+#include "Core/Transform.h"
+#include "Core/ResourceManager.h"
+#include "Core/EntityFileParser.h"
+#include "Core/EPlayerDamage.h"
+#include "Common.h"
+#include <tuple>
+
+#include "Rendering/ESetCamera.h"
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/vector_angle.hpp>
+
+#include "Rendering/Util/CommonFunctions.h"
+
+class DamageIndicatorSystem : public System
+{
+public:
+    DamageIndicatorSystem(SystemParams params);
+
+private:
+    EventRelay<DamageIndicatorSystem, Events::PlayerDamage> m_EPlayerDamage;
+    bool OnPlayerDamage(Events::PlayerDamage& e);
+
+    EventRelay<DamageIndicatorSystem, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera& e);
+
+    EntityID m_CurrentCamera = -1;
+
+};
+#endif

include/Game/Systems/HealthSystem.h

@@ -9,6 +9,7 @@
 #include "Core/EPlayerDamage.h"
 #include "Core/EPlayerHealthPickup.h"
 #include "Core/EPlayerDeath.h"
+#include "../Engine/Input/EInputCommand.h"
 
 #include <tuple>
 #include <vector>
@@ -28,7 +29,9 @@ private:
     bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e);
     EventRelay<HealthSystem, Events::PlayerHealthPickup> m_EPlayerHealthPickup;
     bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e);
-
+    EventRelay<HealthSystem, Events::InputCommand> m_InputCommand;
+    bool HealthSystem::OnInputCommand(Events::InputCommand& e);
+    
     //vector which will keep track of health changes
     std::vector<std::tuple<EntityID, double>> m_DeltaHealthVector;
    

include/Game/Systems/PlayerSpawnSystem.h

@@ -13,6 +13,8 @@ public:
     PlayerSpawnSystem(SystemParams params);
 
     virtual void Update(double dt) override;
+    
+    static void SetRespawnTime(float respawnTime) { m_RespawnTime = respawnTime; };
 
 private:
     struct SpawnRequest
@@ -23,10 +25,19 @@ private:
 
     bool m_NetworkEnabled = false;
     std::vector<SpawnRequest> m_SpawnRequests;
+
+    //Player ID -> EntityWrapper.
     std::map<int, EntityWrapper> m_PlayerEntities;
+    //EntityWrapper ID -> Player ID.
+    std::map<EntityID, int> m_PlayerIDs;
+
+    static float m_RespawnTime;
+    float m_Timer;
 
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
-    bool OnInputCommand(const Events::InputCommand& e);
+    bool OnInputCommand(Events::InputCommand& e);
     EventRelay<PlayerSpawnSystem, Events::PlayerSpawned> m_OnPlayerSpawnerd;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
+    EventRelay<PlayerSpawnSystem, Events::PlayerDeath> m_OnPlayerDeath;
+    bool OnPlayerDeath(Events::PlayerDeath& e);
 };

include/Game/Systems/Weapon/AssaultWeaponBehaviour.h

@@ -0,0 +1,44 @@
+#include "Sound/EPlaySoundOnEntity.h"
+#include "Collision/Collision.h"
+#include "Rendering/AnimationSystem.h"
+#include "WeaponBehaviour.h"
+#include "../SpawnerSystem.h"
+#include "Core/EPlayerDamage.h"
+#include "Core/EShoot.h"
+
+class AssaultWeaponBehaviour : public WeaponBehaviour
+{
+public:
+    AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity);
+    
+    virtual void Fire() override;
+    virtual void CeaseFire() override;
+    virtual void Reload() override;
+
+    virtual void Update(double dt) override;
+
+private:
+    EntityWrapper m_FirstPersonModel;
+    // State
+    bool m_Firing = false;
+    bool m_Reloading = false;
+    double m_ReloadTimer = 0.0;
+    EntityWrapper m_ReloadImpersonator;
+    double m_TimeSinceLastFire = 0.0;
+
+    EventRelay<WeaponBehaviour, Events::AnimationComplete> m_EAnimationComplete;
+    bool OnAnimationComplete(Events::AnimationComplete& e);
+
+    bool hasAmmo();
+    void fireRound();
+    void spawnTracer();
+    float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
+    void playSound();
+    void viewPunch();
+    void finishReload();
+    void playShootAnimation();
+    void playIdleAnimation();
+    void playReloadAnimation();
+    bool shoot(double damage);
+    void showHitMarker();
+};

include/Game/Systems/Weapon/WeaponBehaviour.h

@@ -0,0 +1,34 @@
+#ifndef WeaponBehaviour_h__
+#define WeaponBehaviour_h__
+
+#include "Core/System.h"
+#include "Rendering/IRenderer.h"
+#include "Core/Octree.h"
+#include "Collision/EntityAABB.h"
+
+class WeaponBehaviour : public System
+{
+public:
+    WeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper player)
+        : System(systemParams)
+        , m_Renderer(renderer)
+        , m_CollisionOctree(collisionOctree)
+        , m_Player(player)
+    { }
+    virtual ~WeaponBehaviour() = default;
+
+    WeaponBehaviour(const WeaponBehaviour&) = delete;
+    WeaponBehaviour& operator=(const WeaponBehaviour &) = delete;
+
+    virtual void Fire() = 0;
+    virtual void CeaseFire() { }
+    virtual void Reload() { }
+    virtual void Update(double dt) { }
+
+protected:
+    IRenderer* m_Renderer;
+    Octree<EntityAABB>* m_CollisionOctree;
+    EntityWrapper m_Player;
+};
+
+#endif

include/Game/Systems/Weapon/WeaponSystem.h

@@ -0,0 +1,44 @@
+#ifndef WeaponSystem_h__
+#define WeaponSystem_h__
+
+#include "Rendering/IRenderer.h"
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Core/EPlayerDamage.h"
+#include "Core/EShoot.h"
+#include "Core/EPlayerSpawned.h"
+#include "Input/EInputCommand.h"
+#include "Core/EntityFile.h"
+#include "Core/EntityFileParser.h"
+#include "Core/Octree.h"
+#include "Collision/EntityAABB.h"
+#include "Systems/SpawnerSystem.h"
+#include "Sound/EPlaySoundOnEntity.h"
+#include "AssaultWeaponBehaviour.h"
+
+class WeaponSystem : public PureSystem, ImpureSystem
+{
+public:
+    WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree);
+
+    virtual void Update(double dt) override;
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt) override;
+
+private:
+    SystemParams m_SystemParams;
+    IRenderer* m_Renderer;
+    Octree<EntityAABB>* m_CollisionOctree;
+
+    std::unordered_map<EntityWrapper, std::shared_ptr<WeaponBehaviour>> m_ActiveWeapons;
+
+    // Events
+    EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(Events::PlayerSpawned& e);
+    EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(Events::InputCommand& e);
+
+    void selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot);
+};
+
+#endif

include/Game/Systems/WeaponSystem.h

@@ -1,192 +0,0 @@
-#ifndef WeaponSystem_h__
-#define WeaponSystem_h__
-
-//#include <GLFW/glfw3.h>
-//#include <glm/common.hpp>
-#include "Rendering/IRenderer.h"
-
-#include "Common.h"
-#include "Core/System.h"
-#include "Core/EPlayerDamage.h"
-#include "Core/EShoot.h"
-#include "Core/EPlayerSpawned.h"
-#include "Input/EInputCommand.h"
-#include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
-#include "Core/Octree.h"
-#include "Collision/EntityAABB.h"
-#include "Systems/SpawnerSystem.h"
-#include "Sound/EPlaySoundOnEntity.h"
-
-class WeaponBehaviour;
-
-class WeaponSystem : public PureSystem, ImpureSystem
-{
-public:
-    WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree);
-
-    virtual void Update(double dt) override;
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt) override;
-
-private:
-    SystemParams m_SystemParams;
-    IRenderer* m_Renderer;
-    Octree<EntityAABB>* m_CollisionOctree;
-
-    std::unordered_map<EntityWrapper, std::shared_ptr<WeaponBehaviour>> m_ActiveWeapons;
-
-    // Events
-    EventRelay<WeaponSystem, Events::PlayerSpawned> m_EPlayerSpawned;
-    bool OnPlayerSpawned(Events::PlayerSpawned& e);
-    EventRelay<WeaponSystem, Events::Shoot> m_EShoot;
-    bool OnShoot(Events::Shoot& e);
-    EventRelay<WeaponSystem, Events::InputCommand> m_EInputCommand;
-    bool OnInputCommand(Events::InputCommand& e);
-
-    void selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot);
-};
-
-class WeaponBehaviour : public System
-{
-public:
-    WeaponBehaviour(SystemParams systemParams, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity)
-        : System(systemParams)
-        , m_CollisionOctree(collisionOctree)
-        , m_Entity(weaponEntity)
-    { }
-    virtual ~WeaponBehaviour() = default;
-
-    WeaponBehaviour(const WeaponBehaviour&) = delete;
-    WeaponBehaviour& operator=(const WeaponBehaviour &) = delete;
-
-    virtual void Fire() = 0;
-    virtual void CeaseFire() { }
-    virtual void Reload() { }
-    virtual void Update(double dt) { }
-
-protected:
-    Octree<EntityAABB>* m_CollisionOctree;
-    EntityWrapper m_Entity;
-};
-
-class AssaultWeaponBehaviour : public WeaponBehaviour
-{
-public:
-    AssaultWeaponBehaviour(SystemParams systemParams, Octree<EntityAABB>* collisionOctree, EntityWrapper weaponEntity)
-        : WeaponBehaviour(systemParams, collisionOctree, weaponEntity)
-    { }
-    
-    virtual void Fire() override
-    {
-        m_TimeSinceLastFire = 0.0;
-        m_Firing = true;
-        fireRound();
-    }
-
-    virtual void CeaseFire() override
-    {
-        m_Firing = false;
-    }
-
-    virtual void Reload() override
-    {
-        ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
-
-        int& magAmmo = cAssaultWeapon["MagazineAmmo"];
-        int magSize = cAssaultWeapon["MagazineSize"];
-        int& ammo = cAssaultWeapon["Ammo"];
-
-        // Don't reload if we're already fully loaded
-        if (magAmmo == magSize) {
-            return;
-        }
-
-        // Throw away rounds in magazine to incentivise ammo sharing
-        int toLoad = glm::min(magSize, ammo);
-        magAmmo = toLoad;
-        ammo -= toLoad;
-    }
-
-    virtual void Update(double dt) override
-    {
-        if (!m_Firing) {
-            return;
-        }
-
-        m_TimeSinceLastFire += dt;
-
-        ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
-        if (m_TimeSinceLastFire >= 1.0 / ((double)cAssaultWeapon["RPM"] / 60.0)) {
-            fireRound();
-        }
-    }
-
-private:
-    bool m_Firing = false;
-    double m_TimeSinceLastFire = 0.0;
-    EntityFile* m_RayRed = nullptr;
-    EntityFile* m_RayBlue = nullptr;
-
-    void fireRound()
-    {
-        ComponentWrapper& cAssaultWeapon = m_Entity["AssaultWeapon"];
-
-        int& magAmmo = cAssaultWeapon["MagazineAmmo"];
-        int ammo = cAssaultWeapon["Ammo"];
-
-        // Reload if our magazine is empty
-        if (magAmmo <= 0) {
-            Reload();
-            return;
-        }
-
-        // Fire
-        magAmmo -= 1;
-        spawnTracer();
-        playSound();
-
-        m_TimeSinceLastFire = 0.0;
-    }
-
-    void spawnTracer()
-    {
-        if (!IsClient) {
-            return;
-        }
-
-        EntityWrapper spawner;
-        if (m_Entity == LocalPlayer) {
-            spawner = m_Entity.FirstChildByName("WeaponMuzzle");
-        } else {
-            spawner = m_Entity.FirstChildByName("ThirdPersonWeaponMuzzle");
-        }
-
-        if (!spawner.Valid()) {
-            return;
-        }
-
-        Events::SpawnerSpawn e;
-        e.Spawner = spawner;
-        m_EventBroker->Publish(e);
-    }
-
-    float traceRayDistance(glm::vec3 origin, glm::vec3 direction)
-    {
-        // TODO: Cast a ray and size tracer appropriately
-        return 100.f;
-    }
-
-    void playSound()
-    { 
-        if (!IsClient) {
-            return;
-        }
-
-        Events::PlaySoundOnEntity e;
-        e.EmitterID = m_Entity.ID;
-        e.FilePath = "Audio/laser/laser1.wav";
-        m_EventBroker->Publish(e);
-    }
-};
-
-#endif

resources/DefaultConfig.ini

@@ -4,6 +4,9 @@ LoadMap=
 ; if true -> Pool allocation is not used when calling Allocate/Free, just use regular dynamic allocation. 
 ; if false -> Use pool allocation.
 DisableMemoryPool=false
+RespawnTime = 8.0
+EditorEnabled=false
+OutOfBodyExperience=false
 
 [Editor]
 CameraSpeed=3

resources/DefaultInput.ini

@@ -24,4 +24,5 @@ F1=ToggleEditor
 C=ConnectToServer
 N=SwitchToServer
 M=SwitchToClient
-P=SwitchToPlayer
+P=SwitchToPlayer
+K=TakeDamage,1500

resources/Schema/Components.xsd

@@ -32,9 +32,12 @@
 	<xs:include schemaLocation="Components/Lifetime.xsd"/>
 	<xs:include schemaLocation="Components/HiddenForLocalPlayer.xsd"/>
 	<xs:include schemaLocation="Components/HealthPickup.xsd"/>
+	<xs:include schemaLocation="Components/AmmoPickup.xsd"/>
 	<xs:include schemaLocation="Components/AnimationOffset.xsd"/>
 	<xs:include schemaLocation="Components/DashAbility.xsd"/>
 	<xs:include schemaLocation="Components/AssaultWeapon.xsd"/>
 	<xs:include schemaLocation="Components/Shield.xsd"/>
+	<xs:include schemaLocation="Components/Sprite.xsd"/>
 	<xs:include schemaLocation="Components/Shielded.xsd"/>
+	<xs:include schemaLocation="Components/CapturePointHUD.xsd"/>
 </xs:schema>

resources/Schema/Components/AmmoPickup.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<AmmoPickup xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="AmmoPickup.xsd">
+	<RespawnTimer>3</RespawnTimer>
+	<AmmoGain>30</AmmoGain>
+</AmmoPickup>

resources/Schema/Components/AmmoPickup.xsd

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="AmmoPickup">
+		<xs:annotation>
+			<xs:documentation>An Ammo Pickup</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="RespawnTimer" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>The respawn timer for a ammo pickup</xs:documentation></xs:annotation>
+				</xs:element>			
+				<xs:element name="AmmoGain" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>How much percent ammo gain the player will get</xs:documentation></xs:annotation>
+				</xs:element>			
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/AssaultWeapon.xml

@@ -6,4 +6,6 @@
 	<MaxAmmo>360</MaxAmmo>
 	<BaseDamage>5</BaseDamage>
 	<RPM>120</RPM>
+	<ViewPunch>0.01</ViewPunch>
+	<ReloadTime>2</ReloadTime>
 </AssaultWeapon>

resources/Schema/Components/AssaultWeapon.xsd

@@ -22,6 +22,12 @@
 				<xs:element name="RPM" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>Rate of fire in rounds per minute</xs:documentation></xs:annotation>
 				</xs:element>
+				<xs:element name="ViewPunch" type="t:float" minOccurs="0">
+					<xs:annotation><xs:documentation>View punch in radians for each bullet fired</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="ReloadTime" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>Time it takes to reload the weapon in seconds</xs:documentation></xs:annotation>
+				</xs:element>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Components/CapturePoint.xml

@@ -2,5 +2,6 @@
 <CapturePoint xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="CapturePoint.xsd">
 	<CapturePointNumber>0</CapturePointNumber>
 	<CaptureTimer>0</CaptureTimer>
+	<CapturePointMaxTimer>15</CapturePointMaxTimer>
 	<HomePointForTeam><Spectator/></HomePointForTeam>
 </CapturePoint>

resources/Schema/Components/CapturePoint.xsd

@@ -20,7 +20,11 @@
 						<xs:documentation>CapturePointNumber specify an int number for this</xs:documentation>
 					</xs:annotation>
 				</xs:element>
-
+				<xs:element name="CapturePointMaxTimer" type="t:double" minOccurs="0">
+					<xs:annotation>
+						<xs:documentation>The time needed to take over a Capture Point</xs:documentation>
+					</xs:annotation>
+				</xs:element>
 				<xs:element name="HomePointForTeam" type="TeamEnum" minOccurs="0">
 					<xs:annotation>
 						<xs:documentation>Specify if this is a HomePoint for either team</xs:documentation>

resources/Schema/Components/CapturePointHUD.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<CapturePointHUD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="CapturePointHUD.xsd">
+	<CapturePointNumber>0</CapturePointNumber>
+	<Owner><Spectator/></Owner>
+</CapturePointHUD>

resources/Schema/Components/CapturePointHUD.xsd

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	<xs:include schemaLocation="../Types/TeamEnum.xsd"/>
+	<xs:element name="CapturePointHUD">
+		<xs:annotation>
+			<xs:documentation>Hud element for tracking capture points.</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="CapturePointNumber" type="t:int" minOccurs="0">
+					<xs:annotation>
+						<xs:documentation>Corresponds to the number on the capture point it should track.</xs:documentation>
+					</xs:annotation>
+				</xs:element>
+				<xs:element name="Owner" type="TeamEnum" minOccurs="0">
+					<xs:annotation>
+						<xs:documentation>Specify the team that own this capturePoint.</xs:documentation>
+					</xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/Player.xml

@@ -2,4 +2,5 @@
 <Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Player.xsd">
 	<MovementSpeed>3</MovementSpeed>
 	<CrouchSpeed>1.5</CrouchSpeed>
+	<CurrentWishDirection X="0" Y="0" Z="0"/>
 </Player>

resources/Schema/Components/Player.xsd

@@ -5,12 +5,13 @@
 
 	<xs:element name="Player">
 		<xs:annotation>
-			<xs:documentation>The player charachter</xs:documentation>
+			<xs:documentation>The player entity</xs:documentation>
 		</xs:annotation>
 		<xs:complexType>
 			<xs:all>
 				<xs:element name="MovementSpeed" type="t:float" minOccurs="0"/>
 				<xs:element name="CrouchSpeed" type="t:float" minOccurs="0"/>
+				<xs:element name="CurrentWishDirection" type="t:Vector" minOccurs="0"/>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Components/Sprite.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Sprite xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Sprite.xsd">
+	<DiffuseTexture></DiffuseTexture>
+	<GlowMap></GlowMap>
+	<Color R="1" G="1" B="1" A="1"/>
+	<Visible>true</Visible>
+	<DepthSort>true</DepthSort>
+</Sprite>

resources/Schema/Components/Sprite.xsd

@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="Sprite">
+		<xs:annotation>
+			<xs:documentation>A sprite that will be facing the camera</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="DiffuseTexture" type="t:string" minOccurs="0">
+					<xs:annotation><xs:documentation>Diffuse Texture file</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="GlowMap" type="t:string" minOccurs="0">
+					<xs:annotation><xs:documentation>GlowMap file</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Color" type="t:Color" minOccurs="0">
+					<xs:annotation><xs:documentation>Color tint</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Visible" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Whether the model is visible or not</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="DepthSort" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Whether the sprite should be sorted with depth or not. Only use false for textures that are on HUD</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/AmmoPickup.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:AABB/>
+    <c:AmmoPickup/>
+    <c:Model>
+      <Resource>Models/Core/UnitSphere.mesh</Resource>
+    </c:Model>
+    <c:Transform>
+      <Position X="0" Y="1" Z="0"/>
+    </c:Transform>
+    <c:Trigger/>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/AmmoPickupTest.xml

@@ -0,0 +1,294 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity name="Scenemesh">
+      <Components>
+        <c:Model>
+          <Resource>Models/LevelBase/MapVersion1.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="DirectionalLight">
+      <Components>
+        <c:DirectionalLight>
+          <Intensity>2</Intensity>
+        </c:DirectionalLight>
+        <c:Model>
+          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="61.9050903" Z="0"/>
+          <Scale X="50" Y="50" Z="50"/>
+          <Orientation X="4.42700005" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="0.370978802" Y="1.88588905" Z="-0.55370003"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="38.0347443" Y="1.88588905" Z="62.7340622"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.904668212" Y="0" Z="8.48177528"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-4.61666441" Y="0" Z="-8.51156044"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-7.56803513" Y="-0.0658408776" Z="0.59418112"/>
+          <Scale X="1.20000005" Y="0.900000036" Z="1.30000007"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="10.460474" Y="0" Z="-3.92580295"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1.09146011" Y="-0.315138876" Z="-0.333906144"/>
+          <Scale X="150" Y="1" Z="180"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="BluSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="57.7363472" Y="1.18853188" Z="79.5"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform>
+              <Position X="-2.05988312" Y="0" Z="2.79573512"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="1.85022807" Y="0" Z="-2.08909845"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.98651481" Y="0" Z="-4.67667246"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="-5.16323137" Y="0" Z="3.62892342"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="RedSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="-60.2567062" Y="1.60000002" Z="-78.1000061"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="0" Y="0" Z="2.24403"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.20245028" Y="0" Z="-1.97843659"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="4.79769945" Y="0" Z="-5.2088728"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:AmmoPickup>
+          <RespawnTimer>1</RespawnTimer>
+          <AmmoGain>22</AmmoGain>
+        </c:AmmoPickup>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="60" Y="1" Z="75"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:AmmoPickup>
+          <RespawnTimer>1</RespawnTimer>
+          <AmmoGain>22</AmmoGain>
+        </c:AmmoPickup>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="60" Y="1" Z="77"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:AmmoPickup>
+          <RespawnTimer>4</RespawnTimer>
+          <AmmoGain>44</AmmoGain>
+        </c:AmmoPickup>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="60" Y="1" Z="79"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/AnimationTests2.xml

@@ -26,29 +26,25 @@
           </Components>
           <Children/>
         </Entity>
-        <Entity name="Wave">
+        <Entity name="Running">
           <Components>
             <c:Animation>
               <AnimationName1>Run</AnimationName1>
               <Weight1>0.5</Weight1>
-              <Time1>0.78014858943309839</Time1>
-              <Speed1>1</Speed1>
+              <Time1>0.60188997954429357</Time1>
+              <Speed1>-1</Speed1>
               <Speed2>1</Speed2>
-              <AnimationName2>StrafeRight</AnimationName2>
               <Weight2>0.5</Weight2>
-              <Time2>0.78620929522779459</Time2>
-              <AnimationName3>ShootFastRifle</AnimationName3>
-              <Time3>0.13809128482706701</Time3>
+              <Time2>0.96957233017255007</Time2>
+              <Time3>0.093923612201312068</Time3>
               <Speed3>1</Speed3>
             </c:Animation>
             <c:AnimationOffset>
               <AnimationName>AimRifle</AnimationName>
-              <Time>0.040000014007091522</Time>
+              <Time>0.5</Time>
             </c:AnimationOffset>
             <c:Model>
               <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
-              <Color A="0.627451003" B="19.6078434" G="1" R="3.92156863"/>
-              <Transparent>true</Transparent>
             </c:Model>
             <c:Transform>
               <Position X="-0.690088332" Y="0" Z="0"/>
@@ -62,13 +58,11 @@
                   <ScaleOffset X="0.200000003" Y="0.200000003" Z="0.200000003"/>
                 </c:BoneAttachment>
                 <c:Model>
-                  <Resource>Models/Weapons/Blue/AssaultWeapon.mesh</Resource>
-                  <Color A="1" B="1" G="1" R="19.6078434"/>
-                  <Transparent>true</Transparent>
+                  <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
                 </c:Model>
                 <c:Transform>
-                  <Position X="0.144055843" Y="0.970111489" Z="-0.126199633"/>
-                  <Orientation X="-0.535831392" Y="0.0691146553" Z="-0.0608282126"/>
+                  <Position X="0.161975682" Y="1.06281972" Z="-0.216630161"/>
+                  <Orientation X="-0.064812161" Y="-0.0739696771" Z="0.143780142"/>
                 </c:Transform>
               </Components>
               <Children/>
@@ -78,13 +72,27 @@
         <Entity>
           <Components>
             <c:PointLight>
+              <Color A="1" B="0.70588237" G="0.70588237" R="1"/>
               <Radius>10</Radius>
             </c:PointLight>
             <c:Transform>
-              <Position X="0" Y="1.0823108" Z="0.738871336"/>
+              <Position X="-0.375567257" Y="2.13093901" Z="-0.718547285"/>
             </c:Transform>
           </Components>
-          <Children/>
+          <Children>
+            <Entity>
+              <Components>
+                <c:PointLight>
+                  <Color A="1" B="1" G="0.70588237" R="0.70588237"/>
+                  <Radius>10</Radius>
+                </c:PointLight>
+                <c:Transform>
+                  <Position X="-1.96873236" Y="0" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
         </Entity>
         <Entity>
           <Components>
@@ -97,6 +105,43 @@
           </Components>
           <Children/>
         </Entity>
+        <Entity>
+          <Components>
+            <c:Animation>
+              <AnimationName1>ShootFastRifle</AnimationName1>
+              <Time1>0.056234247235838808</Time1>
+              <Speed1>1</Speed1>
+              <Speed2>1</Speed2>
+              <AnimationName2>Idl</AnimationName2>
+              <Weight2>0.5</Weight2>
+              <Time2>1.8308673495784191</Time2>
+              <AnimationName3>StrafeRigh</AnimationName3>
+              <Weight3>0.5</Weight3>
+              <Time3>0.32167823998061529</Time3>
+              <Speed3>1</Speed3>
+            </c:Animation>
+            <c:Model>
+              <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children>
+            <Entity>
+              <Components>
+                <c:BoneAttachment>
+                  <BoneName>R_Arm_Weapon_Joint</BoneName>
+                </c:BoneAttachment>
+                <c:Model>
+                  <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
+                </c:Model>
+                <c:Transform>
+                  <Position X="0" Y="0.803468645" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
       </Children>
     </Entity>
   </Children>

resources/Schema/Entities/AnimationTests3.xml

@@ -26,57 +26,48 @@
           </Components>
           <Children/>
         </Entity>
-        <Entity name="Wave">
+        <Entity name="Running">
           <Components>
             <c:Animation>
               <AnimationName1>Run</AnimationName1>
               <Weight1>0.5</Weight1>
-              <Time1>0.97312056690160276</Time1>
-              <Speed1>1</Speed1>
+              <Time1>0.14873348341666759</Time1>
+              <Speed1>-1</Speed1>
               <Speed2>1</Speed2>
-              <AnimationName2>ReloadSwitch</AnimationName2>
-              <Time2>0.91310356788604263</Time2>
-              <AnimationName3>LeftRight</AnimationName3>
-              <Weight3>0</Weight3>
-              <Time3>0.040207288496060478</Time3>
+              <AnimationName2></AnimationName2>
+              <Weight2>0.5</Weight2>
+              <Time2>0.96957233017255007</Time2>
+              <AnimationName3></AnimationName3>
+              <Time3>0.093923612201312068</Time3>
               <Speed3>1</Speed3>
             </c:Animation>
             <c:AnimationOffset>
-              <AnimationName>DownUp</AnimationName>
-              <Time>0.77999961376190186</Time>
+              <AnimationName>AimRifle</AnimationName>
             </c:AnimationOffset>
             <c:Model>
-              <Resource>Models/Characters/Assault/FirstPerson.mesh</Resource>
-              <Color A="0.627451003" B="19.6078434" G="1" R="3.92156863"/>
-              <Transparent>true</Transparent>
+              <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
             </c:Model>
             <c:Transform>
-              <Position X="-0.690088332" Y="1.00491476" Z="0"/>
+              <Position X="-0.690088332" Y="0" Z="0"/>
             </c:Transform>
           </Components>
           <Children>
-            <Entity>
+            <Entity name="R_Arm_Weapon_Joint">
               <Components>
                 <c:BoneAttachment>
                   <BoneName>R_Arm_Weapon_Joint</BoneName>
+                  <ScaleOffset X="0.200000003" Y="0.200000003" Z="0.200000003"/>
                 </c:BoneAttachment>
                 <c:Model>
-                  <Resource>Models/Weapons/Blue/AssaultWeapon.mesh</Resource>
+                  <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
                 </c:Model>
                 <c:Transform>
-                  <Position X="0.120548911" Y="-0.223148599" Z="-0.151705116"/>
-                  <Orientation X="0.09407565" Y="0.0181003436" Z="0.0279055703"/>
+                  <Position X="0.106085993" Y="1.24281573" Z="-0.198514819"/>
+                  <Orientation X="0.466044426" Y="0.284358948" Z="-0.0190349482"/>
                 </c:Transform>
               </Components>
               <Children/>
             </Entity>
-            <Entity>
-              <Components>
-                <c:Camera/>
-                <c:Transform/>
-              </Components>
-              <Children/>
-            </Entity>
           </Children>
         </Entity>
         <Entity>
@@ -101,6 +92,40 @@
           </Components>
           <Children/>
         </Entity>
+        <Entity>
+          <Components>
+            <c:Animation>
+              <AnimationName1>ShootFastRifle</AnimationName1>
+              <Time1>0.11093210511546658</Time1>
+              <Speed1>1</Speed1>
+            </c:Animation>
+            <c:AnimationOffset>
+              <AnimationName>AimRifle</AnimationName>
+              <Time>1</Time>
+            </c:AnimationOffset>
+            <c:Model>
+              <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children>
+            <Entity>
+              <Components>
+                <c:BoneAttachment>
+                  <BoneName>R_Arm_Weapon_Joint</BoneName>
+                </c:BoneAttachment>
+                <c:Model>
+                  <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
+                </c:Model>
+                <c:Transform>
+                  <Position X="0.106085993" Y="1.24281573" Z="-0.198514819"/>
+                  <Orientation X="0.466044426" Y="0.284358948" Z="-0.0190349482"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
       </Children>
     </Entity>
   </Children>

resources/Schema/Entities/CapturePointHUDGroup

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="HudOrigin" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="-24.3529072" Y="0" Z="6.95243597"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="BackgroundHexagon">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+          <Color A="0.300000012" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0" Y="0.919596612" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="ProgressionHexagon">
+          <Components>
+            <c:CapturePointHUD>
+              <CapturePointNumber>2</CapturePointNumber>
+            </c:CapturePointHUD>
+            <c:Fill>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Fill>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.00999999978"/>
+              <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="BackgroundHexagon">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+          <Color A="0.300000012" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0.811270177" Y="0.440691769" Z="-0.100000001"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="ProgressionHexagon">
+          <Components>
+            <c:CapturePointHUD>
+              <CapturePointNumber>3</CapturePointNumber>
+            </c:CapturePointHUD>
+            <c:Fill>
+              <Percentage>0.80222018197612788</Percentage>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Fill>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.00999999978"/>
+              <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="BackgroundHexagon">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+          <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="1.62788737" Y="0.919596612" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="ProgressionHexagon">
+          <Components>
+            <c:CapturePointHUD>
+              <CapturePointNumber>4</CapturePointNumber>
+            </c:CapturePointHUD>
+            <c:Fill>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Fill>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.00999999978"/>
+              <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="BackgroundHexagon">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+          <Color A="0.300000012" B="1" G="1" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="-0.820431828" Y="0.441878349" Z="-0.100000001"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="ProgressionHexagon">
+          <Components>
+            <c:CapturePointHUD>
+              <CapturePointNumber>1</CapturePointNumber>
+            </c:CapturePointHUD>
+            <c:Fill>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Fill>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.00999999978"/>
+              <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="BackgroundHexagon">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+          <Color A="0.699999988" B="0" G="0.200000003" R="1"/>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="-1.58304751" Y="0.919596612" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="ProgressionHexagon">
+          <Components>
+            <c:CapturePointHUD/>
+            <c:Fill>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Fill>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0" Z="0.00999999978"/>
+              <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+              <Orientation X="0" Y="0" Z="1.57079637"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CapturePointHUDHexagon.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="BackgroundHexagon" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Sprite>
+      <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+      <Color A="0.666666687" B="1" G="1" R="1"/>
+    </c:Sprite>
+    <c:Transform>
+      <Position X="0" Y="0.919596612" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="ProgressionHexagon">
+      <Components>
+        <c:CapturePointHUD/>
+        <c:Fill>
+          <Percentage>0.5</Percentage>
+        </c:Fill>
+        <c:Sprite>
+          <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0" Y="0" Z="0.00999999978"/>
+          <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+          <Orientation X="0" Y="0" Z="1.5710001"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CaptureTestState5.xml

@@ -2,12 +2,246 @@
 <Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:Transform>
-      <Position X="0.340887427" Y="0" Z="0"/>
-    </c:Transform>
+    <c:Transform/>
   </Components>
 
   <Children>
+    <Entity name="Scenemesh">
+      <Components>
+        <c:AABB>
+          <Origin X="0.195705414" Y="26.0382366" Z="-0.010017395"/>
+          <Size X="135.414337" Y="68.3848572" Z="180.020035"/>
+        </c:AABB>
+        <c:Model>
+          <Resource>Models/LevelBase/MapVersion1.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="DirectionalLight">
+      <Components>
+        <c:DirectionalLight>
+          <Intensity>2</Intensity>
+        </c:DirectionalLight>
+        <c:Model>
+          <Resource>Models/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="61.9050903" Z="0"/>
+          <Scale X="50" Y="50" Z="50"/>
+          <Orientation X="4.42700005" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="0.370978802" Y="1.88588905" Z="-0.55370003"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="38.0347443" Y="1.88588905" Z="62.7340622"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.904668212" Y="0" Z="8.48177528"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-4.61666441" Y="0" Z="-8.51156044"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-7.56803513" Y="-0.0658408776" Z="0.59418112"/>
+          <Scale X="1.20000005" Y="0.900000036" Z="1.30000007"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="10.460474" Y="0" Z="-3.92580295"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1.09146011" Y="-0.315138876" Z="-0.333906144"/>
+          <Scale X="150" Y="1" Z="180"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="BluSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="57.7363472" Y="2.38900018" Z="79.5"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform>
+              <Position X="-2.05988312" Y="0" Z="2.79573512"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="1.85022807" Y="0" Z="-2.08909845"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.98651481" Y="0" Z="-4.67667246"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="-5.16323137" Y="0" Z="3.62892342"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="RedSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="-60.2567062" Y="3.4000001" Z="-78.1000061"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="0" Y="0" Z="2.24403"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.20245028" Y="0" Z="-1.97843659"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="4.79769945" Y="0" Z="-5.2088728"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
     <Entity>
       <Components>
         <c:AABB/>
@@ -15,10 +249,12 @@
           <HomePointForTeam>
             <Red/>
           </HomePointForTeam>
+          <CaptureTimer>15</CaptureTimer>
         </c:CapturePoint>
         <c:Model>
           <Resource>Models/Core/UnitSphere.mesh</Resource>
-          <Color A="1" B="0" G="0.200000003" R="1"/>
+          <Color A="0.300000012" B="0" G="0" R="1"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team>
           <Team>
@@ -26,7 +262,7 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="6.60000038" Y="0" Z="0"/>
+          <Position X="56.0000038" Y="1.50000012" Z="77.1000061"/>
         </c:Transform>
         <c:Trigger/>
       </Components>
@@ -40,11 +276,12 @@
         </c:CapturePoint>
         <c:Model>
           <Resource>Models/Core/UnitSphere.mesh</Resource>
-          <Color A="1" B="1" G="1" R="0"/>
+          <Color A="0.300000012" B="1" G="1" R="1"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team/>
         <c:Transform>
-          <Position X="4.46673203" Y="0" Z="3.50259304"/>
+          <Position X="56.0000038" Y="1.70000005" Z="78.5"/>
         </c:Transform>
         <c:Trigger/>
       </Components>
@@ -58,15 +295,12 @@
         </c:CapturePoint>
         <c:Model>
           <Resource>Models/Core/UnitSphere.mesh</Resource>
-          <Color A="1" B="1" G="0.200000003" R="0"/>
+          <Color A="0.300000012" B="1" G="1" R="1"/>
+          <Transparent>true</Transparent>
         </c:Model>
-        <c:Team>
-          <Team>
-            <Blue/>
-          </Team>
-        </c:Team>
+        <c:Team/>
         <c:Transform>
-          <Position X="3.00000024" Y="0" Z="0.113596022"/>
+          <Position X="56.0000038" Y="1.10000002" Z="79.6000061"/>
         </c:Transform>
         <c:Trigger/>
       </Components>
@@ -76,11 +310,13 @@
       <Components>
         <c:AABB/>
         <c:CapturePoint>
+          <CaptureTimer>-15</CaptureTimer>
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
           <Resource>Models/Core/UnitSphere.mesh</Resource>
-          <Color A="1" B="1" G="0.200000003" R="0"/>
+          <Color A="0.300000012" B="1" G="0" R="0"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team>
           <Team>
@@ -88,7 +324,7 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="1.75382805" Y="0" Z="0.0895374417"/>
+          <Position X="56.0000038" Y="1.60000002" Z="80.6000061"/>
         </c:Transform>
         <c:Trigger/>
       </Components>
@@ -101,11 +337,13 @@
           <HomePointForTeam>
             <Blue/>
           </HomePointForTeam>
+          <CaptureTimer>-15</CaptureTimer>
           <CapturePointNumber>4</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
           <Resource>Models/Core/UnitSphere.mesh</Resource>
-          <Color A="1" B="1" G="0.200000003" R="0"/>
+          <Color A="0.300000012" B="1" G="0" R="0"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team>
           <Team>
@@ -113,61 +351,12 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="0.56674248" Y="0" Z="0"/>
+          <Position X="56.0000038" Y="1.4000001" Z="82.1000061"/>
         </c:Transform>
         <c:Trigger/>
       </Components>
       <Children/>
     </Entity>
-    <Entity>
-      <Components>
-        <c:AABB/>
-        <c:Health/>
-        <c:Model>
-          <Resource>Models/Core/UnitCube.mesh</Resource>
-        </c:Model>
-        <c:Player/>
-        <c:Team>
-          <Team>
-            <Blue/>
-          </Team>
-        </c:Team>
-        <c:Transform>
-          <Position X="4.29100037" Y="-0.08556436" Z="1.29717529"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-    <Entity>
-      <Components>
-        <c:AABB/>
-        <c:Health/>
-        <c:Model>
-          <Resource>Models/Core/UnitCube.mesh</Resource>
-        </c:Model>
-        <c:Player/>
-        <c:Team>
-          <Team>
-            <Red/>
-          </Team>
-        </c:Team>
-        <c:Transform>
-          <Position X="5.43557501" Y="0.888866663" Z="1.55849135"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-    <Entity>
-      <Components>
-        <c:Model>
-          <Resource>Models/Test/DummyScene.mesh</Resource>
-        </c:Model>
-        <c:Transform>
-          <Position X="-0.600000024" Y="0" Z="0"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/DamageIndicator.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Sprite>
+      <DiffuseTexture>Textures/DamageIndicator.png</DiffuseTexture>
+      <GlowMap></GlowMap>
+      <DepthSort>false</DepthSort>
+      <Color A="1" B="0.721568644" G="1" R="0.839215696"/>
+    </c:Sprite>
+    <c:Transform>
+      <Position X="0" Y="0" Z="-0.472000033"/>
+      <Scale X="0.100000001" Y="0.200000003" Z="0.5"/>
+    </c:Transform>
+    <c:Lifetime>
+      <Lifetime>1.5</Lifetime>
+    </c:Lifetime>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/DamageIndicatorTest.xml

@@ -0,0 +1,426 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity name="Scenemesh">
+      <Components>
+        <c:AABB>
+          <Size X="150" Y="64" Z="180"/>
+        </c:AABB>
+        <c:Model>
+          <Resource>Models\MapVersion1.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="DirectionalLight">
+      <Components>
+        <c:DirectionalLight>
+          <Intensity>2</Intensity>
+        </c:DirectionalLight>
+        <c:Model>
+          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="61.9050903" Z="0"/>
+          <Scale X="50" Y="50" Z="50"/>
+          <Orientation X="4.42700005" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="0.370978802" Y="1.88588905" Z="-0.55370003"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PointLight">
+      <Components>
+        <c:PointLight>
+          <Radius>8</Radius>
+          <Intensity>2.7999999523162842</Intensity>
+        </c:PointLight>
+        <c:Transform>
+          <Position X="38.0347443" Y="1.88588905" Z="62.7340622"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.904668212" Y="0" Z="8.48177528"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-4.61666441" Y="0" Z="-8.51156044"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-7.56803513" Y="-0.0658408776" Z="0.59418112"/>
+          <Scale X="1.20000005" Y="0.900000036" Z="1.30000007"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="10.460474" Y="0" Z="-3.92580295"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1.09146011" Y="-0.315138876" Z="-0.333906144"/>
+          <Scale X="150" Y="1" Z="180"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="BluSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="57.7363472" Y="2.38900018" Z="79.5"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform>
+              <Position X="-2.05988312" Y="0" Z="2.79573512"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="1.85022807" Y="0" Z="-2.08909845"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.98651481" Y="0" Z="-4.67667246"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="-5.16323137" Y="0" Z="3.62892342"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="RedSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="-60.2567062" Y="3.4000001" Z="-78.1000061"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="0" Y="0" Z="2.24403"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="2.20245028" Y="0" Z="-1.97843659"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:Transform>
+              <Position X="4.79769945" Y="0" Z="-5.2088728"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="Player">
+      <Components>
+        <c:AABB>
+          <Origin X="0" Y="0.772000015" Z="0"/>
+          <Size X="1" Y="1.60000002" Z="1"/>
+        </c:AABB>
+        <c:Collidable/>
+        <c:DashAbility/>
+        <c:Health>
+          <Health>99</Health>
+        </c:Health>
+        <c:Physics>
+          <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
+        </c:Physics>
+        <c:Player>
+          <MovementSpeed>5</MovementSpeed>
+        </c:Player>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="57" Y="0.212861136" Z="77"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Camera">
+          <Components>
+            <c:Camera/>
+            <c:Transform>
+              <Position X="0" Y="1.37700009" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="PlayerName">
+              <Components>
+                <c:Text>
+                  <Resource>Fonts/DroidSans.ttf,100</Resource>
+                  <Color A="1" B="0" G="1" R="0"/>
+                </c:Text>
+                <c:Transform>
+                  <Position X="0.100000001" Y="0.248000011" Z="-0.248000011"/>
+                  <Scale X="0.100000001" Y="0.113000005" Z="0.5"/>
+                  <Orientation X="0" Y="3.14199996" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="CameraModel">
+              <Components>
+                <c:Model>
+                  <Resource>Models/Camera.mesh</Resource>
+                  <Visible>false</Visible>
+                </c:Model>
+                <c:Transform>
+                  <Position X="0" Y="0.0331346765" Z="-0.0792061687"/>
+                  <Scale X="1.30000007" Y="1.50000012" Z="1"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="HUD">
+              <Components>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="-0.5"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="HealthBar">
+                  <Components>
+                    <c:Fill>
+                      <Percentage>0.99000000953674316</Percentage>
+                      <Color A="0" B="0.99000001" G="0" R="0.00999999046"/>
+                    </c:Fill>
+                    <c:HealthHUD/>
+                    <c:Model>
+                      <Resource>Models/Core/UnitHexagon.mesh</Resource>
+                      <Color A="1" B="0.70588237" G="0.70588237" R="0.70588237"/>
+                    </c:Model>
+                    <c:Transform>
+                      <Position X="-0.383000016" Y="-0.185000002" Z="0"/>
+                      <Scale X="0.150000006" Y="0.150000006" Z="0.150000006"/>
+                      <Orientation X="0" Y="0.594000041" Z="0"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+                <Entity name="Crosshair">
+                  <Components>
+                    <c:Model>
+                      <Resource>Models/CrosshairQuad.mesh</Resource>
+                    </c:Model>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.200000003"/>
+                      <Scale X="0.00600000005" Y="1" Z="0.00600000005"/>
+                      <Orientation X="1.57000005" Y="0" Z="0"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+                <Entity name="Weapon">
+                  <Components>
+                    <c:Model>
+                      <Resource>Models/AssaultWeaponRed.mesh</Resource>
+                    </c:Model>
+                    <c:Transform>
+                      <Position X="0.180000007" Y="-0.183000013" Z="0"/>
+                      <Orientation X="0" Y="3.08300018" Z="0"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+                <Entity name="WeaponMuzzle">
+                  <Components>
+                    <c:Transform>
+                      <Position X="0.215000004" Y="-0.153000012" Z="-0.266000003"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+          </Children>
+        </Entity>
+        <Entity name="ThirdPersonCamera">
+          <Components>
+            <c:Camera/>
+            <c:Model>
+              <Resource>Models/Camera.mesh</Resource>
+              <Visible>false</Visible>
+            </c:Model>
+            <c:Transform>
+              <Position X="-0.284000009" Y="1.83800006" Z="1.18900001"/>
+              <Orientation X="5.95600033" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="PlayerModel">
+          <Components>
+            <c:Animation/>
+            <c:HiddenForLocalPlayer/>
+            <c:Model>
+              <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
+              <Color A="1" B="0" G="0" R="1"/>
+            </c:Model>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="AABBStanding">
+          <Components>
+            <c:Model>
+              <Resource>Models/Core/UnitCube.mesh</Resource>
+              <Color A="0.427450985" B="1" G="1" R="1"/>
+              <Visible>false</Visible>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.772000015" Z="0"/>
+              <Scale X="1" Y="1.60000002" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="AABBCrouching">
+          <Components>
+            <c:Model>
+              <Resource>Models/Core/UnitCube.mesh</Resource>
+              <Color A="0.745098054" B="1" G="0" R="1"/>
+              <Visible>false</Visible>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.772000015" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/HitMarker.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="HitMarker" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Lifetime>
+      <Lifetime>0.1</Lifetime>
+    </c:Lifetime>
+    <c:Sprite>
+      <DiffuseTexture>Textures/Weapons/Crosshair/SmallThickHoleDot.png</DiffuseTexture>
+      <DepthSort>false</DepthSort>
+    </c:Sprite>
+    <c:Transform>
+      <Scale X="0.031" Y="0.031" Z="1"/>
+      <Orientation X="0" Y="0" Z="0.782"/>
+    </c:Transform>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/MovementTest.xml

@@ -124,10 +124,14 @@
           <Origin X="0" Y="0.772000015" Z="0"/>
           <Size X="1" Y="1.60000002" Z="1"/>
         </c:AABB>
+        <c:AssaultWeapon>
+          <RPM>600</RPM>
+        </c:AssaultWeapon>
         <c:Collidable/>
-        <c:Model/>
+        <c:DashAbility/>
+        <c:Health/>
         <c:Physics>
-          <Gravity>false</Gravity>
+          <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
         </c:Physics>
         <c:Player>
           <MovementSpeed>5</MovementSpeed>
@@ -138,8 +142,7 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="-1.68112314" Y="0.0288829971" Z="3.06287026"/>
-          <Orientation X="0" Y="2.14675093" Z="0"/>
+          <Position X="0" Y="0.0288832653" Z="2.64837074"/>
         </c:Transform>
       </Components>
       <Children>
@@ -147,7 +150,7 @@
           <Components>
             <c:Camera/>
             <c:Transform>
-              <Position X="0" Y="1.37700009" Z="0"/>
+              <Position X="0" Y="1.27700007" Z="0"/>
             </c:Transform>
           </Components>
           <Children>
@@ -156,10 +159,9 @@
                 <c:Text>
                   <Resource>Fonts/DroidSans.ttf,100</Resource>
                   <Color A="1" B="0" G="1" R="0"/>
-                  <Visible>false</Visible>
                 </c:Text>
                 <c:Transform>
-                  <Position X="0" Y="0.247910097" Z="-0.447844714"/>
+                  <Position X="0.100000001" Y="0.248000011" Z="-0.248000011"/>
                   <Scale X="0.100000001" Y="0.113000005" Z="0.5"/>
                   <Orientation X="0" Y="3.14199996" Z="0"/>
                 </c:Transform>
@@ -170,6 +172,7 @@
               <Components>
                 <c:Model>
                   <Resource>Models/Widgets/Camera.mesh</Resource>
+                  <Visible>false</Visible>
                 </c:Model>
                 <c:Transform>
                   <Position X="0" Y="0.0331346765" Z="-0.0792061687"/>
@@ -178,6 +181,100 @@
               </Components>
               <Children/>
             </Entity>
+            <Entity name="HUD">
+              <Components>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="-0.5"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="HealthBar">
+                  <Components>
+                    <c:Fill>
+                      <Percentage>1</Percentage>
+                      <Color A="0" B="1" G="0" R="0"/>
+                    </c:Fill>
+                    <c:HealthHUD/>
+                    <c:Model>
+                      <Resource>Models/Core/UnitHexagon.mesh</Resource>
+                      <Color A="1" B="0.70588237" G="0.70588237" R="0.70588237"/>
+                    </c:Model>
+                    <c:Transform>
+                      <Position X="-0.383000016" Y="-0.185000002" Z="0"/>
+                      <Scale X="0.150000006" Y="0.150000006" Z="0.150000006"/>
+                      <Orientation X="0" Y="0.594000041" Z="0"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+                <Entity name="Crosshair">
+                  <Components>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Weapons/Crosshair/SmallThickHoleDot.png</DiffuseTexture>
+                      <DepthSort>false</DepthSort>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.200000003"/>
+                      <Scale X="0.0250000004" Y="0.0250000004" Z="0"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="Hands">
+              <Components>
+                <c:Animation>
+                  <AnimationName1>Idle</AnimationName1>
+                  <Time1>1.9569972344146196</Time1>
+                  <Speed1>1</Speed1>
+                </c:Animation>
+                <c:Model>
+                  <Resource>Models/Characters/Assault/FirstPerson.mesh</Resource>
+                  <Transparent>true</Transparent>
+                </c:Model>
+                <c:Transform/>
+              </Components>
+              <Children>
+                <Entity name="WeaponModel">
+                  <Components>
+                    <c:BoneAttachment>
+                      <BoneName>R_Arm_Weapon_Joint</BoneName>
+                    </c:BoneAttachment>
+                    <c:Model>
+                      <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+                      <Transparent>true</Transparent>
+                    </c:Model>
+                    <c:Transform>
+                      <Position X="0.120748013" Y="-0.228470564" Z="-0.151475638"/>
+                      <Orientation X="0.010404693" Y="-0.00268176314" Z="0.0428441502"/>
+                    </c:Transform>
+                  </Components>
+                  <Children>
+                    <Entity name="WeaponMuzzle">
+                      <Components>
+                        <c:Spawner>
+                          <EntityFile>Schema/Entities/RayBlue.xml</EntityFile>
+                        </c:Spawner>
+                        <c:Transform>
+                          <Position X="0.00325386273" Y="0.0970000029" Z="-0.843000054"/>
+                        </c:Transform>
+                      </Components>
+                      <Children/>
+                    </Entity>
+                  </Children>
+                </Entity>
+                <Entity name="FirstPersonReloadSpawner">
+                  <Components>
+                    <c:Spawner>
+                      <EntityFile>Schema/Entities/WeaponReloadEffect.xml</EntityFile>
+                    </c:Spawner>
+                    <c:Transform/>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
           </Children>
         </Entity>
         <Entity name="ThirdPersonCamera">
@@ -196,15 +293,52 @@
         </Entity>
         <Entity name="PlayerModel">
           <Components>
+            <c:Animation>
+              <AnimationName1>Idle</AnimationName1>
+              <Time1>1.8055945618467364</Time1>
+              <Speed1>1</Speed1>
+            </c:Animation>
+            <c:AnimationOffset>
+              <AnimationName>AimRifle</AnimationName>
+              <Time>0.5</Time>
+            </c:AnimationOffset>
+            <c:HiddenForLocalPlayer/>
             <c:Model>
-              <Resource>Models/Characters/Assault/AssaultHeadless.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultAnimations.mesh</Resource>
               <Color A="1" B="0" G="0" R="1"/>
             </c:Model>
-            <c:Transform>
-              <Orientation X="0" Y="3.14159274" Z="0"/>
-            </c:Transform>
+            <c:Transform/>
           </Components>
-          <Children/>
+          <Children>
+            <Entity name="ThirdPersonWeaponModel">
+              <Components>
+                <c:BoneAttachment>
+                  <BoneName>R_Arm_Weapon_Joint</BoneName>
+                </c:BoneAttachment>
+                <c:Model>
+                  <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+                  <Visible>false</Visible>
+                </c:Model>
+                <c:Transform>
+                  <Position X="0.158578917" Y="1.02878916" Z="-0.215411991"/>
+                  <Orientation X="-0.0626687407" Y="-0.0361274257" Z="0.120101407"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ThirdPersonWeaponMuzzle">
+                  <Components>
+                    <c:Spawner>
+                      <EntityFile>Schema/Entities/RayBlue.xml</EntityFile>
+                    </c:Spawner>
+                    <c:Transform>
+                      <Position X="0.00644115033" Y="0.096679531" Z="-0.436609417"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+          </Children>
         </Entity>
         <Entity name="AABBStanding">
           <Components>

resources/Schema/Entities/Player.xml

@@ -23,7 +23,9 @@
         <Blue/>
       </Team>
     </c:Team>
-    <c:Transform/>
+    <c:Transform>
+      <Position X="0" Y="0.0288832653" Z="2.64837074"/>
+    </c:Transform>
   </Components>
 
   <Children>
@@ -90,24 +92,33 @@
             </Entity>
             <Entity name="Crosshair">
               <Components>
-                <c:Model>
-                  <Resource>Models/Weapons/CrosshairQuad.mesh</Resource>
-                </c:Model>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Weapons/Crosshair/SmallThickHoleDot.png</DiffuseTexture>
+                  <DepthSort>false</DepthSort>
+                </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.200000003"/>
-                  <Scale X="0.00600000005" Y="1" Z="0.00600000005"/>
-                  <Orientation X="1.57000005" Y="0" Z="0"/>
+                  <Scale X="0.0250000004" Y="0.0250000004" Z="0"/>
                 </c:Transform>
               </Components>
               <Children/>
             </Entity>
+            <Entity name="HitMarkerSpawner">
+              <Components>
+                <c:Spawner>
+                  <EntityFile>Schema/Entities/HitMarker.xml</EntityFile>
+                </c:Spawner>
+                <c:Transform/>
+              </Components>
+              <Children/>
+            </Entity>
           </Children>
         </Entity>
         <Entity name="Hands">
           <Components>
             <c:Animation>
               <AnimationName1>Idle</AnimationName1>
-              <Time1>0.52743271827223559</Time1>
+              <Time1>0.1719161089749548</Time1>
               <Speed1>1</Speed1>
             </c:Animation>
             <c:Model>
@@ -124,10 +135,11 @@
                 </c:BoneAttachment>
                 <c:Model>
                   <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+                  <Transparent>true</Transparent>
                 </c:Model>
                 <c:Transform>
-                  <Position X="0.120747946" Y="-0.232330009" Z="-0.151475713"/>
-                  <Orientation X="0.0104046576" Y="-0.00268170447" Z="0.0428439789"/>
+                  <Position X="0.120747983" Y="-0.228997007" Z="-0.151475653"/>
+                  <Orientation X="0.0104046585" Y="-0.00268164417" Z="0.0428441912"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -144,6 +156,15 @@
                 </Entity>
               </Children>
             </Entity>
+            <Entity name="FirstPersonReloadSpawner">
+              <Components>
+                <c:Spawner>
+                  <EntityFile>Schema/Entities/WeaponReloadEffect.xml</EntityFile>
+                </c:Spawner>
+                <c:Transform/>
+              </Components>
+              <Children/>
+            </Entity>
           </Children>
         </Entity>
       </Children>
@@ -166,7 +187,7 @@
       <Components>
         <c:Animation>
           <AnimationName1>Idle</AnimationName1>
-          <Time1>0.69666320633760392</Time1>
+          <Time1>1.8038469763698401</Time1>
           <Speed1>1</Speed1>
         </c:Animation>
         <c:AnimationOffset>
@@ -188,10 +209,11 @@
             </c:BoneAttachment>
             <c:Model>
               <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+              <Visible>false</Visible>
             </c:Model>
             <c:Transform>
-              <Position X="0.162715688" Y="1.02479136" Z="-0.215626657"/>
-              <Orientation X="-0.0629899353" Y="-0.0542047173" Z="0.11849726"/>
+              <Position X="0.15859656" Y="1.02875519" Z="-0.21540691"/>
+              <Orientation X="-0.0626692101" Y="-0.0361935496" Z="0.120095037"/>
             </c:Transform>
           </Components>
           <Children>

resources/Schema/Entities/QualityAssurance.xml

@@ -40,7 +40,7 @@
               <Axis X="0" Y="1" Z="0"/>
             </c:RaptorCopter>
             <c:Transform>
-              <Orientation X="0" Y="9161.41992" Z="0"/>
+              <Orientation X="0" Y="7364.79053" Z="0"/>
             </c:Transform>
           </Components>
           <Children>
@@ -120,11 +120,7 @@
       <Children>
         <Entity name="RunAnim">
           <Components>
-            <c:Animation>
-              <Name>Run</Name>
-              <Time>0.79292191744688711</Time>
-              <Speed>1</Speed>
-            </c:Animation>
+            <c:Animation/>
             <c:Model>
               <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
@@ -136,11 +132,7 @@
         </Entity>
         <Entity name="Walkanim">
           <Components>
-            <c:Animation>
-              <Name>Walk</Name>
-              <Time>0.96020137154739604</Time>
-              <Speed>1</Speed>
-            </c:Animation>
+            <c:Animation/>
             <c:Model>
               <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
@@ -188,17 +180,13 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="2918.14136" Z="0"/>
+                  <Orientation X="0" Y="2019.28589" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
                 <Entity name="Asset">
                   <Components>
-                    <c:Animation>
-                      <Name>Run</Name>
-                      <Time>0.53173203453812956</Time>
-                      <Speed>1</Speed>
-                    </c:Animation>
+                    <c:Animation/>
                     <c:Model>
                       <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
                     </c:Model>
@@ -683,7 +671,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -730,7 +718,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -790,7 +778,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -837,7 +825,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -883,7 +871,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -930,7 +918,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -977,7 +965,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1217.61243" Z="0"/>
+                  <Orientation X="0" Y="316.505432" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1035,6 +1023,7 @@
                   <HomePointForTeam>
                     <Red/>
                   </HomePointForTeam>
+                  <CaptureTimer>15</CaptureTimer>
                 </c:CapturePoint>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
@@ -1174,7 +1163,6 @@
               <Components>
                 <c:AABB/>
                 <c:CapturePoint>
-                  <CaptureTimer>-12.033302729641917</CaptureTimer>
                   <CapturePointNumber>3</CapturePointNumber>
                 </c:CapturePoint>
                 <c:Model>
@@ -1224,6 +1212,7 @@
                   <HomePointForTeam>
                     <Blue/>
                   </HomePointForTeam>
+                  <CaptureTimer>-15</CaptureTimer>
                   <CapturePointNumber>4</CapturePointNumber>
                 </c:CapturePoint>
                 <c:Model>
@@ -1390,7 +1379,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1750.85376" Z="0"/>
+                  <Orientation X="0" Y="850.207886" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1399,7 +1388,7 @@
                     <c:ExplosionEffect>
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0.800000012" Y="0.0379999988" Z="0"/>
-                      <TimeSinceDeath>1.3671759474185377</TimeSinceDeath>
+                      <TimeSinceDeath>0.75205058136495551</TimeSinceDeath>
                       <ExplosionDuration>3.7999999523162842</ExplosionDuration>
                       <EndColor A="0" B="23.5294113" G="11.7647057" R="0"/>
                       <Randomness>true</Randomness>
@@ -1446,7 +1435,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1750.85376" Z="0"/>
+                  <Orientation X="0" Y="850.207886" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1455,7 +1444,7 @@
                     <c:ExplosionEffect>
                       <Velocity X="0.5" Y="1" Z="0"/>
                       <ExplosionOrigin X="0" Y="0.900000036" Z="0"/>
-                      <TimeSinceDeath>0.31711568080172703</TimeSinceDeath>
+                      <TimeSinceDeath>1.2019563319790627</TimeSinceDeath>
                     </c:ExplosionEffect>
                     <c:Model>
                       <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
@@ -1498,22 +1487,18 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1750.85376" Z="0"/>
+                  <Orientation X="0" Y="850.207886" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
                 <Entity name="Asset">
                   <Components>
-                    <c:Animation>
-                      <Name>Walk</Name>
-                      <Time>0.74121802989810703</Time>
-                      <Speed>1</Speed>
-                    </c:Animation>
+                    <c:Animation/>
                     <c:ExplosionEffect>
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0.300000012" Y="2" Z="0"/>
                       <ExplosionOrigin X="0" Y="1.30000007" Z="-0.200000003"/>
-                      <TimeSinceDeath>0.31711568080172703</TimeSinceDeath>
+                      <TimeSinceDeath>0.68540211563899389</TimeSinceDeath>
                       <EndColor A="0" B="0.333333343" G="0.933333337" R="3.92156863"/>
                       <Randomness>true</Randomness>
                     </c:ExplosionEffect>
@@ -1558,7 +1543,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="857.983765" Z="0"/>
+                  <Orientation X="0" Y="857.984314" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1568,7 +1553,7 @@
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0" Y="0.699999988" Z="0"/>
                       <ExplosionOrigin X="0" Y="-1.10000002" Z="0"/>
-                      <TimeSinceDeath>0.95047462600732735</TimeSinceDeath>
+                      <TimeSinceDeath>0.95150063648635763</TimeSinceDeath>
                       <ExplosionDuration>10</ExplosionDuration>
                       <EndColor A="1" B="0" G="0" R="1"/>
                       <RandomnessScalar>3</RandomnessScalar>
@@ -1616,7 +1601,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="456.13559" Z="0"/>
+                  <Orientation X="0" Y="456.136078" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1626,7 +1611,7 @@
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="6" Y="0.100000001" Z="0"/>
                       <ExplosionOrigin X="0" Y="-10" Z="0"/>
-                      <TimeSinceDeath>1.350502887383392</TimeSinceDeath>
+                      <TimeSinceDeath>1.3515288978624223</TimeSinceDeath>
                       <ExponentialAccelaration>true</ExponentialAccelaration>
                       <ExplosionDuration>5</ExplosionDuration>
                       <Randomness>true</Randomness>
@@ -1807,7 +1792,7 @@
                         <c:ExplosionEffect>
                           <ColorByDistance>true</ColorByDistance>
                           <Velocity X="0.800000012" Y="0.0379999988" Z="0"/>
-                          <TimeSinceDeath>1.3671759474185377</TimeSinceDeath>
+                          <TimeSinceDeath>1.3682019578975679</TimeSinceDeath>
                           <ExplosionDuration>3.7999999523162842</ExplosionDuration>
                           <EndColor A="0" B="23.5294113" G="11.7647057" R="0"/>
                           <Randomness>true</Randomness>
@@ -1850,11 +1835,7 @@
             </Entity>
             <Entity name="PlayerModel">
               <Components>
-                <c:Animation>
-                  <Name>Hold Pos</Name>
-                  <Time>0.39573681725672838</Time>
-                  <Speed>1</Speed>
-                </c:Animation>
+                <c:Animation/>
                 <c:HiddenForLocalPlayer/>
                 <c:Model>
                   <Resource>Models/AssaultAnimated.mesh</Resource>
@@ -1916,7 +1897,8 @@
             <Entity name="Bush">
               <Components>
                 <c:Model>
-                  <Resource>Models/BushAlive.mesh</Resource>
+                  <Resource>Models/Props/Flora/AliveBush.mesh</Resource>
+                  <Transparent>true</Transparent>
                 </c:Model>
                 <c:Transform>
                   <Position X="-4.95900011" Y="0" Z="1.29897511"/>
@@ -1943,6 +1925,226 @@
         </Entity>
       </Children>
     </Entity>
+    <Entity name="SpriteOrigin">
+      <Components>
+        <c:Transform>
+          <Position X="-24.0121765" Y="1" Z="0"/>
+          <Orientation X="0" Y="1.45400012" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Sprite1">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Props/FoliageDiff.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="Sprite2">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Props/FoliageDiff.png</DiffuseTexture>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="-0.177861199" Y="0" Z="-1.04673338"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="HudOrigin">
+      <Components>
+        <c:Transform>
+          <Position X="-24.3529072" Y="0" Z="6.95243597"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="BackgroundHexagon">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <Color A="0.300000012" B="1" G="1" R="1"/>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0" Y="0.919596612" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="ProgressionHexagon">
+              <Components>
+                <c:CapturePointHUD>
+                  <CapturePointNumber>2</CapturePointNumber>
+                </c:CapturePointHUD>
+                <c:Fill>
+                  <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                </c:Fill>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="0.00999999978"/>
+                  <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                  <Orientation X="0" Y="0" Z="1.57079637"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+        <Entity name="BackgroundHexagon">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <Color A="0.300000012" B="1" G="1" R="1"/>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="0.811270177" Y="0.440691769" Z="-0.100000001"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="ProgressionHexagon">
+              <Components>
+                <c:CapturePointHUD>
+                  <CapturePointNumber>3</CapturePointNumber>
+                </c:CapturePointHUD>
+                <c:Fill>
+                  <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                </c:Fill>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="0.00999999978"/>
+                  <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                  <Orientation X="0" Y="0" Z="1.57079637"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+        <Entity name="BackgroundHexagon">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="1.62788737" Y="0.919596612" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="ProgressionHexagon">
+              <Components>
+                <c:CapturePointHUD>
+                  <CapturePointNumber>4</CapturePointNumber>
+                </c:CapturePointHUD>
+                <c:Fill>
+                  <Percentage>1</Percentage>
+                  <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                </c:Fill>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="0.00999999978"/>
+                  <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                  <Orientation X="0" Y="0" Z="1.57079637"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+        <Entity name="BackgroundHexagon">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <Color A="0.300000012" B="1" G="1" R="1"/>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="-0.820431828" Y="0.441878349" Z="-0.100000001"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="ProgressionHexagon">
+              <Components>
+                <c:CapturePointHUD>
+                  <CapturePointNumber>1</CapturePointNumber>
+                </c:CapturePointHUD>
+                <c:Fill>
+                  <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                </c:Fill>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="0.00999999978"/>
+                  <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                  <Orientation X="0" Y="0" Z="1.57079637"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+        <Entity name="BackgroundHexagon">
+          <Components>
+            <c:Sprite>
+              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <Color A="0.699999988" B="0" G="0.200000003" R="1"/>
+            </c:Sprite>
+            <c:Transform>
+              <Position X="-1.58304751" Y="0.919596612" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="ProgressionHexagon">
+              <Components>
+                <c:CapturePointHUD/>
+                <c:Fill>
+                  <Percentage>1</Percentage>
+                  <Color A="0.699999988" B="0" G="0.200000003" R="1"/>
+                </c:Fill>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0" Z="0.00999999978"/>
+                  <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                  <Orientation X="0" Y="0" Z="4.71238899"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="CameraHUDOrigin">
+      <Components>
+        <c:Transform>
+          <Position X="-24.1716995" Y="1.20387542" Z="-6.66293383"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Camera">
+          <Components>
+            <c:Camera/>
+            <c:Model>
+              <Resource>Models/Widgets/Camera.mesh</Resource>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1.32321239" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/RenderingWorld.xml

@@ -162,7 +162,7 @@
           <Axis X="0.200000003" Y="3.4000001" Z="0.5"/>
         </c:RaptorCopter>
         <c:Transform>
-          <Orientation X="948.868286" Y="23876.6914" Z="1797.71118"/>
+          <Orientation X="758.059998" Y="20632.8887" Z="1320.68311"/>
         </c:Transform>
       </Components>
       <Children>
@@ -347,6 +347,18 @@
       </Components>
       <Children/>
     </Entity>
+    <Entity name="Sprite">
+      <Components>
+        <c:Sprite>
+          <DiffuseTexture>Textures/HexmapDiff.png</DiffuseTexture>
+          <GlowMap>Textures/GlowFrame.png</GlowMap>
+        </c:Sprite>
+        <c:Transform>
+          <Position X="0" Y="0" Z="-3.41100025"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
     <Entity>
       <Components>
         <c:Animation>

resources/Schema/Entities/StoneWall.xml

@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Collidable/>
+    <c:Model>
+      <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+    </c:Model>
+    <c:Transform>
+      <Position X="47.681942" Y="0.14480646" Z="46.8966408"/>
+      <Scale X="2" Y="2" Z="2"/>
+      <Orientation X="5.9380002" Y="0" Z="0.35800001"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1.10786498" Y="-0.615343928" Z="-0.37226662"/>
+          <Orientation X="0.443000019" Y="0.685000062" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="2.15796614" Y="-1.18461192" Z="-0.382025093"/>
+          <Orientation X="0" Y="2.18400002" Z="5.72200012"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="3.53984666" Y="-1.55501318" Z="-0.237787247"/>
+          <Orientation X="0.604000032" Y="0.640000045" Z="6.28300047"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-2.86977816" Y="0.0265773162" Z="0.530605257"/>
+          <Orientation X="0" Y="4.71200037" Z="5.89000034"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-4.06748295" Y="1.2850678" Z="1.0140655"/>
+          <Orientation X="0" Y="4.94500017" Z="5.66600037"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-1.6440227" Y="-0.104511783" Z="0.248545036"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="3.22254896" Y="-0.99158901" Z="-1.59910381"/>
+          <Orientation X="0.268000007" Y="5.9920001" Z="6.00300026"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-3.07137322" Y="0.124666147" Z="1.97699928"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-4.24249363" Y="0.303708076" Z="1.92021227"/>
+          <Orientation X="0" Y="2.95000005" Z="5.79700041"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Props/Stones/MediumStone1.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-1.89417958" Y="-0.57703048" Z="0.874724686"/>
+          <Orientation X="0.345000029" Y="0.651000023" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/WeaponReloadEffect.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="WeaponModel" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:BoneAttachment>
+      <BoneName>R_Arm_Weapon_Joint</BoneName>
+    </c:BoneAttachment>
+    <c:Lifetime>
+      <Lifetime>2</Lifetime>
+    </c:Lifetime>
+    <c:ExplosionEffect>
+      <ColorByDistance>true</ColorByDistance>
+      <Velocity X="3.33300018" Y="0.0320000015" Z="0"/>
+      <ExplosionOrigin X="0" Y="0.0790000036" Z="-0.329000026"/>
+      <ExponentialAccelaration>true</ExponentialAccelaration>
+      <EndColor A="0" B="19.6078434" G="19.6078434" R="1"/>
+      <Randomness>true</Randomness>
+    </c:ExplosionEffect>
+    <c:Model>
+      <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+      <Transparent>true</Transparent>
+    </c:Model>
+    <c:Transform>
+      <Position X="0.120747991" Y="-0.229502052" Z="-0.151475638"/>
+      <Orientation X="0.0104046296" Y="-0.00268167513" Z="0.0428442545"/>
+    </c:Transform>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Types/Entity.xsd

@@ -42,6 +42,7 @@
 							<xs:element ref="c:AssaultWeapon" minOccurs="0"/>
 							<xs:element ref="c:Shield" minOccurs="0"/>
 							<xs:element ref="c:Shielded" minOccurs="0"/>
+							<xs:element ref="c:CapturePointHUD" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

resources/Shaders/ForwardPlusSplatMapRGB.frag.glsl

@@ -0,0 +1,245 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec2 ScreenDimensions;
+uniform float FillPercentage;
+uniform vec4 DiffuseColor;
+uniform vec4 FillColor;
+uniform vec4 Color;
+uniform vec4 AmbientColor;
+
+//Get bineded at the same time as the textures
+uniform vec2 DiffuseUVRepeat1;
+uniform vec2 DiffuseUVRepeat2;
+uniform vec2 DiffuseUVRepeat3;
+uniform vec2 NormalUVRepeat1;
+uniform vec2 NormalUVRepeat2;
+uniform vec2 NormalUVRepeat3;
+uniform vec2 SpecularUVRepeat1;
+uniform vec2 SpecularUVRepeat2;
+uniform vec2 SpecularUVRepeat3;
+uniform vec2 GlowUVRepeat1;
+uniform vec2 GlowUVRepeat2;
+uniform vec2 GlowUVRepeat3;
+layout (binding = 0) uniform sampler2D SplatMapTexture;
+layout (binding = 1) uniform sampler2D DiffuseTexture1;
+layout (binding = 2) uniform sampler2D DiffuseTexture2;
+layout (binding = 3) uniform sampler2D DiffuseTexture3;
+layout (binding = 4) uniform sampler2D NormalMapTexture1;
+layout (binding = 5) uniform sampler2D NormalMapTexture2;
+layout (binding = 6) uniform sampler2D NormalMapTexture3;
+layout (binding = 7) uniform sampler2D SpecularMapTexture1;
+layout (binding = 8) uniform sampler2D SpecularMapTexture2;
+layout (binding = 9) uniform sampler2D SpecularMapTexture3;
+layout (binding = 10) uniform sampler2D GlowMapTexture1;
+layout (binding = 11) uniform sampler2D GlowMapTexture2;
+layout (binding = 12) uniform sampler2D GlowMapTexture3;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist, float falloff) {
+	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+}
+
+vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
+	vec4 R = normalize( reflect(-lightVec, normal));
+	float RdotV = max( dot(R, viewVec), 0.0);
+	return lightColor * pow(RdotV, 90.0);
+}
+
+vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
+	float power = max( dot(normal, lightVec), 0.0);
+	return lightColor * power;
+}
+
+LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
+	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
+	return result;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+vec4 CalcBlendedTexel(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+	 				  vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	vec4 R_Channel = texture2D(R, Input.TextureCoordinate * R_TileValues);
+	vec4 G_Channel = texture2D(G, Input.TextureCoordinate * G_TileValues);
+	vec4 B_Channel = texture2D(B, Input.TextureCoordinate * B_TileValues);
+
+	float total = blendValue.r + blendValue.g + blendValue.b;
+	float totalDiv = 1.0f / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	return blendValue.r * R_Channel
+		 + blendValue.g * G_Channel
+		 + blendValue.b * B_Channel;
+}
+
+vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+					   vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	mat3 TBN = mat3(Input.Tangent, Input.BiTangent, Input.Normal);
+	vec3 R_Channel = texture(R, Input.TextureCoordinate * R_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 G_Channel = texture(G, Input.TextureCoordinate * G_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 B_Channel = texture(B, Input.TextureCoordinate * B_TileValues).xyz * 2.0 - vec3(1.0);
+
+	float total = blendValue.r + blendValue.g + blendValue.b + blendValue.a;
+	float totalDiv = 1 / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	vec3 Normal_result = blendValue.r * R_Channel
+					   + blendValue.g * G_Channel 
+		 			   + blendValue.b * B_Channel;
+
+	return vec4(TBN * normalize(Normal_result), 0.0);
+}
+
+void main()
+{
+	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);
+
+	vec4 diffuseTexel = CalcBlendedTexel(splatTexel, DiffuseTexture1, DiffuseTexture2, DiffuseTexture3,
+	 									 DiffuseUVRepeat1, DiffuseUVRepeat2, DiffuseUVRepeat3);
+	vec4 glowTexel = CalcBlendedTexel(splatTexel, GlowMapTexture1, GlowMapTexture2, GlowMapTexture3,
+	 									 GlowUVRepeat1, GlowUVRepeat2, GlowUVRepeat3);
+	vec4 specularTexel = CalcBlendedTexel(splatTexel, SpecularMapTexture1, SpecularMapTexture2, SpecularMapTexture3,
+										 SpecularUVRepeat1, SpecularUVRepeat2, SpecularUVRepeat3);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	//vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate, SplatMapTexture);
+	vec4 normal = V * CalcBlendedNormal(splatTexel, NormalMapTexture1, NormalMapTexture2, NormalMapTexture3,
+		   								NormalUVRepeat1, NormalUVRepeat2, NormalUVRepeat3);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position); 
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb, 1.0);
+	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
+
+	int start = int(LightGrids.Data[currentTile].Start);
+	int amount = int(LightGrids.Data[currentTile].Amount);
+
+	for(int i = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += light_result.Diffuse;
+		totalLighting.Specular += light_result.Specular;
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	color_result += glowTexel*3;
+
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

resources/Shaders/Sprite.frag.glsl

@@ -30,12 +30,12 @@ void main()
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
 	if(pos <= FillPercentage) {
-		color_result += FillColor;
+		color_result = FillColor*diffuseTexel.a;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
-	color_result += glowTexel*3;
 
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	//bloomColor = vec4(clamp((glowTexel.xyz*3) - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(1.0, 1.0, 1.0, 0.0);
 }
 
 

resources/Shaders/Sprite.vert.glsl

@@ -16,7 +16,8 @@ out VertexData{
 
 void main()
 {
-	gl_Position = P  * M * vec4(Position, 1.0);
+
+	gl_Position = P * V * M * vec4(Position, 1.0);
 
 	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;

src/Engine/Collision/Collision.cpp

@@ -6,6 +6,7 @@
 #include "Core/World.h"
 #include "Rendering/Model.h"
 #include "imgui/imgui.h"
+#include "Core/Octree.h"
 
 namespace Collision
 {
@@ -145,13 +146,14 @@ bool RayVsTriangle(const Ray& ray,
 }
 
 bool RayVsModel(const Ray& ray,
-    const std::vector<RawModel::Vertex>& modelVertices,
-    const std::vector<unsigned int>& modelIndices)
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix)
 {
-    for (int i = 0; i < modelIndices.size(); ++i) {
-        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-        glm::vec3 v1 = modelVertices[modelIndices[++i]].Position;
-        glm::vec3 v2 = modelVertices[modelIndices[++i]].Position;
+    for (int i = 0; i < modelIndices.size();) {
+        glm::vec3 v0 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
         if (RayVsTriangle(ray, v0, v1, v2)) {
             return true;
         }
@@ -192,19 +194,20 @@ bool RayVsTriangle(const Ray& ray,
 }
 
 bool RayVsModel(const Ray& ray,
-    const std::vector<RawModel::Vertex>& modelVertices,
+    const RawModel::Vertex* modelVertices,
     const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix,
     float& outDistance,
     float& outUCoord,
     float& outVCoord)
 {
     outDistance = INFINITY;
     bool hit = false;
-    for (int i = 0; i < modelIndices.size(); ++i) {
-        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-        glm::vec3 v1 = modelVertices[modelIndices[++i]].Position;
-        glm::vec3 v2 = modelVertices[modelIndices[++i]].Position;
-        float dist;
+    for (int i = 0; i < modelIndices.size();) {
+        glm::vec3 v0 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
+        float dist = INFINITY;
         float u;
         float v;
         if (RayVsTriangle(ray, v0, v1, v2, dist, u, v)) {
@@ -218,14 +221,15 @@ bool RayVsModel(const Ray& ray,
 }
 
 bool RayVsModel(const Ray& ray,
-    const std::vector<RawModel::Vertex>& modelVertices,
+    const RawModel::Vertex* modelVertices,
     const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix,
     glm::vec3& outHitPosition)
 {
     float u;
     float v;
     float dist;
-    bool hit = RayVsModel(ray, modelVertices, modelIndices, dist, u, v);
+    bool hit = RayVsModel(ray, modelVertices, modelIndices, modelMatrix, dist, u, v);
     outHitPosition = ray.Origin() + dist * ray.Direction();
     return hit;
 }
@@ -572,11 +576,11 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeM
         ComponentWrapper& cAABB = entity["AABB"];
         modelSpaceBox = EntityAABB::FromOriginSize((glm::vec3)cAABB["Origin"], (glm::vec3)cAABB["Size"]);
     } else if (entity.HasComponent("Model")) {
-        Model* model;
         std::string res = entity["Model"]["Resource"];
         if (res.empty()) {
             return boost::none;
         }
+        Model* model;
         try {
             model = ResourceManager::Load<::Model, true>(res);
         } catch (const Resource::StillLoadingException&) {
@@ -638,4 +642,36 @@ boost::optional<EntityAABB> AbsoluteAABBExplosionEffect(EntityWrapper& entity)
     return aabb;
 }
 
+boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, std::vector<EntityAABB> entitiesPotentiallyHitSorted, float& outDistance, glm::vec3& outIntersectPos)
+{
+    for (EntityAABB& entityBox : entitiesPotentiallyHitSorted) {
+        if (!entityBox.Entity.HasComponent("Model")) {
+            continue;
+        }
+        std::string res = entityBox.Entity["Model"]["Resource"];
+        if (res.empty()) {
+            continue;
+        }
+        Model* model;
+        try {
+            model = ResourceManager::Load<::Model, true>(res);
+        } catch (const std::exception&) {
+            continue;
+        }
+        float u, v;
+        if (RayVsModel(ray, model->Vertices(), model->m_RawModel->m_Indices, Transform::ModelMatrix(entityBox.Entity), outDistance, u, v)) {
+            outIntersectPos = ray.Origin() + outDistance * ray.Direction();
+            return entityBox;
+        }
+    }
+    return boost::none;
+}
+
+boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, Octree<EntityAABB>* octree, float& outDistance, glm::vec3& outIntersectPos)
+{
+    std::vector<EntityAABB> outObjects;
+    octree->ObjectsPossiblyHitByRay(ray, outObjects);
+    return Collision::EntityFirstHitByRay(ray, outObjects, outDistance, outIntersectPos);
+}
+
 }

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -65,7 +65,6 @@ void EntityFilePreprocessor::parseComponentInfo()
 
         // Name
         compInfo.Name = XS::ToString(element->getName());
-        bool brk = compInfo.Name == "HiddenForLocalPlayer";
         // Known allocation
         compInfo.Meta->Allocation = m_ComponentCounts[compInfo.Name];
         // Annotation

src/Engine/Core/Octree.cpp

@@ -5,22 +5,6 @@
 #include "Core/Octree.h"
 #include "Collision/Collision.h"
 
-namespace
-{
-//To be able to sort nodes based on distance to ray origin.
-struct ChildInfo
-{
-    int Index;
-    float Distance;
-};
-
-bool isFirstLower(const ChildInfo& first, const ChildInfo& second)
-{
-    return first.Distance < second.Distance;
-}
-
-}
-
 namespace OctSpace
 {
 
@@ -123,14 +107,14 @@ bool Child::RayCollides(const Ray& ray, OctSpace::Output& data) const
         //If the ray shoots the tree, and it is a parent to 8 children :o
         if (hasChildren()) {
             //Sort children according to their distance from the ray origin.
-            std::vector<ChildInfo> childInfos;
+            std::vector<RaySorterInfo> childInfos;
             childInfos.reserve(8);
             for (int i = 0; i < 8; ++i) {
                 childInfos.push_back({ i, glm::distance(ray.Origin(), m_Children[i]->m_Box.Origin()) });
             }
             std::sort(childInfos.begin(), childInfos.end(), isFirstLower);
             //Loop through the children, starting with the one closest to the ray origin. I.e the first to be hit.
-            for (const ChildInfo& info : childInfos) {
+            for (const RaySorterInfo& info : childInfos) {
                 if (m_Children[info.Index]->RayCollides(ray, data)) {
                     return true;
                 }
@@ -275,4 +259,9 @@ std::vector<int> Child::childIndicesContainingBox(const AABB& box) const
     }
 }
 
+bool isFirstLower(const RaySorterInfo& first, const RaySorterInfo& second)
+{
+    return first.Distance < second.Distance;
+}
+
 }

src/Engine/Network/Client.cpp

@@ -390,8 +390,9 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
 bool Client::OnPlayerDamage(const Events::PlayerDamage & e)
 {
     Packet packet(MessageType::OnPlayerDamage, m_SendPacketID);
+    packet.WritePrimitive(m_ClientIDToServerID.at(e.Inflictor.ID));
+    packet.WritePrimitive(m_ClientIDToServerID.at(e.Victim.ID));
     packet.WritePrimitive(e.Damage);
-    packet.WritePrimitive(m_ClientIDToServerID.at(e.Player.ID));
     send(packet);
     return false;
 }

src/Engine/Network/Server.cpp

@@ -299,8 +299,9 @@ void Server::parseOnInputCommand(Packet& packet)
 void Server::parseOnPlayerDamage(Packet & packet)
 {
     Events::PlayerDamage e;
+    e.Inflictor = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
+    e.Victim = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
     e.Damage = packet.ReadPrimitive<double>();
-    e.Player = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
     m_EventBroker->Publish(e);
     //LOG_DEBUG("Server::parseOnPlayerDamage: Command is %s. Value is %f. PlayerID is %i.", e.DamageAmount, e.PlayerDamagedID, e.TypeOfDamage.c_str());
 }

src/Engine/Rendering/AnimationSystem.cpp

@@ -34,19 +34,32 @@ void AnimationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& a
             if (!(bool)animationComponent["Loop" + std::to_string(i)]) {
                 if (nextTime > animation->Duration) {
                     nextTime = animation->Duration;
+                    Events::AnimationComplete e;
+                    e.Entity = entity;
+                    e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
+                    m_EventBroker->Publish(e);
                 } else if (nextTime < 0) {
+                    Events::AnimationComplete e;
+                    e.Entity = entity;
+                    e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
+                    m_EventBroker->Publish(e);
                     nextTime = 0;
                 }
 
                 (double&)animationComponent["Speed" + std::to_string(i)] = 0.0;
-                Events::AnimationComplete e;
-                e.Entity = entity;
-                e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
-                m_EventBroker->Publish(e);
+                
             } else {
                 if (nextTime > animation->Duration) {
+                    Events::AnimationComplete e;
+                    e.Entity = entity;
+                    e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
+                    m_EventBroker->Publish(e);
                     nextTime -= animation->Duration;
                 } else if (nextTime < 0) {
+                    Events::AnimationComplete e;
+                    e.Entity = entity;
+                    e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
+                    m_EventBroker->Publish(e);
                     nextTime += animation->Duration;
                 }
             }
@@ -54,32 +67,5 @@ void AnimationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& a
             (double&)animationComponent["Time" + std::to_string(i)] = nextTime;
         }
     } 
-
-    //Calculate bone transforms
-    if (skeleton != nullptr) {
-        std::vector<Skeleton::AnimationData> animations;
-        if (entity.HasComponent("Animation")) {
-            for (int i = 1; i <= 3; i++) {
-                Skeleton::AnimationData animationData;
-                animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(entity["Animation"]["AnimationName" + std::to_string(i)]);
-                if (animationData.animation == nullptr) {
-                    continue;
-                }
-                animationData.time = (double)entity["Animation"]["Time" + std::to_string(i)];
-                animationData.weight = (double)entity["Animation"]["Weight" + std::to_string(i)];
-
-                animations.push_back(animationData);
-            }
-        }
-
-        if (entity.HasComponent("AnimationOffset")) {
-            Skeleton::AnimationOffset animationOffset;
-            animationOffset.animation = skeleton->GetAnimation(entity["AnimationOffset"]["AnimationName"]);
-            animationOffset.time = (double)entity["AnimationOffset"]["Time"];
-            skeleton->CalculateFrameBones(animations, animationOffset);
-        } else {
-            skeleton->CalculateFrameBones(animations);
-        }
-    }
 }
 

src/Engine/Rendering/BoneAttachmentSystem.cpp

@@ -19,6 +19,9 @@ void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
         return;
     }
 
+    if (!model->IsSkinned()) {
+        return;
+    }
 
     Skeleton* skeleton = model->m_RawModel->m_Skeleton;
 
@@ -26,21 +29,45 @@ void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
         return;
     }
 
-    const Skeleton::Animation* animation = skeleton->GetAnimation(parent["Animation"]["AnimationName1"]);
-
-    if (!animation) {
-        return;
-    }
-
     int id = skeleton->GetBoneID(entity["BoneAttachment"]["BoneName"]);
 
-    if(id == -1) {
+    if (id == -1) {
         return;
     }
 
+    std::vector<::Skeleton::AnimationData> Animations;
+    ::Skeleton::AnimationOffset AnimationOffset;
+    glm::mat4 boneTransform;
 
-    glm::mat4 boneTransform = skeleton->GetBoneTransformSuper(id);
-    //glm::mat4 boneTransform = skeleton->GetBoneTransform(skeleton->Bones[id], animation, (double)parent["Animation"]["Time1"], glm::mat4(1));
+    if (parent.HasComponent("Animation")) {
+        for (int i = 1; i <= 3; i++) {
+            ::Skeleton::AnimationData animationData;
+            animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(parent["Animation"]["AnimationName" + std::to_string(i)]);
+            if (animationData.animation == nullptr) {
+                continue;
+            }
+            animationData.time = (double)parent["Animation"]["Time" + std::to_string(i)];
+            animationData.weight = (double)parent["Animation"]["Weight" + std::to_string(i)];
+
+            Animations.push_back(animationData);
+        }
+    }
+
+    if (parent.HasComponent("AnimationOffset")) {
+        AnimationOffset.animation = model->m_RawModel->m_Skeleton->GetAnimation(parent["AnimationOffset"]["AnimationName"]);
+        AnimationOffset.time = (double)parent["AnimationOffset"]["Time"];
+
+        if(AnimationOffset.animation != nullptr) {
+            boneTransform = skeleton->GetBoneTransform(false, skeleton->Bones.at(id), Animations, AnimationOffset, glm::mat4(1));
+        } else {
+            boneTransform = skeleton->GetBoneTransform(false, skeleton->Bones.at(id), Animations, glm::mat4(1));
+        }
+        
+    } else {
+        boneTransform = skeleton->GetBoneTransform(false, skeleton->Bones.at(id), Animations, glm::mat4(1));
+    }
+    
+    
 
     glm::vec3 scale;
     glm::quat rotation;

src/Engine/Rendering/Camera.cpp

@@ -62,6 +62,13 @@ void Camera::SetViewMatrix(glm::mat4 val)
     m_ViewMatrix = val;
 }
 
+
+glm::mat4 Camera::BillboardMatrix()
+{
+    glm::mat4 matrix = glm::toMat4(m_Orientation);
+    return matrix; 
+}
+
 //void Camera::Pitch(float val)
 //{
 //	m_Pitch = val;

src/Engine/Rendering/DrawBloomPass.cpp

@@ -13,7 +13,7 @@ DrawBloomPass::DrawBloomPass(IRenderer* renderer)
 
 void DrawBloomPass::InitializeTextures()
 {
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/White.png");
+    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
 }
 
 void DrawBloomPass::InitializeShaderPrograms()

src/Engine/Rendering/DrawFinalPass.cpp

@@ -13,10 +13,11 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
 
 void DrawFinalPass::InitializeTextures()
 {
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/White.png");
-    m_BlackTexture = ResourceManager::Load<Texture>("Textures/Core/Black.png");
-    m_NeutralNormalTexture = ResourceManager::Load<Texture>("Textures/Core/NeutralNormalMap.png");
-    m_GreyTexture = ResourceManager::Load<Texture>("Textures/Core/Grey.png");
+    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
+    m_NeutralNormalTexture = CommonFunctions::LoadTexture("Textures/Core/NeutralNormalMap.png", false);
+    m_GreyTexture = CommonFunctions::LoadTexture("Textures/Core/Grey.png", false);
+    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
 }
 
 void DrawFinalPass::InitializeFrameBuffers()
@@ -79,9 +80,17 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ExplosionEffectProgram->Link();
     GLERROR("Creating explosion program");
 
+    m_SpriteProgram = ResourceManager::Load<ShaderProgram>("#SpriteProgram");
+    m_SpriteProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Sprite.vert.glsl")));
+    m_SpriteProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Sprite.frag.glsl")));
+    m_SpriteProgram->Compile();
+    m_SpriteProgram->BindFragDataLocation(0, "sceneColor");
+    m_SpriteProgram->BindFragDataLocation(1, "bloomColor");
+    m_SpriteProgram->Link();
+    GLERROR("Creating sprite program");
 	m_ForwardPlusSplatMapProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram");
 	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
-	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMap.frag.glsl")));
+	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGB.frag.glsl")));
 	m_ForwardPlusSplatMapProgram->Compile();
 	m_ForwardPlusSplatMapProgram->BindFragDataLocation(0, "sceneColor");
 	m_ForwardPlusSplatMapProgram->BindFragDataLocation(1, "bloomColor");
@@ -91,7 +100,7 @@ void DrawFinalPass::InitializeShaderPrograms()
 	m_ExplosionEffectSplatMapProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSplatMapProgram");
 	m_ExplosionEffectSplatMapProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
 	m_ExplosionEffectSplatMapProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
-	m_ExplosionEffectSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMap.frag.glsl")));
+	m_ExplosionEffectSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGB.frag.glsl")));
 	m_ExplosionEffectSplatMapProgram->Compile();
 	m_ExplosionEffectSplatMapProgram->BindFragDataLocation(0, "sceneColor");
 	m_ExplosionEffectSplatMapProgram->BindFragDataLocation(1, "bloomColor");
@@ -119,7 +128,7 @@ void DrawFinalPass::InitializeShaderPrograms()
 
 	m_ExplosionEffectSplatMapSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSplatMapSkinnedProgram");
 	m_ExplosionEffectSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
-	m_ExplosionEffectSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMap.frag.glsl")));
+	m_ExplosionEffectSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGB.frag.glsl")));
 	m_ExplosionEffectSplatMapSkinnedProgram->Compile();
 	m_ExplosionEffectSplatMapSkinnedProgram->BindFragDataLocation(0, "sceneColor");
 	m_ExplosionEffectSplatMapSkinnedProgram->BindFragDataLocation(1, "bloomColor");
@@ -128,7 +137,7 @@ void DrawFinalPass::InitializeShaderPrograms()
 
 	m_ForwardPlusSplatMapSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapSkinnedProgram");
 	m_ForwardPlusSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
-	m_ForwardPlusSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMap.frag.glsl")));
+	m_ForwardPlusSplatMapSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMapRGB.frag.glsl")));
 	m_ForwardPlusSplatMapSkinnedProgram->Compile();
 	m_ForwardPlusSplatMapSkinnedProgram->BindFragDataLocation(0, "sceneColor");
 	m_ForwardPlusSplatMapSkinnedProgram->BindFragDataLocation(1, "bloomColor");
@@ -184,6 +193,8 @@ void DrawFinalPass::Draw(RenderScene& scene)
     GLERROR("OpaqueObjects");
     DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
     GLERROR("TransparentObjects");
+    DrawSprites(scene.Jobs.SpriteJob, scene);
+    GLERROR("SpriteJobs");
 
     //DrawStencilState* stencilState = new DrawStencilState(m_FinalPassFrameBuffer.GetHandle());
     //Draw shields to stencil pass
@@ -312,7 +323,6 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
-
     for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if (explosionEffectJob) {
@@ -328,7 +338,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     //bind textures
                     BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
                     std::vector<glm::mat4> frameBones;
-                    frameBones = explosionEffectJob->Skeleton->GetBones();
+                    if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+                    } else {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+                    }
                     glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 } else {
                     m_ExplosionEffectProgram->Bind();
@@ -351,7 +365,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
                     GLERROR("asdasd");
                     std::vector<glm::mat4> frameBones;
-                    frameBones = explosionEffectJob->Skeleton->GetBones();
+                    if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+                    } else {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+                    }
                     glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
                 } else {
@@ -392,7 +410,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             //bind textures
                             BindModelTextures(forwardSkinnedHandle, modelJob);
                             std::vector<glm::mat4> frameBones;
-                            frameBones = modelJob->Skeleton->GetBones();
+                            if (modelJob->AnimationOffset.animation != nullptr) {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                            } else {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                            }
                             glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
                         } else {
@@ -416,7 +438,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
                             GLERROR("asdasd");
                             std::vector<glm::mat4> frameBones;
-                            frameBones = modelJob->Skeleton->GetBones();
+                            if (modelJob->AnimationOffset.animation != nullptr) {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                            } else {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                            }
                             glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
                         } else {
@@ -460,7 +486,11 @@ void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJo
                 glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
                 glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
                 std::vector<glm::mat4> frameBones;
-                frameBones = modelJob->Skeleton->GetBones();
+                if (modelJob->AnimationOffset.animation != nullptr) {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                } else {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                }
                 glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
             } else {
                 m_ShieldToStencilProgram->Bind();
@@ -514,7 +544,11 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
             }
 
             std::vector<glm::mat4> frameBones;
-            frameBones = explosionEffectJob->Skeleton->GetBones();
+            if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+            } else {
+                frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+            }
             glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
             if (GLERROR("Animation")) {
@@ -549,7 +583,11 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
                 BindModelTextures(forwardHandle ,modelJob);
 
                 std::vector<glm::mat4> frameBones;
-                frameBones = modelJob->Skeleton->GetBones();
+                if (modelJob->AnimationOffset.animation != nullptr) {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                } else {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                }
                 glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
 
@@ -581,7 +619,11 @@ void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& job
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
 
             std::vector<glm::mat4> frameBones;
-           frameBones = modelJob->Skeleton->GetBones();
+            if (modelJob->AnimationOffset.animation != nullptr) {
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+            } else {
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+            }
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
         } else {
@@ -604,6 +646,55 @@ void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& job
 
 }
 
+
+void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene)
+{
+    m_SpriteProgram->Bind();
+
+    GLuint shaderHandle = m_SpriteProgram->GetHandle();
+
+    for(auto& job : jobs) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        RenderState jobState;
+
+        if (spriteJob) {
+            if(spriteJob->Depth == 0) {
+                jobState.Disable(GL_DEPTH_TEST);
+            }
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(spriteJob->Matrix));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniform3fv(glGetUniformLocation(shaderHandle, "CameraPos"), 1, glm::value_ptr(scene.Camera->Position()));
+            glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(spriteJob->Color));
+            glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(spriteJob->FillColor));
+            glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), spriteJob->FillPercentage);
+
+            glActiveTexture(GL_TEXTURE0);
+            if (spriteJob->DiffuseTexture != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, spriteJob->DiffuseTexture->m_Texture);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, m_ErrorTexture->m_Texture);
+            }
+
+            glActiveTexture(GL_TEXTURE1);
+            if (spriteJob->IncandescenceTexture != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, spriteJob->IncandescenceTexture->m_Texture);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+            }
+
+
+            glBindVertexArray(spriteJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, spriteJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, spriteJob->EndIndex - spriteJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(spriteJob->StartIndex*sizeof(unsigned int)));
+        }
+    }
+
+    
+
+   // m_SpriteProgram->Unbind();
+}
+
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
 	GLERROR("Bind 1 uniform");
@@ -859,7 +950,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 		
 			//Bind 5 diffuse textures
 			std::string UniformName = "DiffuseUVRepeat";
-			for (unsigned int i = 0; i < 5; i++) {
+			for (unsigned int i = 0; i < 3; i++) {
 				glActiveTexture(texturePosition);
 				if (job->DiffuseTexture.size() > i && job->DiffuseTexture[i]->Texture != nullptr) {
 					glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[i]->Texture->m_Texture);
@@ -873,7 +964,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 
 			//Bind 5 Normal textures
 			UniformName = "NormalUVRepeat";
-			for (unsigned int i = 0; i < 5; i++) {
+			for (unsigned int i = 0; i < 3; i++) {
 				glActiveTexture(texturePosition);
 				if (job->NormalTexture.size() > i && job->NormalTexture[i]->Texture != nullptr) {
 					glBindTexture(GL_TEXTURE_2D, job->NormalTexture[i]->Texture->m_Texture);
@@ -887,7 +978,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 
 			//Bind 5 Specular textures
 			UniformName = "SpecularUVRepeat";
-			for (unsigned int i = 0; i < 5; i++) {
+			for (unsigned int i = 0; i < 3; i++) {
 				glActiveTexture(texturePosition);
 				if (job->SpecularTexture.size() > i && job->SpecularTexture[i]->Texture != nullptr) {
 					glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[i]->Texture->m_Texture);
@@ -901,7 +992,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 
 			//Bind 5 Incandescence textures
 			UniformName = "GlowUVRepeat";
-			for (unsigned int i = 0; i < 5; i++) {
+			for (unsigned int i = 0; i < 3; i++) {
 				glActiveTexture(texturePosition);
 				if (job->IncandescenceTexture.size() > i && job->IncandescenceTexture[i]->Texture != nullptr) {
 					glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[i]->Texture->m_Texture);

src/Engine/Rendering/Model.cpp

@@ -10,60 +10,31 @@ Model::Model(std::string fileName)
 		case RawModel::MaterialType::SingleTextures:
 		{
 			RawModel::MaterialSingleTextures* materialSingleTexture = static_cast<RawModel::MaterialSingleTextures*>(materialProperty.material);
-			if (!materialSingleTexture->ColorMap.TexturePath.empty()) {
-				materialSingleTexture->ColorMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->ColorMap.TexturePath));
-			}
-			if (!materialSingleTexture->NormalMap.TexturePath.empty()) {
-				materialSingleTexture->NormalMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->NormalMap.TexturePath));
-			}
-			if (!materialSingleTexture->SpecularMap.TexturePath.empty()) {
-				materialSingleTexture->SpecularMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->SpecularMap.TexturePath));
-			}
-			if (!materialSingleTexture->IncandescenceMap.TexturePath.empty()) {
-				materialSingleTexture->IncandescenceMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->IncandescenceMap.TexturePath));
-			}
+            materialSingleTexture->ColorMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->ColorMap.TexturePath, false);
+            materialSingleTexture->NormalMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->NormalMap.TexturePath, false);
+            materialSingleTexture->SpecularMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->SpecularMap.TexturePath, false);
+            materialSingleTexture->IncandescenceMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->IncandescenceMap.TexturePath, false);
 		}
 			break;
 		case RawModel::MaterialType::SplatMapping:
 		{
 			RawModel::MaterialSplatMapping* materialSplatMapping = static_cast<RawModel::MaterialSplatMapping*>(materialProperty.material);
-			if (!materialSplatMapping->SplatMap.TexturePath.empty()) {
-				materialSplatMapping->SplatMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSplatMapping->SplatMap.TexturePath));
-			}
+			materialSplatMapping->SplatMap.Texture = CommonFunctions::LoadTexture(materialSplatMapping->SplatMap.TexturePath, false);
 			for (auto& texture : materialSplatMapping->ColorMaps)
 			{
-				if (!texture.TexturePath.empty()) {
-					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
-				}
-				else {
-					texture.Texture = nullptr;
-				}
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
 			}
 			for (auto& texture : materialSplatMapping->NormalMaps)
 			{
-				if (!texture.TexturePath.empty()) {
-					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
-				} else {
-					texture.Texture = nullptr;
-				}
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
 			}
 			for (auto& texture : materialSplatMapping->SpecularMaps)
 			{
-				if (!texture.TexturePath.empty()) {
-					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
-				}
-				else {
-					texture.Texture = nullptr;
-				}
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
 			}
 			for (auto& texture : materialSplatMapping->IncandescenceMaps)
 			{
-				if (!texture.TexturePath.empty()) {
-					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
-				}
-				else {
-					texture.Texture = nullptr;
-				}
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
 			}
 		}
 			break;

src/Engine/Rendering/PNG.cpp

@@ -4,40 +4,35 @@ PNG::PNG(std::string path)
 {
 	FILE* file = fopen(path.c_str(), "rb");
 	if (!file) {
-		LOG_ERROR("Failed to open texture file \"%s\": %s", path.c_str(), const_cast<const char*>(strerror(errno)));
-		return;
+        throw Resource::FailedLoadingException("Failed to open texture file.");
 	}
 
 	png_byte header[8];
 	fread(header, 1, 8, file);
 	bool isPNG = !png_sig_cmp(header, 0, 8);
 	if (!isPNG) {
-		LOG_ERROR("Failed to load texture file \"%s\": File isn't PNG", path.c_str());
 		fclose(file);
-		return;
+        throw Resource::FailedLoadingException("File is not PNG.");
 	}
 
 	// Initialize libpng
 	png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, (png_error_ptr)&PNG::pngErrorFunction, (png_error_ptr)&PNG::pngErrorFunction);
 	if (!png_ptr) {
-		LOG_ERROR("libpng: Failed to initialze png_struct");
 		png_destroy_read_struct(&png_ptr, nullptr, nullptr);
 		fclose(file);
-		return;
+        throw Resource::FailedLoadingException("Failed to initialze png_struct.");
 	}
 	png_infop info_ptr = png_create_info_struct(png_ptr);
 	if (!info_ptr) {
-		LOG_ERROR("libpng: Failed to initialze png_info");
 		png_destroy_read_struct(&png_ptr, nullptr, nullptr);
 		fclose(file);
-		return;
+        throw Resource::FailedLoadingException("Failed to initialze png_info.");
 	}
 	png_infop info_end_ptr = png_create_info_struct(png_ptr);
 	if (!info_end_ptr) {
-		LOG_ERROR("libpng: Failed to initialze second png_info");
 		png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
 		fclose(file);
-		return;
+        throw Resource::FailedLoadingException("Failed to initialze second png_info.");
 	}
 	png_init_io(png_ptr, file);
 
@@ -51,8 +46,8 @@ PNG::PNG(std::string path)
 	unsigned int width, height;
 	png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
 	if (bit_depth != 8) {
-		LOG_ERROR("libpng: Unsupported bit depth \"%i\" of image \"%s\", must be 8", bit_depth, path.c_str());
-		return;
+        throw Resource::FailedLoadingException("Unsupported bit depth. Must be 8");
+
 	}
 	switch (color_type) {
 		case PNG_COLOR_TYPE_RGB:
@@ -60,8 +55,7 @@ PNG::PNG(std::string path)
 			Format = Image::ImageFormat::RGBA;
 			break;
 		default:
-			LOG_ERROR("libpng: Unsupported color format \"%i\" of image \"%s\"", color_type, path.c_str());
-			return;
+            throw Resource::FailedLoadingException("Unsupported color format.");
 	}
 
 	// Convert RGB to RGBA, since DirectX rather treat them all the same way

src/Engine/Rendering/PickingPass.cpp

@@ -103,7 +103,11 @@ void PickingPass::Draw(RenderScene& scene)
 				if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
                     std::vector<glm::mat4> frameBones;
-                    frameBones = modelJob->Skeleton->GetBones();
+                    if (modelJob->AnimationOffset.animation != nullptr) {
+                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                    } else {
+                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                    }
                     glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
 				}
@@ -121,7 +125,7 @@ void PickingPass::Draw(RenderScene& scene)
         }
     }
 
-    for (auto &job : scene.Jobs.TransparentObjects) {
+   /* for (auto &job : scene.Jobs.TransparentObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
@@ -156,7 +160,11 @@ void PickingPass::Draw(RenderScene& scene)
                 glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
                 std::vector<glm::mat4> frameBones;
-                frameBones = modelJob->Skeleton->GetBones();
+                if (modelJob->AnimationOffset.animation != nullptr) {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                } else {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                }
                 glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
             } else {
                 m_PickingProgram->Bind();
@@ -170,7 +178,7 @@ void PickingPass::Draw(RenderScene& scene)
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
             glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
         }
-    }
+    }*/
 
     for (auto &job : scene.Jobs.OpaqueShieldedObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
@@ -207,7 +215,11 @@ void PickingPass::Draw(RenderScene& scene)
                 glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
                 std::vector<glm::mat4> frameBones;
-                frameBones = modelJob->Skeleton->GetBones();
+                if (modelJob->AnimationOffset.animation != nullptr) {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                } else {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                }
                 glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
             } else {
@@ -224,7 +236,7 @@ void PickingPass::Draw(RenderScene& scene)
         }
     }
 
-    for (auto &job : scene.Jobs.TransparentShieldedObjects) {
+ /*   for (auto &job : scene.Jobs.TransparentShieldedObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
@@ -264,7 +276,11 @@ void PickingPass::Draw(RenderScene& scene)
                 if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
                     std::vector<glm::mat4> frameBones;
-                    frameBones = modelJob->Skeleton->GetBones();
+                    if (modelJob->AnimationOffset.animation != nullptr) {
+                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                    } else {
+                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                    }
                     glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
                 }
@@ -284,7 +300,7 @@ void PickingPass::Draw(RenderScene& scene)
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
             glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
         }
-    }
+    }*/
     
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");

src/Engine/Rendering/RawModelCustom.cpp

@@ -277,8 +277,8 @@ void RawModelCustom::ReadMaterialTextureProperties(RawModelCustom::TextureProper
 			throw Resource::FailedLoadingException("Reading Material texture UVTiling failed");
 		}
 		memcpy(&texture.UVRepeat[0], fileData + offset, sizeof(glm::vec2));
-		offset += sizeof(glm::vec2);
 	}
+	offset += sizeof(glm::vec2);
 }
 
 void RawModelCustom::ReadAnimationFile(std::string filePath)

src/Engine/Rendering/RenderSystem.cpp

@@ -33,6 +33,67 @@ bool RenderSystem::OnSetCamera(Events::SetCamera& e)
     return true;
 }
 
+
+void RenderSystem::fillSprites(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
+{
+    auto sprites = world->GetComponents("Sprite");
+    if (sprites == nullptr) {
+        return;
+    }
+
+    for (auto& cSprite : *sprites) {
+        bool visible = cSprite["Visible"];
+        if (!visible) {
+            continue;
+        }
+       
+        EntityWrapper entity(world, cSprite.EntityID);
+        if (!isEntityVisible(entity)) {
+            continue;
+        }
+
+        std::string diffuseResource = cSprite["DiffuseTexture"];
+        std::string glowResource = cSprite["GlowMap"];
+        bool depthSorted = cSprite["DepthSort"];
+        if (diffuseResource.empty() && glowResource.empty()) {
+            continue;
+        }
+
+        float fillPercentage = 0.f;
+        glm::vec4 fillColor = glm::vec4(0);
+        if (world->HasComponent(entity.ID, "Fill")) {
+            auto fillComponent = world->GetComponent(entity.ID, "Fill");
+            fillPercentage = (float)(double)fillComponent["Percentage"];
+            fillColor = (glm::vec4)fillComponent["Color"];
+        }
+
+        glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, world);
+        //modelMatrix *= m_Camera->BillboardMatrix();
+
+
+        std::shared_ptr<SpriteJob> spriteJob = std::shared_ptr<SpriteJob>(new SpriteJob(cSprite, m_Camera, modelMatrix, world, fillColor, fillPercentage, depthSorted));
+        
+        jobs.push_back(spriteJob);
+    }
+}
+
+bool RenderSystem::isEntityVisible(EntityWrapper& entity)
+{
+
+    // Only render children of a camera if that camera is currently active
+    if (isChildOfACamera(entity) && !isChildOfCurrentCamera(entity)) {
+        return false;
+    }
+
+    // Hide things parented to local player if they have the HiddenFromLocalPlayer component
+    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    if (entity.HasComponent("HiddenForLocalPlayer") && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) && !outOfBodyExperience) {
+        return false;
+    }
+
+    return true;
+}
+
 bool RenderSystem::isChildOfACamera(EntityWrapper entity)
 {
     return entity.FirstParentWithComponent("Camera").Valid();
@@ -60,13 +121,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
             continue;
         }
 
-        // Only render children of a camera if that camera is currently active
-        if (isChildOfACamera(entity) && !isChildOfCurrentCamera(entity)) {
-            continue;
-        }
-
-        // Hide things parented to local player if they have the HiddenFromLocalPlayer component
-        if ((entity.HasComponent("HiddenForLocalPlayer") || entity.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer))) {
+        if (!isEntityVisible(entity)) {
             continue;
         }
 
@@ -209,7 +264,6 @@ void RenderSystem::fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs,
     }
 }
 
-
 void RenderSystem::fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
 {
     auto directionalLights = world->GetComponents("DirectionalLight");
@@ -231,7 +285,6 @@ void RenderSystem::fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>&
     }
 }
 
-
 void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
 {
     auto texts = world->GetComponents("Text");
@@ -249,6 +302,11 @@ void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World*
             continue;
         }
 
+        EntityWrapper entity(world, textComponent.EntityID);
+        if (!isEntityVisible(entity)) {
+            continue;
+        }
+
         Font* font;
         try {
             font = ResourceManager::Load<Font>(resource);
@@ -297,6 +355,7 @@ void RenderSystem::Update(double dt)
     fillPointLights(scene.Jobs.PointLight, m_World);
     //TODO: Make sure all objects needed are also sorted.
 	scene.Jobs.OpaqueObjects.sort();
+    fillSprites(scene.Jobs.SpriteJob, m_World);
     fillDirectionalLights(scene.Jobs.DirectionalLight, m_World);
     fillText(scene.Jobs.Text, m_World);
     m_RenderFrame->Add(scene);

src/Engine/Rendering/Renderer.cpp

@@ -106,16 +106,21 @@ void Renderer::Draw(RenderFrame& frame)
     for (auto scene : frame.RenderScenes){
         
         SortRenderJobsByDepth(*scene);
+        GLERROR("SortByDepth");
         m_PickingPass->Draw(*scene);
+        GLERROR("Drawing pickingpass");
         m_LightCullingPass->GenerateNewFrustum(*scene);
+        GLERROR("Generate frustums");
         m_LightCullingPass->FillLightList(*scene);
+        GLERROR("Filling light list");
         m_LightCullingPass->CullLights(*scene);
+        GLERROR("LightCulling");
         m_DrawFinalPass->Draw(*scene);
+        GLERROR("Draw Geometry+Light");
         //m_DrawScenePass->Draw(*scene);
 
-        GLERROR("Renderer::Draw m_DrawScenePass->Draw");
-
         m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
+        GLERROR("Draw Text");
 
     }
     m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
@@ -142,7 +147,8 @@ void Renderer::Draw(RenderFrame& frame)
     }
 
     m_ImGuiRenderPass->Draw();
-	glfwSwapBuffers(m_Window);
+    GLERROR("Imgui draw");
+    glfwSwapBuffers(m_Window);
 }
 
 PickData Renderer::Pick(glm::vec2 screenCoord)
@@ -152,8 +158,8 @@ PickData Renderer::Pick(glm::vec2 screenCoord)
 
 void Renderer::InitializeTextures()
 {
-    m_ErrorTexture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/White.png");
+    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
+    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
 }
 
 
@@ -161,6 +167,7 @@ void Renderer::SortRenderJobsByDepth(RenderScene &scene)
 {
     //Sort all forward jobs so transparency is good.
     scene.Jobs.TransparentObjects.sort(Renderer::DepthSort);
+    scene.Jobs.SpriteJob.sort(Renderer::DepthSort);
 }
 
 void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)

src/Engine/Rendering/Skeleton.cpp

@@ -30,30 +30,6 @@ Skeleton::~Skeleton()
 }
 
 
-void Skeleton::CalculateFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion /*= false*/)
-{
-    if (animations.size() <= 0 || animationOffset.animation == nullptr) {
-        for (auto& b : Bones) {
-            m_BoneLocalTransforms[b.first] = glm::mat4(1);
-            m_BoneTransforms[b.first] = glm::mat4(1);
-        }
-    } else {
-        AccumulateBoneTransforms(noRootMotion, animations, animationOffset, RootBone, glm::mat4(1));
-    }
-}
-
-
-void Skeleton::CalculateFrameBones(std::vector<AnimationData> animations, bool noRootMotion /*= false*/)
-{
-    if (animations.size() <= 0) {
-        for (auto& b : Bones) {
-            m_BoneLocalTransforms[b.first] = glm::mat4(1);
-            m_BoneTransforms[b.first] = glm::mat4(1);
-        }
-    } else {
-        AccumulateBoneTransforms(noRootMotion, animations, RootBone, glm::mat4(1));
-    }
-}
 
 const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 {
@@ -65,7 +41,167 @@ const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 	}
 }
 
-void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, const Bone* bone, glm::mat4 parentMatrix)
+std::vector<glm::mat4> Skeleton::GetFrameBones(std::vector<AnimationData> animations, bool noRootMotion /*= false*/)
+{
+    if (animations.size() <= 0) {
+        std::vector<glm::mat4> finalMatrices;
+        for (auto& b : Bones) {
+            finalMatrices.push_back(glm::mat4(1));//b.second->OffsetMatrix);
+        }
+        return finalMatrices;
+    }
+
+    std::map<int, glm::mat4> frameBones;
+    AccumulateBoneTransforms(true, animations, frameBones, RootBone, glm::mat4(1));
+
+    std::vector<glm::mat4> finalMatrices;
+    for (auto &kv : frameBones) {
+        finalMatrices.push_back(kv.second);
+    }
+    return finalMatrices;
+}
+
+std::vector<glm::mat4> Skeleton::GetFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion /*= false*/)
+{
+    if (animations.size() <= 0 || animationOffset.animation == nullptr) {
+        std::vector<glm::mat4> finalMatrices;
+        for (auto& b : Bones) {
+            finalMatrices.push_back(glm::mat4(1));//b.second->OffsetMatrix);
+        }
+        return finalMatrices;
+    }
+
+    
+    std::map<int, glm::mat4> frameBones;
+    AccumulateBoneTransforms(true, animations, animationOffset, frameBones, RootBone, glm::mat4(1));
+
+    std::vector<glm::mat4> finalMatrices;
+    for (auto &kv : frameBones) {
+        finalMatrices.push_back(kv.second);
+    }
+    return finalMatrices;
+}
+
+void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, std::map<int, glm::mat4>& boneMatrices, const Bone* bone, glm::mat4 parentMatrix)
+{
+    glm::mat4 boneMatrix;
+    std::vector<JointFrameTransform> JointTransforms;
+
+    for (const AnimationData animationData : animations) {
+        const Animation* animation = animationData.animation;
+        const float time = animationData.time;
+
+        JointFrameTransform jointTransform;
+        jointTransform.Weight = animationData.weight;;
+
+        if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
+            std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
+
+            Animation::Keyframe currentFrame;
+            Animation::Keyframe nextFrame;
+
+            if (boneKeyFrames.size() > 1) { // 2+ keyframes for the current bone
+                for (int index = boneKeyFrames.size()-1; index >= 0; index--) { // find the bone keyframes that surrounds the current frame
+                    if (time >= boneKeyFrames.at(index).Time) {
+                        currentFrame = boneKeyFrames.at(index);
+                        nextFrame = boneKeyFrames.at((index + 1) % boneKeyFrames.size());
+                        break;
+                    }
+                }
+
+                float progress;
+
+                if (nextFrame.Index == 0) {
+                    nextFrame = currentFrame;
+                    progress = (time - currentFrame.Time) / (animation->Duration - currentFrame.Time);
+                } else {
+                    progress = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+
+                }
+
+
+                if (progress > 1.0f || progress < 0.0f) {
+                    LOG_INFO("Progress: %f", progress);
+                    progress = glm::clamp(progress, 0.0f, 1.0f);
+                }
+                Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
+                Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
+
+                jointTransform.PositionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+                jointTransform.RotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+                jointTransform.ScaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+                // Flag for no root motion
+                if (bone == RootBone && noRootMotion) {
+                    jointTransform.PositionInterp.x = 0;
+                    jointTransform.PositionInterp.z = 0;
+                }
+
+                JointTransforms.push_back(jointTransform);
+
+            } else { // 1 keyframes for the current bone
+                currentFrame = boneKeyFrames.at(0);
+                jointTransform.PositionInterp = currentFrame.BoneProperties.Position;
+                jointTransform.RotationInterp = currentFrame.BoneProperties.Rotation;
+                jointTransform.ScaleInterp = currentFrame.BoneProperties.Scale;
+                JointTransforms.push_back(jointTransform);
+
+            }
+        } else { // 0 keyframes for the current bone
+
+        }
+
+    }
+
+    if (JointTransforms.size() <= 0) {
+        if (bone->Parent) {
+            boneMatrix = parentMatrix * glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix;
+            boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
+        } else {
+            boneMatrix = glm::inverse(bone->OffsetMatrix);
+            boneMatrices[bone->ID] = parentMatrix;
+        }
+    } else if (JointTransforms.size() == 1) {
+        boneMatrix = parentMatrix *(glm::translate(JointTransforms.at(0).PositionInterp) * glm::toMat4(JointTransforms.at(0).RotationInterp) * glm::scale(JointTransforms.at(0).ScaleInterp));
+        boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
+    } else {
+
+        glm::vec3 finalPosInterp;
+        glm::quat finalRotInterp;
+        glm::vec3 finalScaleInterp;
+        float totalWeight = 0;
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            totalWeight += jointTransform.Weight;
+        }
+
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            if (jointTransform.Weight == 1.0f) {
+                finalPosInterp = jointTransform.PositionInterp;
+                finalRotInterp = jointTransform.RotationInterp;
+                finalScaleInterp = jointTransform.ScaleInterp;
+                break;
+            } else {
+                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
+                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
+                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
+            }
+
+        }
+
+        boneMatrix = parentMatrix *(glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp));
+        boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
+    }
+
+
+
+    for (auto &child : bone->Children) {
+        AccumulateBoneTransforms(noRootMotion, animations, boneMatrices, child, boneMatrix);
+    }
+}
+
+void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, std::map<int, glm::mat4>& boneMatrices, const Bone* bone, glm::mat4 parentMatrix)
 {
     glm::mat4 boneMatrix;
 
@@ -105,6 +241,7 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<Animation
 
 
                 if (progress > 1.0f || progress < 0.0f) {
+                    LOG_INFO("Progress: %f", progress);
                     progress = glm::clamp(progress, 0.0f, 1.0f);
                 }
                 Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
@@ -147,12 +284,10 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<Animation
                 boneMatrix = parentMatrix  *((glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix));
 
             }
-            m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
-            m_BoneTransforms[bone->ID] = boneMatrix;
+            boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
         } else {
             boneMatrix = offset * glm::inverse(bone->OffsetMatrix);
-            m_BoneLocalTransforms[bone->ID] = parentMatrix;
-            m_BoneTransforms[bone->ID] = boneMatrix;
+            boneMatrices[bone->ID] = parentMatrix;
         }
     } else {
 
@@ -181,140 +316,18 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<Animation
         }
 
 
+
         if (offset != glm::mat4(1)) {
             boneMatrix = parentMatrix * ((glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) + offset);
         } else {
             boneMatrix = parentMatrix * (glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp));
         }
 
-        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
-        m_BoneTransforms[bone->ID] = boneMatrix;
+        boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
     }
 
     for (auto &child : bone->Children) {
-        AccumulateBoneTransforms(noRootMotion, animations, animationOffset, child, boneMatrix);
-    }
-}
-
-void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, const Bone* bone, glm::mat4 parentMatrix)
-{
-    glm::mat4 boneMatrix;
-    std::vector<JointFrameTransform> JointTransforms;
-
-    for (const AnimationData animationData : animations) {
-        const Animation* animation = animationData.animation;
-        const float time = animationData.time;
-
-        JointFrameTransform jointTransform;
-        jointTransform.Weight = animationData.weight;;
-
-        if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
-            std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
-
-            Animation::Keyframe currentFrame;
-            Animation::Keyframe nextFrame;
-
-            if (boneKeyFrames.size() > 1) { // 2+ keyframes for the current bone
-                for (int index = boneKeyFrames.size()-1; index >= 0; index--) { // find the bone keyframes that surrounds the current frame
-                    if (time >= boneKeyFrames.at(index).Time) {
-                        currentFrame = boneKeyFrames.at(index);
-                        nextFrame = boneKeyFrames.at((index + 1) % boneKeyFrames.size());
-                        break;
-                    }
-                }
-
-                float progress;
-
-                if (nextFrame.Index == 0) {
-                    nextFrame = currentFrame;
-                    progress = (time - currentFrame.Time) / (animation->Duration - currentFrame.Time);
-                } else {
-                    progress = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
-
-                }
-
-                if (progress > 1.0f || progress < 0.0f) {
-                    progress = glm::clamp(progress, 0.0f, 1.0f);
-                }
-                Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
-                Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
-
-                jointTransform.PositionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
-                jointTransform.RotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
-                jointTransform.ScaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
-
-                // Flag for no root motion
-                if (bone == RootBone && noRootMotion) {
-                    jointTransform.PositionInterp.x = 0;
-                    jointTransform.PositionInterp.z = 0;
-                }
-
-                JointTransforms.push_back(jointTransform);
-
-            } else { // 1 keyframes for the current bone
-                currentFrame = boneKeyFrames.at(0);
-                jointTransform.PositionInterp = currentFrame.BoneProperties.Position;
-                jointTransform.RotationInterp = currentFrame.BoneProperties.Rotation;
-                jointTransform.ScaleInterp = currentFrame.BoneProperties.Scale;
-                JointTransforms.push_back(jointTransform);
-
-            }
-        } else { // 0 keyframes for the current bone
-
-        }
-
-    }
-
-    if (JointTransforms.size() <= 0) {
-        if (bone->Parent) {
-            boneMatrix = parentMatrix * glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix;
-            m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
-            m_BoneTransforms[bone->ID] = boneMatrix;
-        } else {
-            boneMatrix = glm::inverse(bone->OffsetMatrix);
-            m_BoneLocalTransforms[bone->ID] = parentMatrix;
-            m_BoneTransforms[bone->ID] = boneMatrix;
-        }
-    } else if (JointTransforms.size() == 1) {
-        boneMatrix = parentMatrix *(glm::translate(JointTransforms.at(0).PositionInterp) * glm::toMat4(JointTransforms.at(0).RotationInterp) * glm::scale(JointTransforms.at(0).ScaleInterp));
-        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
-        m_BoneTransforms[bone->ID] = boneMatrix;
-    } else {
-
-        glm::vec3 finalPosInterp;
-        glm::quat finalRotInterp;
-        glm::vec3 finalScaleInterp;
-        float totalWeight = 0;
-
-        for (JointFrameTransform jointTransform : JointTransforms) {
-            totalWeight += jointTransform.Weight;
-        }
-
-
-        for (JointFrameTransform jointTransform : JointTransforms) {
-            if (jointTransform.Weight == 1.0f) {
-                finalPosInterp = jointTransform.PositionInterp;
-                finalRotInterp = jointTransform.RotationInterp;
-                finalScaleInterp = jointTransform.ScaleInterp;
-                break;
-            } else {
-                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
-                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
-                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
-            }
-
-        }
-
-        boneMatrix = parentMatrix *(glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp));
-
-        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
-        m_BoneTransforms[bone->ID] = boneMatrix;
-    }
-
-
-
-    for (auto &child : bone->Children) {
-        AccumulateBoneTransforms(noRootMotion, animations, child, boneMatrix);
+        AccumulateBoneTransforms(noRootMotion, animations, animationOffset, boneMatrices, child, boneMatrix);
     }
 }
 
@@ -352,9 +365,8 @@ glm::mat4 Skeleton::GetOffsetTransform(const Bone* bone, AnimationOffset animati
 
             }
 
-            if (progress > 1.0f || progress < 0.0f) {
-                progress = glm::clamp(progress, 0.0f, 1.0f);
-            }
+            progress = glm::clamp(progress, 0.0f, 1.0f);
+            
             Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
             Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
 
@@ -436,6 +448,249 @@ glm::mat4 Skeleton::GetBoneTransform(const Bone* bone, const Animation* animatio
     }
 }
 
+
+glm::mat4 Skeleton::GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, AnimationOffset animationOffset, glm::mat4 childMatrix)
+{
+    glm::mat4 boneMatrix;
+
+    std::vector<JointFrameTransform> JointTransforms;
+
+    for (const AnimationData animationData : animations) {
+        const Animation* animation = animationData.animation;
+        const float time = animationData.time;
+
+        JointFrameTransform jointTransform;
+        jointTransform.Weight = animationData.weight;;
+
+        if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
+            std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
+
+            Animation::Keyframe currentFrame;
+            Animation::Keyframe nextFrame;
+
+            if (boneKeyFrames.size() > 1) { // 2+ keyframes for the current bone
+                for (int index = boneKeyFrames.size()-1; index >= 0; index--) { // find the bone keyframes that surrounds the current frame
+                    if (time >= boneKeyFrames.at(index).Time) {
+                        currentFrame = boneKeyFrames.at(index);
+                        nextFrame = boneKeyFrames.at((index + 1) % boneKeyFrames.size());
+                        break;
+                    }
+                }
+
+                float progress;
+
+                if (nextFrame.Index == 0) {
+                    nextFrame = currentFrame;
+                    progress = (time - currentFrame.Time) / (animation->Duration - currentFrame.Time);
+                } else {
+                    progress = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+
+                }
+
+
+                if (progress > 1.0f || progress < 0.0f) {
+                    LOG_INFO("Progress: %f", progress);
+                    progress = glm::clamp(progress, 0.0f, 1.0f);
+                }
+                Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
+                Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
+
+                jointTransform.PositionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+                jointTransform.RotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+                jointTransform.ScaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+                // Flag for no root motion
+                if (bone == RootBone && noRootMotion) {
+                    jointTransform.PositionInterp.x = 0;
+                    jointTransform.PositionInterp.z = 0;
+                }
+
+                JointTransforms.push_back(jointTransform);
+
+            } else { // 1 keyframes for the current bone
+                currentFrame = boneKeyFrames.at(0);
+                jointTransform.PositionInterp = currentFrame.BoneProperties.Position;
+                jointTransform.RotationInterp = currentFrame.BoneProperties.Rotation;
+                jointTransform.ScaleInterp = currentFrame.BoneProperties.Scale;
+                JointTransforms.push_back(jointTransform);
+
+            }
+        } else { // 0 keyframes for the current bone
+
+        }
+
+    }
+
+
+    glm::mat4 offset = GetOffsetTransform(bone, animationOffset);
+
+    if (JointTransforms.size() == 0) {
+        if (bone->Parent) {
+            if (offset != glm::mat4(1)) {
+                boneMatrix = offset * childMatrix;// *((glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix));
+            } else {
+                boneMatrix = ((glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix)) * childMatrix;
+            }
+        } else {
+            boneMatrix = offset * glm::inverse(bone->OffsetMatrix);
+        }
+    } else {
+
+        glm::vec3 finalPosInterp;
+        glm::quat finalRotInterp;
+        glm::vec3 finalScaleInterp;
+        float totalWeight = 0;
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            totalWeight += jointTransform.Weight;
+        }
+
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            if (jointTransform.Weight == 1.0f) {
+                finalPosInterp = jointTransform.PositionInterp;
+                finalRotInterp = jointTransform.RotationInterp;
+                finalScaleInterp = jointTransform.ScaleInterp;
+                break;
+            } else {
+                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
+                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
+                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
+            }
+
+        }
+
+        if (offset != glm::mat4(1)) {
+            boneMatrix = ((glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) + offset) * childMatrix;
+        } else {
+            boneMatrix = (glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) * childMatrix;
+        }
+    }
+
+    if (bone->Parent != nullptr) {
+        return GetBoneTransform(noRootMotion, bone->Parent, animations, animationOffset, boneMatrix);
+    } else {
+        return boneMatrix;
+    }
+}
+
+
+glm::mat4 Skeleton::GetBoneTransform(bool noRootMotion, const Bone* bone, std::vector<AnimationData> animations, glm::mat4 childMatrix)
+{
+    glm::mat4 boneMatrix;
+    std::vector<JointFrameTransform> JointTransforms;
+
+    for (const AnimationData animationData : animations) {
+        const Animation* animation = animationData.animation;
+        const float time = animationData.time;
+
+        JointFrameTransform jointTransform;
+        jointTransform.Weight = animationData.weight;;
+
+        if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
+            std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
+
+            Animation::Keyframe currentFrame;
+            Animation::Keyframe nextFrame;
+
+            if (boneKeyFrames.size() > 1) { // 2+ keyframes for the current bone
+                for (int index = boneKeyFrames.size()-1; index >= 0; index--) { // find the bone keyframes that surrounds the current frame
+                    if (time >= boneKeyFrames.at(index).Time) {
+                        currentFrame = boneKeyFrames.at(index);
+                        nextFrame = boneKeyFrames.at((index + 1) % boneKeyFrames.size());
+                        break;
+                    }
+                }
+
+                float progress;
+
+                if (nextFrame.Index == 0) {
+                    nextFrame = currentFrame;
+                    progress = (time - currentFrame.Time) / (animation->Duration - currentFrame.Time);
+                } else {
+                    progress = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+
+                }
+
+
+                if (progress > 1.0f || progress < 0.0f) {
+                    LOG_INFO("Progress: %f", progress);
+                    progress = glm::clamp(progress, 0.0f, 1.0f);
+                }
+                Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
+                Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
+
+                jointTransform.PositionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+                jointTransform.RotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+                jointTransform.ScaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+                // Flag for no root motion
+                if (bone == RootBone && noRootMotion) {
+                    jointTransform.PositionInterp.x = 0;
+                    jointTransform.PositionInterp.z = 0;
+                }
+
+                JointTransforms.push_back(jointTransform);
+
+            } else { // 1 keyframes for the current bone
+                currentFrame = boneKeyFrames.at(0);
+                jointTransform.PositionInterp = currentFrame.BoneProperties.Position;
+                jointTransform.RotationInterp = currentFrame.BoneProperties.Rotation;
+                jointTransform.ScaleInterp = currentFrame.BoneProperties.Scale;
+                JointTransforms.push_back(jointTransform);
+
+            }
+        } else { // 0 keyframes for the current bone
+
+        }
+
+    }
+
+    if (JointTransforms.size() <= 0) {
+        if (bone->Parent) {
+            boneMatrix = glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix * childMatrix;
+        } else {
+            boneMatrix = glm::inverse(bone->OffsetMatrix) * childMatrix;
+        }
+    } else if (JointTransforms.size() == 1) {
+        boneMatrix = (glm::translate(JointTransforms.at(0).PositionInterp) * glm::toMat4(JointTransforms.at(0).RotationInterp) * glm::scale(JointTransforms.at(0).ScaleInterp)) * childMatrix;
+    } else {
+
+        glm::vec3 finalPosInterp;
+        glm::quat finalRotInterp;
+        glm::vec3 finalScaleInterp;
+        float totalWeight = 0;
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            totalWeight += jointTransform.Weight;
+        }
+
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            if (jointTransform.Weight == 1.0f) {
+                finalPosInterp = jointTransform.PositionInterp;
+                finalRotInterp = jointTransform.RotationInterp;
+                finalScaleInterp = jointTransform.ScaleInterp;
+                break;
+            } else {
+                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
+                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
+                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
+            }
+        }
+
+        boneMatrix = (glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) * childMatrix;
+    }
+
+
+
+    if (bone->Parent != nullptr) {
+        return GetBoneTransform(noRootMotion, bone->Parent, animations, boneMatrix);
+    } else {
+        return boneMatrix;
+    }
+}
+
 int Skeleton::GetBoneID(std::string name)
 {
 	if (m_BonesByName.find(name) == m_BonesByName.end()) {

src/Engine/Rendering/Texture.cpp

@@ -2,21 +2,25 @@
 
 Texture::Texture(std::string path)
 {
-    PNG image(path);
+    PNG* img = ResourceManager::Load<PNG, true>(path); //TODO: Make this threaded. Catch exeptions in all other load places.
 
-    if (image.Width == 0 && image.Height == 0 || image.Format == Image::ImageFormat::Unknown) {
-        image = PNG("Textures/Core/ErrorTexture.png");
-        if (image.Width == 0 && image.Height == 0 || image.Format == Image::ImageFormat::Unknown) {
-            LOG_ERROR("Couldn't even load the error texture. This is a dark day indeed.");
-            return;
-        }
-    }
+    //PNG image(path);
 
-    this->Width = image.Width;
-    this->Height = image.Height;
+    //if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
+    //    //image = PNG("Textures/Core/ErrorTexture.png");
+    //    //return; // Temporary fix to remove crash
+
+    //    if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
+    //        LOG_ERROR("Couldn't even load the error texture. This is a dark day indeed.");
+    //        return;
+    //    }
+    //}
+
+    this->Width = img->Width;
+    this->Height = img->Height;
 
     GLint format;
-    switch (image.Format) {
+    switch (img->Format) {
     case Image::ImageFormat::RGB:
         format = GL_RGB;
         break;
@@ -29,7 +33,7 @@ Texture::Texture(std::string path)
     glGenTextures(1, &m_Texture);
     glBindTexture(GL_TEXTURE_2D, m_Texture);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glTexImage2D(GL_TEXTURE_2D, 0, format, image.Width, image.Height, 0, format, GL_UNSIGNED_BYTE, image.Data);
+    glTexImage2D(GL_TEXTURE_2D, 0, format, img->Width, img->Height, 0, format, GL_UNSIGNED_BYTE, img->Data);
 	glGenerateMipmap(GL_TEXTURE_2D);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

src/Engine/Rendering/Util/CommonFunctions.cpp

@@ -1,2 +1,19 @@
 #include "Rendering/Util/CommonFunctions.h"
 
+Texture* CommonFunctions::LoadTexture(std::string path, bool threaded)
+{
+    Texture* img;
+    try {
+        if(threaded) {
+            img = ResourceManager::Load<Texture, true>(path);
+        } else {
+            img = ResourceManager::Load<Texture, false>(path);
+        }
+    } catch (const Resource::StillLoadingException&) {
+        img = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
+    } catch (const std::exception&) {
+        img = nullptr;
+    }
+
+    return img;
+}

src/Game/CMakeLists.txt

@@ -16,6 +16,12 @@ file(GLOB SOURCE_FILES_Systems
 )
 source_group(Systems FILES ${SOURCE_FILES_Systems})
 
+file(GLOB SOURCE_FILES_Systems_Weapon
+    "${INCLUDE_PATH}/Systems/Weapon/*.h"
+    "Systems/Weapon/*.cpp"
+)
+source_group(Systems\\Weapon FILES ${SOURCE_FILES_Systems_Weapon})
+
 file(GLOB SOURCE_FILES_Events
 	"${INCLUDE_PATH}/Events/*.h"
 	"Events/*.cpp"
@@ -31,6 +37,7 @@ set(SOURCE_FILES
     ${SOURCE_FILES}
     "Game.cpp"
     ${SOURCE_FILES_Systems}
+    ${SOURCE_FILES_Systems_Weapon}
     ${SOURCE_FILES_Events}
 	${SOURCE_FILES_Network}
 )

src/Game/Game.cpp

@@ -12,12 +12,16 @@
 #include "Systems/PlayerDeathSystem.h"
 #include "Core/EntityFileWriter.h"
 #include "Game/Systems/CapturePointSystem.h"
+#include "Game/Systems/CapturePointHUDSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"
-#include "Game/Systems/WeaponSystem.h"
+#include "Game/Systems/AmmoPickupSystem.h"
+#include "Game/Systems/DamageIndicatorSystem.h"
+#include "Game/Systems/Weapon/WeaponSystem.h"
 #include "Rendering/AnimationSystem.h"
 #include "Game/Systems/PlayerHUDSystem.h"
 #include "Rendering/BoneAttachmentSystem.h"
 #include "Game/Systems/LifetimeSystem.h"
+#include "../Engine/Core/UniformScaleSystem.h"
 #include "Rendering/AnimationSystem.h"
 #include "Network/MultiplayerSnapshotFilter.h"
 
@@ -30,6 +34,7 @@ Game::Game(int argc, char* argv[])
     ResourceManager::RegisterType<Model>("Model");
     ResourceManager::RegisterType<RawModel>("RawModel");
     ResourceManager::RegisterType<Texture>("Texture");
+    ResourceManager::RegisterType<PNG>("Png");
     ResourceManager::RegisterType<ShaderProgram>("ShaderProgram");
     ResourceManager::RegisterType<EntityFile>("EntityFile");
     ResourceManager::RegisterType<Font>("FontFile");
@@ -38,6 +43,7 @@ Game::Game(int argc, char* argv[])
     ResourceManager::UseThreading = m_Config->Get<bool>("Multithreading.ResourceLoading", true);
     DisableMemoryPool::Value = m_Config->Get<bool>("Debug.DisableMemoryPool", false);
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
+    PlayerSpawnSystem::SetRespawnTime(m_Config->Get<float>("Debug.RespawnTime", 15.0f));
 
     // Create the core event broker
     m_EventBroker = new EventBroker();
@@ -114,17 +120,21 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<CapturePointHUDSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PickupSpawnSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<AmmoPickupSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<DamageIndicatorSystem>(updateOrderLevel);
     // Populate Octree with collidables
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
     m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerHUDSystem>(updateOrderLevel);
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;

src/Game/Systems/AmmoPickupSystem.cpp

@@ -0,0 +1,78 @@
+#include "Systems/AmmoPickupSystem.h"
+
+AmmoPickupSystem::AmmoPickupSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &AmmoPickupSystem::OnTriggerTouch);
+}
+
+void AmmoPickupSystem::Update(double dt)
+{
+    for (auto it = m_ETriggerTouchVector.begin(); it != m_ETriggerTouchVector.end(); ++it)
+    {
+        auto& ammoPickupPosition = *it;
+        //set the double timer value (value 3)
+        ammoPickupPosition.DecreaseThisRespawnTimer -= dt;
+        if (ammoPickupPosition.DecreaseThisRespawnTimer < 0.0) {
+            //spawn and delete the vector item
+            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/AmmoPickup.xml");
+            EntityFileParser parser(entityFile);
+            EntityID ammoPickupID = parser.MergeEntities(m_World);
+
+            //let the world know a pickup has spawned (graphics effects, etc)
+            Events::PickupSpawned ePickupSpawned;
+            ePickupSpawned.Pickup = EntityWrapper(m_World, ammoPickupID);
+            m_EventBroker->Publish(ePickupSpawned);
+
+            //set values from the old entity to the new entity
+            auto& newAmmoPickupEntity = EntityWrapper(m_World, ammoPickupID);
+            newAmmoPickupEntity["Transform"]["Position"] = ammoPickupPosition.Pos;
+            newAmmoPickupEntity["AmmoPickup"]["AmmoGain"] = ammoPickupPosition.AmmoGain;
+            newAmmoPickupEntity["AmmoPickup"]["RespawnTimer"] = ammoPickupPosition.RespawnTimer;
+
+            //erase the current element (AmmoPickupPosition)
+            m_ETriggerTouchVector.erase(it);
+            break;
+        }
+    }
+}
+
+
+bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
+{
+    if (e.Entity != LocalPlayer) {
+        return false;
+    }
+    //TODO: add other weapontypes
+    if (!e.Entity.HasComponent("AssaultWeapon")) {
+        return false;
+    }
+    if (!e.Trigger.HasComponent("AmmoPickup")) {
+        return false;
+    }
+    int maxWeaponAmmo = (int)e.Entity["AssaultWeapon"]["MaxAmmo"];
+    int& currentAmmo = (int)e.Entity["AssaultWeapon"]["Ammo"];
+
+    int ammoGiven = 0.01*(double)e.Trigger["AmmoPickup"]["AmmoGain"] * maxWeaponAmmo;
+    //cant pick up ammopacks if you are already at MaxAmmo
+    if (currentAmmo >= maxWeaponAmmo) {
+        return false;
+    }
+
+    //personEntered = e.Entity, thingEntered = e.Trigger
+    Events::AmmoPickup ePlayerAmmoPickup;
+    ePlayerAmmoPickup.AmmoGain = ammoGiven;
+    ePlayerAmmoPickup.Player = e.Entity;
+    m_EventBroker->Publish(ePlayerAmmoPickup);
+    //immediately give the player the ammo
+    currentAmmo = std::min(currentAmmo + ammoGiven, maxWeaponAmmo);
+
+    //copy position, ammogain, 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 ammoPickup
+    m_ETriggerTouchVector.push_back({ (glm::vec3)e.Trigger["Transform"]["Position"] ,e.Trigger["AmmoPickup"]["AmmoGain"],
+        e.Trigger["AmmoPickup"]["RespawnTimer"],e.Trigger["AmmoPickup"]["RespawnTimer"] });
+
+    //delete the ammopickup
+    m_World->DeleteEntity(e.Trigger.ID);
+    return true;
+}

src/Game/Systems/CapturePointHUDSystem.cpp

@@ -0,0 +1,55 @@
+#include "Systems/CapturePointHUDSystem.h"
+
+CapturePointHUDSystem::CapturePointHUDSystem(SystemParams params)
+    : System(params)
+    , ImpureSystem()
+{
+}
+
+
+void CapturePointHUDSystem::Update(double dt)
+{
+    bool LoadCheck = true;
+    int redTeam;
+    int blueTeam;
+    int spectatorTeam;
+
+    auto CapturePointHUDElements = m_World->GetComponents("CapturePointHUD");
+    auto CapturePoints = m_World->GetComponents("CapturePoint");
+    if (CapturePointHUDElements == nullptr) {
+        return;
+    }
+
+    for (auto& cCapturePointHUD : *CapturePointHUDElements) {
+        int HUD_ID = cCapturePointHUD["CapturePointNumber"];
+        EntityWrapper entityHUD = EntityWrapper(m_World, cCapturePointHUD.EntityID);
+        EntityWrapper entityHUDparent = entityHUD.Parent();
+
+        for (auto& cCapturePoint : *CapturePoints) {
+            EntityWrapper entityCP = EntityWrapper(m_World, cCapturePoint.EntityID);
+
+            //Check if the HUD corresponds to the Capture Point Number
+            if (HUD_ID == (int)entityCP["CapturePoint"]["CapturePointNumber"]) {
+                ComponentWrapper& teamComponent = entityCP["Team"];
+                if (LoadCheck) {
+                    redTeam = (int)teamComponent["Team"].Enum("Red");
+                    blueTeam = (int)teamComponent["Team"].Enum("Blue");
+                    spectatorTeam = (int)teamComponent["Team"].Enum("Spectator");
+                    LoadCheck = false;
+                }
+                //Color hud with team color
+                auto capturePointTeam = (int)teamComponent["Team"];
+                entityHUDparent["Sprite"]["Color"] = capturePointTeam == blueTeam ? glm::vec4(0, 0.2f, 1, 0.7f) : capturePointTeam == redTeam ? glm::vec4(1, 0.0f, 0, 0.7f) : glm::vec4(1, 1, 1, 0.3f);
+
+                //Progress is scaled with time
+                double currentCaptureTime = (double)entityCP["CapturePoint"]["CaptureTimer"];
+                double progress = glm::abs(currentCaptureTime)/15.0;
+                int currentCapturingTeam = currentCaptureTime > 0 ? redTeam : currentCaptureTime < 0 ? blueTeam : spectatorTeam;
+                ((glm::vec3&)entityHUD["Transform"]["Orientation"]).z = currentCapturingTeam == redTeam ? glm::half_pi<float>()+glm::pi<float>() : glm::half_pi<float>();
+                glm::vec4 fillColor = currentCapturingTeam == redTeam ? glm::vec4(1, 0.f, 0, 0.7f) : glm::vec4(0, 0.2f, 1, 0.7f);
+                entityHUD["Fill"]["Color"] = fillColor;
+                entityHUD["Fill"]["Percentage"] = progress;
+            }
+        }
+    }
+}

src/Game/Systems/CapturePointSystem.cpp

@@ -32,6 +32,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     const int redTeam = (int)teamComponent["Team"].Enum("Red");
     const int blueTeam = (int)teamComponent["Team"].Enum("Blue");
     const int spectatorTeam = (int)teamComponent["Team"].Enum("Spectator");
+    const double captureTimeToTakeOver = (double)cCapturePoint["CapturePointMaxTimer"];
 
     int homePointForTeam = (int)cCapturePoint["HomePointForTeam"];
     if (m_NumberOfCapturePoints == 0 && capturePointNumber != 0 && (homePointForTeam == redTeam || homePointForTeam == blueTeam)) {
@@ -57,7 +58,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     int blueTeamPlayersStandingInside = 0;
     if (capturePointEntity.HasComponent("Model")) {
         //Now sets team color to the capturepoint, or white if it is uncaptured.
-        capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.2f, 1, 0.3) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 0.3) : glm::vec4(1, 1, 1, 0.3);
+        capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.0f, 1, 0.3) : ownedBy == redTeam ? glm::vec4(1, 0.0f, 0, 0.3) : glm::vec4(1, 1, 1, 0.3);
     }
 
     //calculate next possible capturePoint for both teams
@@ -98,20 +99,16 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             ComponentWrapper& capturePoint = m_CapturePointNumberToEntityMap[i]["CapturePoint"];
             if ((int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Red"] &&
                 (int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Blue"]) {
-                capturePoint["CaptureTimer"] = 0.0;
+                //RED = +, BLUE = -, NONE
+                auto teamOwners = (int)m_CapturePointNumberToEntityMap[i]["Team"]["Team"];
+                if (teamOwners == redTeam || teamOwners == blueTeam) {
+                    capturePoint["CaptureTimer"] = teamOwners == blueTeam ? -captureTimeToTakeOver : captureTimeToTakeOver;
+                }
             }
         }
         m_ResetTimers = false;
     }
 
-    //colorize next possible capturepoint
-    if (nextPossibleCapturePoint["Red"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(1, 1, 0, 0.3);
-    }
-    if (nextPossibleCapturePoint["Blue"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(0, 1, 1, 0.3);
-    }
-
     //check how many players are standing inside and are healthy
     for (size_t i = m_ETriggerTouchVector.size(); i > 0; i--)
     {
@@ -170,9 +167,6 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
         //B. at most one of the teams have players inside
         //if capturePoint is not owned by the take-over team, just modify the CaptureTimer accordingly
         if (ownedBy != currentTeam && canCapture) {
-            if (abs((double)cCapturePoint["CaptureTimer"]) < 0.001f) {
-                LOG_DEBUG("Point is being captured by team %i", currentTeam);   //Remove when we tested sufficiently.
-            }
             cCapturePoint["CaptureTimer"] = (double)cCapturePoint["CaptureTimer"] + timerDeltaChange;
         }
         //if capturePoint is owned by the team, and the other team has been trying to take it, then increase/decrease the timer towards 0.0
@@ -180,12 +174,11 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
             (ownedBy == currentTeam && currentTeam == blueTeam && (double)cCapturePoint["CaptureTimer"] > 0.0)) {
             cCapturePoint["CaptureTimer"] = (double)cCapturePoint["CaptureTimer"] + timerDeltaChange;
         }
-        //check if captureTimer > m_CaptureTimeToTakeOver and if so change owner and publish the eCaptured event
-        if (abs((double)cCapturePoint["CaptureTimer"]) > abs(m_CaptureTimeToTakeOver) && canCapture) {
+        //check if captureTimer > captureTimeToTakeOver and if so change owner and publish the eCaptured event
+        if (abs((double)cCapturePoint["CaptureTimer"]) > captureTimeToTakeOver && canCapture) {
             teamComponent["Team"] = currentTeam;
-            cCapturePoint["CaptureTimer"] = 0.0;
+            cCapturePoint["CaptureTimer"] = glm::sign((double)cCapturePoint["CaptureTimer"])*captureTimeToTakeOver;
             //publish Captured event
-            LOG_DEBUG("Point is captured by team %i!", currentTeam);    //Remove when we tested sufficiently.
             Events::Captured e;
             e.CapturePointID = cCapturePoint.EntityID;
             e.TeamNumberThatCapturedCapturePoint = currentTeam;

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -0,0 +1,73 @@
+#include "Systems/DamageIndicatorSystem.h"
+
+DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
+    : System(params)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &DamageIndicatorSystem::OnPlayerDamage);
+    //current camera
+    EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &DamageIndicatorSystem::OnSetCamera);
+
+    //load texture to cache
+    auto texture = CommonFunctions::LoadTexture("Textures/DamageIndicator.png", false);
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
+}
+
+bool DamageIndicatorSystem::OnPlayerDamage(Events::PlayerDamage& e)
+{
+    if (m_CurrentCamera == EntityID_Invalid) {
+        return false;
+    }
+
+    if (e.Victim != LocalPlayer) {
+        return false;
+    }
+
+    if (!e.Inflictor.Valid() || !e.Victim.Valid()) {
+        return false;
+    }
+
+    //grab players direction
+    auto playerOrientation = glm::quat((glm::vec3)e.Victim["Transform"]["Orientation"]);
+
+    //get the position vectors, but ignore the y-height
+    auto enemyPosition = (glm::vec3)e.Inflictor["Transform"]["Position"];
+    auto playerPosition = (glm::vec3)e.Victim["Transform"]["Position"];
+    enemyPosition.y = 0.0f;
+    playerPosition.y = 0.0f;
+
+    //calculate the enemy to player vector
+    auto enemyPlayerVector = glm::normalize(playerPosition - enemyPosition);
+
+    //get angle from players current rotation, this angle is how much you rotate around the y-axis
+    auto playerAngle = glm::angle(playerOrientation);
+    auto playerRotationVector = glm::normalize(glm::rotateY(glm::vec3(0, 0, 1), playerAngle));
+
+    //dot product of players direction-vector and enemys-to-playervector will give the cos of the angle between the vectors
+    auto playerRotationDot = glm::dot(playerRotationVector, enemyPlayerVector);
+    //to get the angle between the vectors just do cos-inverse
+    auto angleBetweenVectors = glm::acos(playerRotationDot);
+
+    //rotate the direction-vector 90 degrees to get the players side-vector
+    auto playerSideVector = glm::normalize(glm::rotateY(glm::vec3(0, 0, 1), playerAngle + 1.57f));
+    //dot of sidevector positive = enemy is on the right side, dot sidevector negative = left side
+    auto playerSideVectorDot = glm::dot(playerSideVector, enemyPlayerVector);
+    if (playerSideVectorDot < 0) {
+        angleBetweenVectors = -angleBetweenVectors;
+    }
+
+    //load & set the "2d" sprite
+    auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/DamageIndicator.xml");
+    EntityFileParser parser(entityFile);
+    EntityID spriteID = parser.MergeEntities(m_World);
+    m_World->SetParent(spriteID, m_CurrentCamera);
+    auto spriteWrapper = EntityWrapper(m_World, spriteID);
+    //simply set the rotation z-wise to the angleBetweenVectors
+    spriteWrapper["Transform"]["Orientation"] = glm::vec3(0, 0, angleBetweenVectors);
+
+    return true;
+}
+
+bool DamageIndicatorSystem::OnSetCamera(const Events::SetCamera& e) {
+    m_CurrentCamera = e.CameraEntity.ID;
+    return true;
+}

src/Game/Systems/HealthSystem.cpp

@@ -7,6 +7,7 @@ HealthSystem::HealthSystem(SystemParams params)
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &HealthSystem::OnPlayerDamaged);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerHealthPickup, &HealthSystem::OnPlayerHealthPickup);
+    EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &HealthSystem::OnInputCommand);
 }
 
 void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
@@ -15,13 +16,13 @@ void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& comp
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
 {
-    ComponentWrapper cHealth = e.Player["Health"];
+    ComponentWrapper cHealth = e.Victim["Health"];
     double& health = cHealth["Health"];
     health -= e.Damage;
 
     if (health <= 0.0) {
         Events::PlayerDeath ePlayerDeath;
-        ePlayerDeath.Player = e.Player;
+        ePlayerDeath.Player = e.Victim;
         m_EventBroker->Publish(ePlayerDeath);
         //Note: we will delete the entity in PlayerDeathSystem
     }
@@ -29,6 +30,17 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     return true;
 }
 
+bool HealthSystem::OnInputCommand(Events::InputCommand& e)
+{
+    if (e.Command == "TakeDamage" && e.Value > 0 && LocalPlayer.Valid()) {
+        Events::PlayerDamage ev;
+        ev.Victim = LocalPlayer;
+        ev.Damage = e.Value;
+        m_EventBroker->Publish(ev);
+    }
+    return true;
+}
+
 bool HealthSystem::OnPlayerHealthPickup(Events::PlayerHealthPickup& e)
 {
     ComponentWrapper cHealth = e.Player["Health"];

src/Game/Systems/PlayerDeathSystem.cpp

@@ -34,14 +34,23 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
 
     //components that we need from player
     auto playerCamera = player.FirstChildByName("Camera");
-    auto playerEntityModel = player.FirstChildByName("PlayerModel")["Model"];
-    auto playerEntityAnimation = player.FirstChildByName("PlayerModel")["Animation"];
+    auto playerModel = player.FirstChildByName("PlayerModel");
+    if (!playerCamera.Valid() || !playerModel.Valid()) {
+        return;
+    }
+    if (!playerModel.HasComponent("Model") || !playerModel.HasComponent("Animation")) {
+        return;
+    }
+    auto playerEntityModel = playerModel["Model"];
+    auto playerEntityAnimation = 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;
+    deathEffectEW["Animation"]["Speed1"] = 0.0;
+    deathEffectEW["Animation"]["Speed2"] = 0.0;
+    deathEffectEW["Animation"]["Speed3"] = 0.0;
 
     //copy the models position,orientation
     deathEffectEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
@@ -50,8 +59,10 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     //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);
+    if (player == LocalPlayer) {
+        auto cam = deathEffectEW.FirstChildByName("Camera");
+        Events::SetCamera eSetCamera;
+        eSetCamera.CameraEntity = cam;
+        m_EventBroker->Publish(eSetCamera);
+    }
 }

src/Game/Systems/PlayerMovementSystem.cpp

@@ -51,6 +51,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
 
         float playerMovementSpeed = player["Player"]["MovementSpeed"];
         float playerCrouchSpeed = player["Player"]["CrouchSpeed"];
+        glm::vec3& wishDirection = player["Player"]["CurrentWishDirection"];
 
         if (player.HasComponent("Physics")) {
             ComponentWrapper cPhysics = player["Physics"];
@@ -58,7 +59,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
             if (player.HasComponent("DashAbility")) {
                 controller->AssaultDashCheck(dt, ((glm::vec3)cPhysics["Velocity"]).y != 0.0f, player["DashAbility"]["CoolDownMaxTimer"]);
             }
-            glm::vec3 wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
+            wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
             //this makes sure you can only dash in the 4 directions: forw,backw,left,right
             if (controller->AssaultDashDoubleTapped() && controller->Movement().z != 0 && controller->Movement().x != 0) {
                 wishDirection = glm::vec3(controller->Movement().x, 0, 0)* glm::inverse(glm::quat(ori));
@@ -233,7 +234,8 @@ void PlayerMovementSystem::updateVelocity(double dt)
     float speed = glm::length(velocity);
     static float groundFriction = 7.f;
     ImGui::InputFloat("groundFriction", &groundFriction);
-    static float airFriction = 0.f;
+    static float airFriction = 2.f;
+
     ImGui::InputFloat("airFriction", &airFriction);
     float friction = isOnGround ? groundFriction : airFriction;
     if (speed > 0) {

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,20 +1,39 @@
 #include "Systems/PlayerSpawnSystem.h"
 
+//This should be set by the config anyway.
+float PlayerSpawnSystem::m_RespawnTime = 15.0f;
+
 PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params) 
     : System(params)
+    , m_Timer(0.f)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerSpawnSystem::OnPlayerDeath);
     m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
 }
 
 void PlayerSpawnSystem::Update(double dt)
 {
+    //Increase timer.
+    m_Timer += dt;
+    if (m_Timer < m_RespawnTime) {
+        return;
+    }
+    //If respawn time has passed, we spawn all players that have requested to be spawned.
+    m_Timer = 0.f;
+
+    //If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty.
+    if (m_SpawnRequests.size() == 0) {
+        return;
+    }
+
     auto playerSpawns = m_World->GetComponents("PlayerSpawn");
     if (playerSpawns == nullptr) {
         return;
     }
 
+    int numSpawnedPlayers = 0;
     for (auto& req : m_SpawnRequests) {
         for (auto& cPlayerSpawn : *playerSpawns) {
             EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
@@ -40,29 +59,61 @@ void PlayerSpawnSystem::Update(double dt)
             e.Player = player;
             e.Spawner = spawner;
             m_EventBroker->Publish(e);
-
+            ++numSpawnedPlayers;
+            break;
         }
     }
+    if (numSpawnedPlayers != (int)m_SpawnRequests.size()) {
+        LOG_DEBUG("%i players were supposed to be spawned, but %i was spawned.", (int)m_SpawnRequests.size(), numSpawnedPlayers);
+    } else {
+        LOG_DEBUG("%i players were spawned.", numSpawnedPlayers);
+    }
     m_SpawnRequests.clear();
 }
 
-bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
+bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
 {
     if (e.Command != "PickTeam") {
         return false;
     }
 
     // Team picks should be processed ONLY server-side!
-    // Don't make a spawn request if PlayerID is -1, i.e. we're the client.
-    if (e.PlayerID == -1 && m_NetworkEnabled) {
+    // Don't make a spawn request if we're the client.
+    if (!IsServer && m_NetworkEnabled) {
         return false;
     }
 
-    if (e.Value != 0) {
+    if (e.Value == 0) {
+        return false;
+    }
+
+    //TODO: Spectating?
+    //Right now, return if someone picks spectator.
+    //1 signifies spectator here, could not get Playerteam component since it may be invalid or without team comp.
+    if ((ComponentInfo::EnumType)e.Value == 1) {
+        return false;
+    }
+
+    //Check if the player already requested spawn.
+    auto iter = m_SpawnRequests.begin();
+    for (; iter != m_SpawnRequests.end(); ++iter) {
+        if (iter->PlayerID == e.PlayerID) {
+            break;
+        }
+    }
+
+    if (iter != m_SpawnRequests.end()) {
+        //If player is in queue to spawn, then change their team affiliation in the request.
+        iter->Team = (ComponentInfo::EnumType)e.Value;
+    } else if (m_PlayerEntities.count(e.PlayerID) == 0 || !m_PlayerEntities[e.PlayerID].Valid()) {
+        //If player is not in queue to spawn, then create a spawn request, 
+        //but only if they are spectating and/or just connected.
         SpawnRequest req;
         req.PlayerID = e.PlayerID;
         req.Team = (ComponentInfo::EnumType)e.Value;
         m_SpawnRequests.push_back(req);
+    } else {
+        return false;
     }
 
     return true;
@@ -70,25 +121,20 @@ bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
 
 bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
+    // Store the player for future reference
+    m_PlayerEntities[e.PlayerID] = e.Player;
+    m_PlayerIDs[e.Player.ID] = e.PlayerID;
+
     // When a player is actually spawned (since the actual spawning is handled on the server)
     if (!IsClient) {
         return false;
     }
 
-    // Check if a player already exists
-    if (m_PlayerEntities.count(e.PlayerID) != 0) {
-        // TODO: Disallow infinite respawning here
-        if (m_PlayerEntities[e.PlayerID].Valid()) {
-            m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
-        }
-    }
-
-    // Store the player for future reference
-    m_PlayerEntities[e.PlayerID] = e.Player;
 
     // Set the camera to the correct entity
     EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera");
-    if (cameraEntity.Valid()) {
+    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    if (cameraEntity.Valid() && !outOfBodyExperience) {
         Events::SetCamera e;
         e.CameraEntity = cameraEntity;
         m_EventBroker->Publish(e);
@@ -113,4 +159,24 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     }
 
     return true;
-}
+}
+
+bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
+{
+    //Only spawn request if network is disabled or we are server.
+    if (!IsServer && m_NetworkEnabled) {
+        return false;
+    }
+    if (!e.Player.HasComponent("Team")) {
+        return false;
+    }
+    ComponentWrapper cTeam = e.Player["Team"];
+    //A spectator can't die anyway
+    if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Spectator")) {
+        return false;
+    }
+    SpawnRequest req;
+    req.PlayerID = m_PlayerIDs.at(e.Player.ID);
+    req.Team = cTeam["Team"];
+    m_SpawnRequests.push_back(req);
+}

src/Game/Systems/SoundSystem.cpp

@@ -52,12 +52,6 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
             return true;
         }
     }
-    if (e.Command == "TakeDamage" && e.Value > 0) {
-        Events::PlayerDamage ev;
-        ev.Player = LocalPlayer;
-        ev.Damage = 1.0;
-        m_EventBroker->Publish(ev);
-    }
 
     return false;
 }

src/Game/Systems/SpawnerSystem.cpp

@@ -48,10 +48,12 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     EntityFileParser parser(entityFile);
     EntityWrapper spawnedEntity(world, parser.MergeEntities(world, parent.ID));
 
-    // Set its position and orientation to that of the SpawnPoint
-    spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
-    // TODO: Quaternions, bitch
-    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
+    if (spawnPoint != parent) {
+        // Set its position and orientation to that of the SpawnPoint
+        spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
+        // TODO: Quaternions, bitch
+        spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
+    }
 
     return spawnedEntity;
 }

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp

@@ -0,0 +1,341 @@
+#include "Systems/Weapon/AssaultWeaponBehaviour.h"
+
+AssaultWeaponBehaviour::AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper player) 
+    : WeaponBehaviour(systemParams, renderer, collisionOctree, player)
+{
+    m_FirstPersonModel = m_Player.FirstChildByName("Hands");
+    EVENT_SUBSCRIBE_MEMBER(m_EAnimationComplete, &AssaultWeaponBehaviour::OnAnimationComplete);
+}
+
+void AssaultWeaponBehaviour::Fire()
+{
+    m_TimeSinceLastFire = 0.0;
+    m_Firing = true;
+    fireRound();
+}
+
+void AssaultWeaponBehaviour::CeaseFire()
+{
+    m_Firing = false;
+}
+
+void AssaultWeaponBehaviour::Reload()
+{
+    if (m_Reloading) {
+        return;
+    }
+
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int magSize = cAssaultWeapon["MagazineSize"];
+    int ammo = cAssaultWeapon["Ammo"];
+
+    // Don't reload if we're already fully loaded
+    if (magAmmo == magSize) {
+        return;
+    }
+
+    // Don't reload if we're completly out of ammo
+    if (ammo == 0) {
+        return;
+    }
+
+    m_Reloading = true;
+    m_ReloadTimer = cAssaultWeapon["ReloadTime"];
+    playReloadAnimation();
+}
+
+void AssaultWeaponBehaviour::Update(double dt)
+{
+    if (m_Reloading) {
+        m_ReloadTimer -= dt;
+        // Re-enable glow on reload impersonator half-way through the animation
+        if (m_ReloadTimer <= (double)m_Player["AssaultWeapon"]["ReloadTime"] / 2.0) {
+            if (m_ReloadImpersonator.Valid()) {
+                m_ReloadImpersonator["Model"]["GlowMap"] = true;
+            }
+        }
+        if (m_ReloadTimer <= 0) {
+            finishReload();
+        }
+    }
+
+    if (m_Firing && !m_Reloading) {
+        m_TimeSinceLastFire += dt;
+        ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+        if (m_TimeSinceLastFire >= 1.0 / ((double)cAssaultWeapon["RPM"] / 60.0)) {
+            fireRound();
+        }
+    }
+
+    if (!m_Firing && !m_Reloading) {
+        playIdleAnimation();
+    }
+
+    // Disable glow map on weapon if it's out of ammo
+    // Make real first person weapon model visible again
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    if (firstPersonWeaponModel.Valid()) {
+        firstPersonWeaponModel["Model"]["GlowMap"] = hasAmmo();
+    }
+}
+
+bool AssaultWeaponBehaviour::OnAnimationComplete(Events::AnimationComplete& e)
+{
+    if (e.Entity != m_FirstPersonModel) {
+        return false;
+    }
+
+    //if (e.Name == "ShootRifle") {
+    //    if (!m_Firing) {
+    //        playIdleAnimation();
+    //    }
+    //}
+
+    return true;
+}
+
+bool AssaultWeaponBehaviour::hasAmmo()
+{
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    return magAmmo > 0;
+}
+
+void AssaultWeaponBehaviour::fireRound()
+{
+    if (m_Reloading) {
+        return;
+    }
+
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int ammo = cAssaultWeapon["Ammo"];
+
+    // Reload if our magazine is empty
+    if (magAmmo <= 0) {
+        Reload();
+        return;
+    }
+
+    // Fire
+    magAmmo -= 1;
+    spawnTracer();
+    playSound();
+    viewPunch();
+    playShootAnimation();
+    bool hit = shoot(cAssaultWeapon["BaseDamage"]);
+    if (hit) {
+        showHitMarker();
+    }
+
+    m_TimeSinceLastFire = 0.0;
+}
+
+void AssaultWeaponBehaviour::spawnTracer()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    EntityWrapper spawner;
+    if (m_Player == LocalPlayer) {
+        spawner = m_Player.FirstChildByName("WeaponMuzzle");
+    } else {
+        spawner = m_Player.FirstChildByName("ThirdPersonWeaponMuzzle");
+    }
+
+    if (!spawner.Valid()) {
+        return;
+    }
+
+    float distance = traceRayDistance(Transform::AbsolutePosition(spawner), Transform::AbsoluteOrientation(spawner) * glm::vec3(0, 0, -1));
+    EntityWrapper ray = SpawnerSystem::Spawn(spawner);
+    ((glm::vec3&)ray["Transform"]["Scale"]).z = (distance / 100.f);
+}
+
+float AssaultWeaponBehaviour::traceRayDistance(glm::vec3 origin, glm::vec3 direction)
+{
+    // TODO: Cast a ray and size tracer appropriately
+    float distance;
+    glm::vec3 pos;
+    auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
+    if (entity) {
+        return distance;
+    } else {
+        return 100.f;
+    }
+}
+
+void AssaultWeaponBehaviour::playSound()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = m_Player.ID;
+    e.FilePath = "Audio/laser/laser1.wav";
+    m_EventBroker->Publish(e);
+}
+
+void AssaultWeaponBehaviour::viewPunch()
+{
+    EntityWrapper playerCamera = m_Player.FirstChildByName("Camera");
+    if (!playerCamera.Valid()) {
+        return;
+    }
+    float viewPunch = m_Player["AssaultWeapon"]["ViewPunch"];
+    ComponentWrapper cTransform = playerCamera["Transform"];
+    glm::vec3& orientation = cTransform["Orientation"];
+    orientation.x += viewPunch;
+}
+
+void AssaultWeaponBehaviour::finishReload()
+{
+    ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
+    int& magAmmo = cAssaultWeapon["MagazineAmmo"];
+    int magSize = cAssaultWeapon["MagazineSize"];
+    int& ammo = cAssaultWeapon["Ammo"];
+
+    // Throw away rounds in magazine to incentivise ammo sharing
+    int toLoad = glm::min(magSize, ammo);
+    magAmmo = toLoad;
+    ammo -= toLoad;
+
+    // Make real first person weapon model visible again
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    firstPersonWeaponModel["Model"]["Visible"] = true;
+
+    m_Reloading = false;
+}
+
+void AssaultWeaponBehaviour::playShootAnimation()
+{
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    if (cAnimation["AnimationName1"] != "ShootRifle") {
+        cAnimation["AnimationName1"] = "ShootRifle";
+        cAnimation["Weight1"] = 1.0;
+        cAnimation["Time1"] = 0.0;
+        cAnimation["Speed1"] = 1.0;
+        cAnimation["Loop1"] = true;
+    }
+}
+
+void AssaultWeaponBehaviour::playIdleAnimation()
+{
+    if (!m_FirstPersonModel.Valid()) {
+        return;
+    }
+
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    std::string& animationName1 = cAnimation["AnimationName1"];
+    double& animationSpeed1 = cAnimation["Speed1"];
+
+    std::string animationToPlay = "Idle";
+    double speedToSet = 1.0;
+
+    ComponentWrapper cPlayer = m_Player["Player"];
+    glm::vec3 movementDirection = cPlayer["CurrentWishDirection"];
+    if (glm::length2(movementDirection) > 0) {
+        animationToPlay = "Run";
+        ComponentWrapper cPhysics = m_Player["Physics"];
+        speedToSet = glm::length((glm::vec3)cPhysics["Velocity"]) / (float)cPlayer["MovementSpeed"];
+    }
+
+    if (animationName1 != animationToPlay) {
+        cAnimation["AnimationName1"] = animationToPlay;
+        cAnimation["Weight1"] = 1.0;
+        cAnimation["Time1"] = 0.0;
+        cAnimation["Loop1"] = true;
+    }
+
+    if (animationSpeed1 != speedToSet) {
+        cAnimation["Speed1"] = speedToSet;
+    }
+}
+
+void AssaultWeaponBehaviour::playReloadAnimation()
+{
+    // Play animation
+    ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+    cAnimation["AnimationName1"] = "ReloadSwitch";
+    cAnimation["Weight1"] = 1.0;
+    cAnimation["Time1"] = 0.0;
+    cAnimation["Speed1"] = 0.5;
+    cAnimation["Loop1"] = true;
+
+    // Hide weapon model and spawn the exploding version
+    EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
+    EntityWrapper reloadSpawner = m_Player.FirstChildByName("FirstPersonReloadSpawner");
+    m_ReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+    firstPersonWeaponModel["Model"].Copy(m_ReloadImpersonator["Model"]);
+    firstPersonWeaponModel["Model"]["Visible"] = false;
+}
+
+bool AssaultWeaponBehaviour::shoot(double damage)
+{
+    // Only do shooting clientside
+    if (!IsClient) {
+        return false;
+    }
+
+    // Only handle shooting for the local player
+    if (m_Player != LocalPlayer) {
+        return false;
+    }
+
+    // Make sure the player isn't shooting from the grave
+    if (!m_Player.Valid()) {
+        return false;
+    }
+
+    // Screen center, based on current resolution!
+    Rectangle screenResolution = m_Renderer->GetViewportSize();
+    glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
+
+    // Pick middle of screen
+    PickData pickData = m_Renderer->Pick(centerScreen);
+    if (pickData.Entity == EntityID_Invalid) {
+        return false;
+    }
+
+    EntityWrapper victim(m_World, pickData.Entity);
+
+    // Don't let us shoot ourselves in the foot
+    if (victim == LocalPlayer) {
+        return false;
+    }
+
+    // Only care about players being hit
+    if (!victim.HasComponent("Player")) {
+        victim = victim.FirstParentWithComponent("Player");
+    }
+    if (!victim.Valid()) {
+        return false;
+    }
+
+    // Check for friendly fire
+    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)m_Player["Team"]["Team"]) {
+        return false;
+    }
+
+    // Deal damage! 
+    Events::PlayerDamage ePlayerDamage;
+    ePlayerDamage.Inflictor = m_Player;
+    ePlayerDamage.Victim = victim;
+    ePlayerDamage.Damage = damage;
+    m_EventBroker->Publish(ePlayerDamage);
+
+    return true;
+}
+
+void AssaultWeaponBehaviour::showHitMarker()
+{
+    // Show hit marker
+    EntityWrapper hitMarkerSpawner = m_Player.FirstChildByName("HitMarkerSpawner");
+    if (hitMarkerSpawner.Valid()) {
+        SpawnerSystem::Spawn(hitMarkerSpawner, hitMarkerSpawner);
+    }
+}

src/Game/Systems/Weapon/WeaponSystem.cpp

@@ -1,4 +1,4 @@
-#include "Systems/WeaponSystem.h"
+#include "Systems/Weapon/WeaponSystem.h"
 
 WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
     : System(params)
@@ -8,7 +8,6 @@ WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<Enti
     , m_CollisionOctree(collisionOctree)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
-    EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
 }
 
@@ -24,7 +23,8 @@ void WeaponSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPla
     if (it == m_ActiveWeapons.end()) {
         selectWeapon(entity, 1);
     }
-
+    
+    m_EventBroker->Process<WeaponBehaviour>();
     m_ActiveWeapons.at(entity)->Update(dt);
 }
 
@@ -59,6 +59,14 @@ bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
         }
     }
 
+    // Reload
+    if (e.Command == "Reload" && e.Value != 0) {
+        if (m_ActiveWeapons.find(player) != m_ActiveWeapons.end()) {
+            auto weapon = m_ActiveWeapons.at(player);
+            weapon->Reload();
+        }
+    }
+
     return true;
 }
 
@@ -68,7 +76,7 @@ void WeaponSystem::selectWeapon(EntityWrapper player, ComponentInfo::EnumType sl
     if (slot == 1) {
         // TODO: if class...
         if (m_ActiveWeapons.count(player) == 0) {
-            m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_CollisionOctree, player)));
+            m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_Renderer, m_CollisionOctree, player)));
         } else {
             //m_ActiveWeapons.erase(player);
         }
@@ -84,54 +92,5 @@ bool WeaponSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
     // Select primary weapon on player spawn
     // TODO: Select the active one specified by player component
-    return true;
-}
-
-bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
-{
-    if (!eShoot.Player.Valid()) {
-        return false;
-    }
-
-    // Only run further picking code for the local player!
-    if (eShoot.Player != LocalPlayer) {
-        return false;
-    }
-
-    // Screen center, based on current resolution!
-    // TODO: check if player has enough ammo and if weapon has a cooldown or not
-    Rectangle screenResolution = m_Renderer->GetViewportSize();
-    glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
-
-    // TODO: check if player has enough ammo and if weapon has a cooldown or not
-
-    // Pick middle of screen
-    PickData pickData = m_Renderer->Pick(centerScreen);
-    if (pickData.Entity == EntityID_Invalid) {
-        return false;
-    }
-
-    EntityWrapper player(m_World, pickData.Entity);
-
-    // Only care about players being hit
-    if (!player.HasComponent("Player")) {
-        player = player.FirstParentWithComponent("Player");
-    }
-    if (!player.Valid()) {
-        return false;
-    }
-
-    // Check for friendly fire
-    EntityWrapper shooter = eShoot.Player;
-    if ((ComponentInfo::EnumType)player["Team"]["Team"] == (ComponentInfo::EnumType)shooter["Team"]["Team"]) {
-        return false;
-    }
-
-    // TODO: Weapon damage calculations etc
-    Events::PlayerDamage ePlayerDamage;
-    ePlayerDamage.Player = player;
-    ePlayerDamage.Damage = 100;
-    m_EventBroker->Publish(ePlayerDamage);
-
     return true;
 }

src/Tests/HealthSystemTest.cpp

@@ -71,7 +71,7 @@ GameHealthSystemTest::GameHealthSystemTest()
     //damage player with 50
     Events::PlayerDamage e;
     e.Damage = 50.0f;
-    e.Player = EntityWrapper(m_World, player.EntityID);
+    e.Victim = EntityWrapper(m_World, player.EntityID);
     m_EventBroker->Publish(e);
 
     //heal some other player with 40