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

# Conflicts:
#	resources/Schema/Components.xsd

src/Engine/CMakeLists.txt

@@ -3,7 +3,7 @@ project(TacticalZ-Engine)
 find_package(OpenGL REQUIRED)
 find_package(GLEW REQUIRED)
 find_package(GLFW REQUIRED)
-find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono)
+find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono program_options)
 find_package(assimp REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)

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;
         }
@@ -184,7 +186,7 @@ bool RayVsTriangle(const Ray& ray,
     }
     outDistance = dist;
     outUCoord = glm::dot(m, DxE2) * DetInv;
-    outVCoord  = glm::dot(ray.Direction(), MxE1) * DetInv;
+    outVCoord = glm::dot(ray.Direction(), MxE1) * DetInv;
 
     //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
     //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
@@ -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;
 }
@@ -331,7 +335,7 @@ bool rectangleVsTriangle(const glm::vec2& boxMin,
         float push = rightRes < -leftRes ? rightRes : leftRes;
         float absPushSq = abs(push);
         absPushSq *= absPushSq;
-        
+
         if (absPushSq < resolutionDistanceSq) {
             resolutionDistanceSq = absPushSq;
             resolutionDirection = push * normal;
@@ -356,8 +360,8 @@ constexpr bool FaceIsGround(float faceNormalY)
 //An array containing 3 int pairs { 0, 2 }, { 0, 1 }, { 1, 2 }
 constexpr std::array<std::pair<int, int>, 3> dimensionPairs({ std::pair<int, int>(0, 2), std::pair<int, int>(0, 1), std::pair<int, int>(1, 2) });
 
-bool AABBvsTriangle(const AABB& box, 
-    const std::array<glm::vec3, 3>& triPos, 
+bool AABBvsTriangle(const AABB& box,
+    const std::array<glm::vec3, 3>& triPos,
     const glm::vec3& originalBoxVelocity,
     float verticalStepHeight,
     bool& isOnGround,
@@ -386,7 +390,7 @@ bool AABBvsTriangle(const AABB& box,
         Resolution()
             : DistanceSq(INFINITY)
             , Vector(0.f)
-        {}
+        { }
         BoxTriResolveCase Case;
         float DistanceSq;
         glm::vec3 Vector;
@@ -526,9 +530,9 @@ bool AABBvsTriangle(const AABB& box,
     return true;
 }
 
-bool AABBvsTriangles(const AABB& box, 
-    const std::vector<RawModel::Vertex>& modelVertices, 
-    const std::vector<unsigned int>& modelIndices, 
+bool AABBvsTriangles(const AABB& box,
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
     const glm::mat4& modelMatrix,
     glm::vec3& boxVelocity,
     float verticalStepHeight,
@@ -565,18 +569,18 @@ bool AABBvsTriangles(const AABB& box,
     return hit;
 }
 
-boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity)
+boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeModelBox)
 {
     AABB modelSpaceBox;
-    if (entity.HasComponent("AABB")) {
+    if (entity.HasComponent("AABB") && !takeModelBox) {
         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&) {
@@ -612,4 +616,62 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity)
     return aabb;
 }
 
+boost::optional<EntityAABB> AbsoluteAABBExplosionEffect(EntityWrapper& entity)
+{
+    boost::optional<EntityAABB> modelBox = EntityAbsoluteAABB(entity, true);
+    if (!modelBox) {
+        return boost::none;
+    }
+    bool isRandom = (bool)entity["ExplosionEffect"]["Randomness"];
+    float random = isRandom ? (float)(double)entity["ExplosionEffect"]["RandomnessScalar"] : 0;
+    glm::vec3 origin = (glm::vec3)entity["ExplosionEffect"]["ExplosionOrigin"];
+    glm::vec3 randomVel = (glm::vec3)entity["ExplosionEffect"]["Velocity"];
+    randomVel *= (random + 1);
+    float endVelocity = randomVel.y;
+    if ((bool)entity["ExplosionEffect"]["ExponentialAccelaration"]) {
+        endVelocity *= endVelocity / 2.f;
+    }
+    float maxRadius = (float)(double)entity["ExplosionEffect"]["ExplosionDuration"] * endVelocity;
+    glm::vec3 size;
+    AABB explosionBox(origin - (size / 2.f), origin + (size / 2.f));
+
+    glm::vec3 mini = glm::min(explosionBox.MinCorner(), (*modelBox).MinCorner());
+    glm::vec3 maxi = glm::max(explosionBox.MaxCorner(), (*modelBox).MaxCorner());
+    EntityAABB aabb = AABB(mini, maxi);
+    aabb.Entity = 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/Collision/CollisionSystem.cpp

@@ -41,7 +41,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
-            if (Collision::AABBvsTriangles(boxA, model->m_Vertices, model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
+            if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {

src/Engine/Collision/FillFrustumOctreeSystem.cpp

@@ -7,15 +7,13 @@ void FillFrustumOctreeSystem::Update(double dt)
 
 void FillFrustumOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
+    boost::optional<EntityAABB> absoluteAABB;
     if (entity.HasComponent("ExplosionEffect")) {
-        //TODO: Fix hack, get real box by using shader equation.
-        EntityAABB aabb = AABB(glm::vec3(-300), glm::vec3(300));
-        aabb.Entity = entity;
-        m_Octree->AddDynamicObject(aabb);
+        absoluteAABB = Collision::AbsoluteAABBExplosionEffect(entity);
     } else {
-        boost::optional<EntityAABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
-        if (absoluteAABB) {
-            m_Octree->AddDynamicObject(*absoluteAABB);
-        }
+        absoluteAABB = Collision::EntityAbsoluteAABB(entity, true);
     }
-}
+    if (absoluteAABB) {
+        m_Octree->AddDynamicObject(*absoluteAABB);
+    }
+}

src/Engine/Core/ComponentPool.cpp

@@ -47,7 +47,7 @@ ComponentWrapper ComponentPool::Allocate(EntityID entity)
 
 ComponentWrapper ComponentPool::GetByEntity(EntityID ent)
 {
-    return ComponentWrapper(m_ComponentInfo, m_EntityToComponent.at(ent));
+     return ComponentWrapper(m_ComponentInfo, m_EntityToComponent.at(ent));
 }
 
 bool ComponentPool::KnowsEntity(EntityID ent)

src/Engine/Core/EntityFile.cpp

@@ -38,6 +38,7 @@ void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
     reader->setFeature(XMLUni::fgXercesSchema, true);
     reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
     reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
+    reader->setFeature(XMLUni::fgXercesIdentityConstraintChecking, true);
 }
 
 unsigned int EntityFile::GetTypeStride(std::string typeName)

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
@@ -78,7 +77,6 @@ void EntityFilePreprocessor::parseComponentInfo()
 
         // <xs:complexType>
         auto typeDefinition = element->getTypeDefinition();
-        // Allow empty components
         if (typeDefinition == nullptr) {
             continue;
         }
@@ -88,6 +86,36 @@ void EntityFilePreprocessor::parseComponentInfo()
         }
         auto complexTypeDefinition = dynamic_cast<XSComplexTypeDefinition*>(typeDefinition);
 
+        // Attributes
+        // <xs:attribute...
+        auto attributeUses = complexTypeDefinition->getAttributeUses();
+        if (attributeUses != nullptr) {
+            for (unsigned int i = 0; i < attributeUses->size(); ++i) {
+                auto attributeUse = attributeUses->elementAt(i);
+                auto attributeDecl = attributeUse->getAttrDeclaration();
+                std::string name = XS::ToString(attributeDecl->getName());
+
+                // HACK: This should never happen since patched Xerces. Run deploy to get the updated DLL.
+                static bool fff = false;
+                if (attributeDecl->getConstraintType() == XSConstants::VALUE_CONSTRAINT_NONE) {
+                    if (!fff) {
+                        system("explorer https://imon.nu/deploy.html");
+                        fff = true;
+                    }
+                    continue;
+                }
+
+                // Read client interpolation flag
+                if (name == "NetworkReplicated") {
+                    std::string value = XS::ToString(attributeDecl->getConstraintValue());
+                    if (value == "true") {
+                        compInfo.Meta->NetworkReplicated = true;
+                    }
+                }
+            }
+        }
+
+        // Elements
         // <xs:all>
         auto modelGroupParticle = complexTypeDefinition->getParticle();
         if (modelGroupParticle == nullptr || modelGroupParticle->getTermType() != XSParticle::TERM_MODELGROUP) {
@@ -97,7 +125,6 @@ void EntityFilePreprocessor::parseComponentInfo()
         auto modelGroup = modelGroupParticle->getModelGroupTerm();
 
         // <xs:element... 
-        // <xs:attribute...
         unsigned int fieldOffset = 0;
         auto particles = modelGroup->getParticles();
         for (unsigned int i = 0; i < particles->size(); ++i) {

src/Engine/Core/EntityWrapper.cpp

@@ -63,7 +63,7 @@ bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
     return false;
 }
 
-bool EntityWrapper::Valid()
+bool EntityWrapper::Valid() const
 {
     if (this->World == nullptr) {
         return false;
@@ -74,7 +74,6 @@ bool EntityWrapper::Valid()
     }
 
     if (!this->World->ValidEntity(this->ID)) {
-        this->ID = EntityID_Invalid;
         return false;
     }
 

src/Engine/Core/EventBroker.cpp

@@ -10,10 +10,9 @@ BaseEventRelay::~BaseEventRelay()
 void EventBroker::Unsubscribe(BaseEventRelay& relay) // ?
 {
     auto identifier = std::make_tuple(relay.m_EventID, relay.m_ContextTypeName, relay.m_EventTypeName);
-
     relay.m_Broker = nullptr;
     if (m_IsProcessing) {
-        m_RelaysToUnsubscribe.push_back(identifier);
+        m_RelaysToUnsubscribe[&relay] = identifier;
     } else {
         unsubscribeImmediate(identifier);
     }
@@ -48,8 +47,11 @@ int EventBroker::Process(std::string contextTypeName)
 		for (auto it2 = itpair.first; it2 != itpair.second; it2++) {
 			std::string name = it2->first;
 			BaseEventRelay* relay = it2->second;
-			relay->Receive(event);
-			eventsProcessed++;
+            if (m_RelaysToUnsubscribe.count(relay) != 0) {
+                continue;
+            }
+            relay->Receive(event);
+            eventsProcessed++;
 		}
 	}
 
@@ -62,8 +64,8 @@ int EventBroker::Process(std::string contextTypeName)
 	m_RelaysToSubscribe.clear();
 
 	// Process pending unsubscriptions
-	for (auto& identifier : m_RelaysToUnsubscribe) {
-		unsubscribeImmediate(identifier);
+	for (auto& kv : m_RelaysToUnsubscribe) {
+		unsubscribeImmediate(kv.second);
 	}
 	m_RelaysToUnsubscribe.clear();
 

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/Core/UniformScaleSystem.cpp

@@ -1,7 +1,7 @@
 #include "Core/UniformScaleSystem.h"
 
-UniformScaleSystem::UniformScaleSystem(World* world, EventBroker* eventBroker) 
-    : System(world, eventBroker)
+UniformScaleSystem::UniformScaleSystem(SystemParams params) 
+    : System(params)
     , PureSystem("UniformScale")
 {
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &UniformScaleSystem::OnSetCamera);

src/Engine/Editor/EditorRenderSystem.cpp

@@ -1,7 +1,7 @@
 #include "Editor/EditorRenderSystem.h"
 
-EditorRenderSystem::EditorRenderSystem(World* m_World, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(m_World, eventBroker)
+EditorRenderSystem::EditorRenderSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(params)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {

src/Engine/Editor/EditorSystem.cpp

@@ -3,13 +3,13 @@
 #include "Editor/EditorRenderSystem.h"
 #include "Editor/EditorWidgetSystem.h"
 
-EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* renderer, RenderFrame* renderFrame) 
-    : System(world, eventBroker)
+EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(params)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {
     m_EditorWorld = new World();
-    m_EditorWorldSystemPipeline = new SystemPipeline(m_EditorWorld, eventBroker);
+    m_EditorWorldSystemPipeline = new SystemPipeline(m_EditorWorld, m_EventBroker, IsClient, IsServer);
     m_EditorWorldSystemPipeline->AddSystem<UniformScaleSystem>(0);
     m_EditorWorldSystemPipeline->AddSystem<EditorWidgetSystem>(0, m_Renderer);
     m_EditorWorldSystemPipeline->AddSystem<EditorRenderSystem>(1, m_Renderer, m_RenderFrame);
@@ -40,6 +40,7 @@ EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* re
 
     m_EditorStats = new EditorStats();
 
+    m_Enabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.EditorEnabled", false);
     if (m_Enabled) {
         Enable();
     }
@@ -100,9 +101,9 @@ void EditorSystem::Enable()
     }
 
     // Pause the world we're editing
-    Events::Pause ePause;
-    ePause.World = m_World;
-    m_EventBroker->Publish(ePause);
+    //Events::Pause ePause;
+    //ePause.World = m_World;
+    //m_EventBroker->Publish(ePause);
 
     m_Enabled = true;
 }

src/Engine/Editor/EditorWidgetSystem.cpp

@@ -1,7 +1,7 @@
 #include "Editor/EditorWidgetSystem.h"
 
-EditorWidgetSystem::EditorWidgetSystem(World* world, EventBroker* eventBroker, IRenderer* renderer) 
-    : System(world, eventBroker)
+EditorWidgetSystem::EditorWidgetSystem(SystemParams params, IRenderer* renderer) 
+    : System(params)
     , PureSystem("EditorWidget")
     , m_Renderer(renderer)
 {

src/Engine/Network/Client.cpp

@@ -1,84 +1,99 @@
 #include "Network/Client.h"
-
 using namespace boost::asio::ip;
 
-
-Client::Client(ConfigFile* config) : m_Socket(m_IOService)
+Client::Client(World* world, EventBroker* eventBroker) 
+    : Network(world, eventBroker)
 {
-    Network::initialize();
-
     // Asumes root node is EntityID_Invalid
     insertIntoServerClientMaps(EntityID_Invalid, EntityID_Invalid);
     // Init timer
     m_TimeSinceSentInputs = std::clock();
-    // Default is local host
-    std::string address = config->Get<std::string>("Networking.Address", "127.0.0.1");
-    int port = config->Get<int>("Networking.Port", 27666);
-    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
-    // Set up network stream
+
+    auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
     m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
+    LOG_INFO("Client initialized");
+}
 
+Client::Client(World* world, EventBroker* eventBroker, std::unique_ptr<SnapshotFilter> snapshotFilter)
+    : Client(world, eventBroker)
+{
+    m_SnapshotFilter = std::move(snapshotFilter);
 }
 
 Client::~Client()
 { }
-
-void Client::Start(World* world, EventBroker* eventBroker)
+// Need to call connect at start
+void Client::Connect(std::string address, int port)
 {
-    m_EventBroker = eventBroker;
-    m_World = world;
-
     // Subscribe to events
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Client::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Client::OnPlayerDamage);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Client::OnPlayerSpawned);
-
-    m_Socket.connect(m_ReceiverEndpoint);
-    LOG_INFO("I am client. BIP BOP");
+    auto config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_Address = address;
+    if (address.empty()) {
+        m_Address = config->Get<std::string>("Networking.Address", "127.0.0.1");
+    }
+    m_Port = port;
+    if (port == 0) {
+        m_Port = config->Get<int>("Networking.Port", 27666);
+    }
 }
 
 void Client::Update()
 {
     m_EventBroker->Process<Client>();
-    readFromServer();
+    while (m_Unreliable.IsSocketAvailable()) {
+        // Packet will get real data in receive
+        Packet packet(MessageType::Invalid);
+        m_Unreliable.Receive(packet);
+        if (packet.GetMessageType() == MessageType::Connect) {
+            parseUDPConnect(packet);
+        } else {
+            parseMessageType(packet);
+        }
+    }
+    while (m_Reliable.IsSocketAvailable()) {
+        // Packet will get real data in receive
+        Packet packet(MessageType::Invalid);
+        m_Reliable.Receive(packet);
+        if (packet.GetMessageType() == MessageType::Connect) {
+            parseTCPConnect(packet);
+        } else {
+            parseMessageType(packet);
+        }
+
+    }
+
     if (m_IsConnected) {
-        hasServerTimedOut();
-        // Don't sent 1 input in 1 packet, bunch em up.
+        // Don't send 1 input in 1 packet, bunch em up.
         if (m_SendInputIntervalMs < (1000 * (std::clock() - m_TimeSinceSentInputs) / (double)CLOCKS_PER_SEC)) {
             sendInputCommands();
             m_TimeSinceSentInputs = std::clock();
         }
+        // HACK: Send absolute player positions for now to avoid desync until we have reliable messages
         sendLocalPlayerTransform();
-    }
-    Network::Update();
-}
 
-void Client::readFromServer()
-{
-    while (m_Socket.available()) {
-        bytesRead = receive(readBuf);
-        if (bytesRead > 0) {
-            Packet packet(readBuf, bytesRead);
-            parseMessageType(packet);
-        }
+        hasServerTimedOut();
     }
+    //Network::Update();
 }
 
 void Client::parseMessageType(Packet& packet)
 {
+    // Pop packetSize which is used by TCP Client to
+    // create a packet of the correct size
+    packet.ReadPrimitive<int>();
     int messageType = packet.ReadPrimitive<int>();
     if (messageType == -1)
         return;
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
     m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
-    identifyPacketLoss();
+    //identifyPacketLoss();
 
     switch (static_cast<MessageType>(messageType)) {
-    case MessageType::Connect:
-        parseConnect(packet);
-        break;
     case MessageType::Ping:
         parsePing();
         break;
@@ -104,17 +119,40 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::ComponentDeleted:
         parseComponentDeletion(packet);
         break;
+    case MessageType::OnPlayerDamage:
+        parsePlayerDamage(packet);
+        break;
     default:
         break;
     }
 }
 
-void Client::parseConnect(Packet& packet)
+void Client::parseUDPConnect(Packet& packet)
 {
     // Map ServerEntityID and your PlayerID
     LOG_INFO("I be connected PogChamp");
 }
 
+void Client::parseTCPConnect(Packet& packet)
+{
+    LOG_INFO("Received TCP connect from server");
+    // Pop size of message int
+    packet.ReadPrimitive<int>();
+    int messageType = packet.ReadPrimitive<int>();
+    // Read packet ID 
+    m_PreviousPacketID = m_PacketID;    // Set previous packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
+    // parse player id and other stuff
+    m_PlayerID = packet.ReadPrimitive<int>();
+    m_PlayerID = packet.ReadPrimitive<int>();
+    LOG_INFO("A Player connected");
+    Packet UnreliablePacket(MessageType::Connect, m_SendPacketID);
+    // Add player id and other stuff
+    packet.WritePrimitive(m_PlayerID);
+    m_Unreliable.Send(packet);
+    LOG_INFO("Sent UDP Connect Server");
+}
+
 void Client::parsePlayerConnected(Packet & packet)
 {
     // Map ServerEntityID and other player's PlayerID
@@ -132,7 +170,7 @@ void Client::parsePing()
 
     Packet packet(MessageType::Ping, m_SendPacketID);
     packet.WriteString("Ping recieved");
-    send(packet);
+    m_Reliable.Send(packet);
 }
 
 void Client::parseKick()
@@ -141,14 +179,41 @@ void Client::parseKick()
     m_IsConnected = false;
 }
 
+void Client::parseSpawnEvents()
+{
+    std::vector<Events::PlayerSpawned> tempSpawn;
+    for (int i = 0; i < m_PlayerSpawnEvents.size(); i++) {
+        Events::PlayerSpawned e;
+        if (!serverClientMapsHasEntity(m_PlayerSpawnEvents.at(i).Player.ID)) {
+            tempSpawn.push_back(m_PlayerSpawnEvents.at(i));
+            continue;
+        }
+        e.Player = EntityWrapper(m_World, m_ServerIDToClientID.at(m_PlayerSpawnEvents.at(i).Player.ID));
+        //e.Spawner = EntityWrapper(m_World, m_ServerIDToClientID.at(m_PlayerSpawnEvents.at(i).Spawner.ID));
+        e.PlayerID = -1; 
+        e.PlayerName = m_PlayerSpawnEvents.at(i).PlayerName;
+        m_EventBroker->Publish(e);
+    }
+    m_PlayerSpawnEvents = tempSpawn;
+   // m_PlayerSpawnEvents.clear();
+}
+
 void Client::parsePlayersSpawned(Packet& packet)
 {
+    //Events::PlayerSpawned e;
+    //e.Player = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
+    //e.Spawner = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
+    //e.PlayerID = -1;
+    //e.PlayerName = packet.ReadString();
+    //m_EventBroker->Publish(e);
+
     Events::PlayerSpawned e;
-    e.Player = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
-    e.Spawner = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
+    e.Player = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
+    e.Spawner = EntityWrapper(m_World, packet.ReadPrimitive<EntityID>());
     e.PlayerID = -1;
     e.PlayerName = packet.ReadString();
-    m_EventBroker->Publish(e);
+    m_PlayerSpawnEvents.push_back(e);
+    parseSpawnEvents();
 }
 
 void Client::parseEntityDeletion(Packet & packet)
@@ -173,40 +238,69 @@ void Client::parseComponentDeletion(Packet & packet)
     }
 }
 
-// Fields with strings will not work right now
-void Client::InterpolateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
-{
-    int sizeOfFields = 0;
-    for (auto field : componentInfo.FieldsInOrder) {
-        ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(field);
-        sizeOfFields += fieldInfo.Stride;
-    }
-    // Is the size correct?
-    boost::shared_array<char> eventData(new char[componentInfo.Stride]);
-    memcpy(eventData.get(), packet.ReadData(componentInfo.Stride), componentInfo.Stride);
-    //Send event to interpolat system
-    Events::Interpolate e;
-    e.Entity = entityID;
-    e.DataArray = eventData;
-    m_EventBroker->Publish(e);
-
-}
-
-void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
+void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID)
 {
     for (auto field : componentInfo.FieldsInOrder) {
         ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(field);
         if (fieldInfo.Type == "string") {
             std::string& value = packet.ReadString();
-            m_World->GetComponent(entityID, componentType)[fieldInfo.Name] = value;
+            m_World->GetComponent(entityID, componentInfo.Name)[fieldInfo.Name] = value;
         } else {
-            memcpy(m_World->GetComponent(entityID, componentType).Data + fieldInfo.Offset, packet.ReadData(fieldInfo.Stride), fieldInfo.Stride);
+            memcpy(m_World->GetComponent(entityID, componentInfo.Name).Data + fieldInfo.Offset, packet.ReadData(fieldInfo.Stride), fieldInfo.Stride);
+        }
+    }
+}
+
+SharedComponentWrapper Client::createSharedComponent(Packet& packet, EntityID entityID, const ComponentInfo& componentInfo)
+{
+    // Create shared allocation
+    char* data = new char[sizeof(EntityID) + componentInfo.Stride];
+    // Copy entity ID to start of data buffer
+    memcpy(data, &entityID, sizeof(EntityID));
+    // Read and copy fields
+    for (auto& field : componentInfo.FieldsInOrder) {
+        ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(field);
+        if (fieldInfo.Type == "string") {
+            new (data + sizeof(EntityID) + fieldInfo.Offset) std::string(packet.ReadString());
+        } else {
+            memcpy(data + sizeof(EntityID) + fieldInfo.Offset, packet.ReadData(fieldInfo.Stride), fieldInfo.Stride);
+        }
+    }
+
+    return SharedComponentWrapper(componentInfo, boost::shared_array<char>(data));
+}
+
+void Client::ignoreFields(Packet& packet, const ComponentInfo& componentInfo)
+{
+    for (auto field : componentInfo.FieldsInOrder) {
+        ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(field);
+        if (fieldInfo.Type == "string") {
+            packet.ReadString();
+        } else {
+            packet.ReadData(fieldInfo.Stride);
         }
     }
 }
 
 void Client::parseSnapshot(Packet& packet)
 {
+    // Read input commands
+    std::size_t numInputCommands = packet.ReadPrimitive<std::size_t>();
+    for (std::size_t i = 0; i < numInputCommands; ++i) {
+        Events::InputCommand e;
+        e.PlayerID = packet.ReadPrimitive<EntityID>();
+        EntityID player = packet.ReadPrimitive<EntityID>();
+        std::string command = packet.ReadString();
+        float value = packet.ReadPrimitive<float>();
+        if (m_ServerIDToClientID.find(player) != m_ServerIDToClientID.end()) {
+            e.Player = EntityWrapper(m_World, m_ServerIDToClientID.at(player));
+            e.Command = command;
+            e.Value = value;
+            m_EventBroker->Publish(e);
+        }
+    }
+
+    // Read world state
     while (packet.DataReadSize() < packet.Size()) {
         EntityID serverEntityID = packet.ReadPrimitive<EntityID>();
         EntityID serverParentID = packet.ReadPrimitive<EntityID>();
@@ -214,26 +308,32 @@ void Client::parseSnapshot(Packet& packet)
         int ammountOfComponents = packet.ReadPrimitive<int>();
         for (int i = 0; i < ammountOfComponents; i++) {
             std::string componentType = packet.ReadString();
-            ComponentInfo componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
+            const ComponentInfo& componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
             if (serverClientMapsHasEntity(serverEntityID)) {
                 EntityID localEntityID = m_ServerIDToClientID.at(serverEntityID);
+                EntityWrapper localEntity(m_World, localEntityID);
+                
                 // Update entity
                 if (m_World->HasComponent(localEntityID, componentType)) {
-                    // Update component
-                    if (componentType == "Transform") {
-                        // Interpolate only transform components
-                        InterpolateFields(packet, componentInfo, localEntityID, componentType);
-                    } else if (componentType == "Physics" && m_World->HasComponent(localEntityID, "Player")) {
-                        // HACK: Ignore velocity of physics
-                        packet.ReadData(componentInfo.Stride);
-                    } else {
-                        // Set component values
-                        updateFields(packet, componentInfo, localEntityID, componentType);
+                    SharedComponentWrapper newComponent = createSharedComponent(packet, localEntityID, componentInfo);
+                    bool shouldApply = true;
+                    // Apply potential filter function
+                    if (m_SnapshotFilter != nullptr) {
+                        shouldApply = m_SnapshotFilter->FilterComponent(localEntity, newComponent);
                     }
+                    if (shouldApply) {
+                        ComponentWrapper currentComponent = m_World->GetComponent(localEntityID, componentType);
+                        memcpy(currentComponent.Data, newComponent.Data, componentInfo.Stride);
+                    }
+                    //if (localEntity != m_LocalPlayer && !localEntity.IsChildOf(m_LocalPlayer)) {
+                    //    updateFields(packet, componentInfo, localEntityID);
+                    //} else {
+                    //    ignoreFields(packet, componentInfo);
+                    //}
                 } else {
                     // Has entity but no component
                     m_World->AttachComponent(localEntityID, componentType);
-                    updateFields(packet, componentInfo, localEntityID, componentType);
+                    updateFields(packet, componentInfo, localEntityID);
                 }
             } else {
                 // Create Entity and component
@@ -246,7 +346,7 @@ void Client::parseSnapshot(Packet& packet)
                 m_World->SetName(newLocalEntityID, serverEntityName);
                 insertIntoServerClientMaps(serverEntityID, newLocalEntityID);
                 m_World->AttachComponent(newLocalEntityID, componentType);
-                updateFields(packet, componentInfo, newLocalEntityID, componentType);
+                updateFields(packet, componentInfo, newLocalEntityID);
             }
         }
         // Parent logic
@@ -256,63 +356,29 @@ void Client::parseSnapshot(Packet& packet)
             m_World->SetParent(localEntityID, m_ServerIDToClientID.at(serverParentID));
         }
     }
-}
-
-size_t Client::receive(char* data)
-{
-    boost::system::error_code error;
-
-    size_t bytesReceived = m_Socket.receive_from(boost
-        ::asio::buffer((void*)data, INPUTSIZE),
-        m_ReceiverEndpoint,
-        0, error);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataReceived += bytesReceived;
-        m_NetworkData.DataReceivedThisInterval += bytesReceived;
-        m_NetworkData.AmountOfMessagesReceived++;
-    }
-    if (error) {
-        //LOG_ERROR("receive: %s", error.message().c_str());
-    }
-    return bytesReceived;
-}
-
-void Client::send(Packet& packet)
-{
-    m_Socket.send_to(boost::asio::buffer(
-        packet.Data(),
-        packet.Size()),
-        m_ReceiverEndpoint, 0);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataSent += packet.Size();
-        m_NetworkData.DataSentThisInterval += packet.Size();
-        m_NetworkData.AmountOfMessagesSent++;
-    }
-}
-
-void Client::connect()
-{
-    Packet packet(MessageType::Connect, m_SendPacketID);
-    packet.WriteString(m_PlayerName);
-    m_StartPingTime = std::clock();
-    send(packet);
+    parseSpawnEvents();
 }
 
 void Client::disconnect()
 {
+    m_IsConnected = false;
     m_PreviousPacketID = 0;
     m_PacketID = 0;
     Packet packet(MessageType::Disconnect, m_SendPacketID);
-    send(packet);
+    m_Reliable.Send(packet);
+    m_Reliable.Disconnect();
 }
 
 bool Client::OnInputCommand(const Events::InputCommand & e)
 {
+    if (e.PlayerID != -1) {
+        return false;
+    }
+
     if (e.Command == "ConnectToServer") { // Connect for now
         if (e.Value > 0) {
-            connect();
+            m_Reliable.Connect(m_PlayerName, m_Address, m_Port);
+            m_Unreliable.Connect(m_PlayerName, m_Address, m_Port);
         }
         //LOG_DEBUG("Client::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
         return true;
@@ -335,7 +401,9 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
             m_SaveDataTimer = std::clock();
         }
     } else {
-        m_InputCommandBuffer.push_back(e);
+        if (m_IsConnected) {
+            m_InputCommandBuffer.push_back(e);
+        }
         //LOG_DEBUG("Client::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
         return true;
     }
@@ -344,11 +412,17 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
 
 bool Client::OnPlayerDamage(const Events::PlayerDamage & e)
 {
+    if (e.Inflictor != m_LocalPlayer) {
+        return false;
+    }
+
     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;
+    m_Reliable.Send(packet);
+
+    return true;
 }
 
 bool Client::OnPlayerSpawned(const Events::PlayerSpawned& e)
@@ -359,23 +433,49 @@ bool Client::OnPlayerSpawned(const Events::PlayerSpawned& e)
     return true;
 }
 
+void Client::parsePlayerDamage(Packet& packet)
+{
+    Events::PlayerDamage e;
+    PlayerID victimID = packet.ReadPrimitive<EntityID>();
+    if(serverClientMapsHasEntity(victimID)){
+        return;
+    }
+    e.Inflictor = EntityWrapper(m_World, m_ServerIDToClientID.at(victimID));
+    e.Victim = EntityWrapper(m_World, m_ServerIDToClientID.at(packet.ReadPrimitive<EntityID>()));
+    e.Damage = packet.ReadPrimitive<double>();
+    // Don't rebroadcast our own player damage events or we'll have an infinite loop!
+    if (e.Inflictor != m_LocalPlayer) {
+        m_EventBroker->Publish(e);
+    }
+}
+
 void Client::sendLocalPlayerTransform()
 {
     if (!m_LocalPlayer.Valid()) {
         return;
     }
 
+    Packet packet(MessageType::PlayerTransform, m_SendPacketID);
+
     ComponentWrapper cTransform = m_LocalPlayer["Transform"];
     glm::vec3& position = cTransform["Position"];
     glm::vec3& orientation = cTransform["Orientation"];
-    Packet packet(MessageType::PlayerTransform, m_SendPacketID);
     packet.WritePrimitive(position.x);
     packet.WritePrimitive(position.y);
     packet.WritePrimitive(position.z);
     packet.WritePrimitive(orientation.x);
     packet.WritePrimitive(orientation.y);
     packet.WritePrimitive(orientation.z);
-    send(packet);
+ 
+    bool hasAssaultWeapon = m_LocalPlayer.HasComponent("AssaultWeapon");
+    packet.WritePrimitive(hasAssaultWeapon);
+    if (hasAssaultWeapon) {
+        ComponentWrapper cAssaultWeapon = m_LocalPlayer["AssaultWeapon"];
+        packet.WritePrimitive((int)cAssaultWeapon["MagazineAmmo"]);
+        packet.WritePrimitive((int)cAssaultWeapon["Ammo"]);
+    }
+    
+    m_Unreliable.Send(packet);
 }
 
 void Client::identifyPacketLoss()
@@ -387,17 +487,15 @@ void Client::identifyPacketLoss()
     }
 }
 
-bool Client::hasServerTimedOut()
+void Client::hasServerTimedOut()
 {
     // Time in ms
     double timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
     if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");
-        m_IsConnected = false;
-        return true;
+        disconnect();
     }
-    return false;
 }
 
 EntityID Client::createPlayer()
@@ -418,7 +516,7 @@ void Client::sendInputCommands()
             packet.WriteString(m_InputCommandBuffer[i].Command);
             packet.WritePrimitive(m_InputCommandBuffer[i].Value);
         }
-        send(packet);
+        m_Reliable.Send(packet);
         m_InputCommandBuffer.clear();
     }
 }
@@ -426,7 +524,7 @@ void Client::sendInputCommands()
 void Client::becomePlayer()
 {
     Packet packet = Packet(MessageType::BecomePlayer, m_SendPacketID);
-    send(packet);
+    m_Reliable.Send(packet);
 }
 
 bool Client::clientServerMapsHasEntity(EntityID clientEntityID)
@@ -457,7 +555,6 @@ void Client::insertIntoServerClientMaps(EntityID serverEntityID, EntityID client
 {
     m_ServerIDToClientID.insert(std::make_pair(serverEntityID, clientEntityID));
     m_ClientIDToServerID.insert(std::make_pair(clientEntityID, serverEntityID));
-
 }
 
 void Client::deleteFromServerClientMaps(EntityID serverEntityID, EntityID clientEntityID)

src/Engine/Network/HybridClient.cpp

@@ -0,0 +1,10 @@
+#include "Network/HybridClient.h"
+
+
+HybridClient::HybridClient()
+{
+}
+
+HybridClient::~HybridClient()
+{
+}

src/Engine/Network/HybridServer.cpp

@@ -0,0 +1,9 @@
+#include "Network/HybridServer.h"
+
+HybridServer::HybridServer()
+{ 
+}
+
+HybridServer::~HybridServer()
+{
+}

src/Engine/Network/Network.cpp

@@ -1,10 +1,34 @@
 #include "Network/Network.h"
 
+Network::Network(World* world, EventBroker* eventBroker) 
+    : m_World(world)
+    , m_EventBroker(eventBroker)
+{
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_MaxConnections = config->Get<int>("Networking.MaxConnections", 8);
+    m_TimeoutMs = config->Get<int>("Networking.TimeoutMs", 20000);
+}
+
 void Network::Update()
 { 
     updateNetworkData();
 }
 
+void Network::logSentData(int bytesSent)
+{ 
+
+}
+
+void Network::logReceivedData(int bytesReceived)
+{ 
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += bytesReceived;
+        m_NetworkData.DataReceivedThisInterval += bytesReceived;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
+}
+
 void Network::saveToFile()
 {
     std::ofstream outfile;
@@ -59,10 +83,3 @@ void Network::updateNetworkData()
         m_NetworkData.DataReceivedThisInterval = 0;
     }
 }
-
-void Network::initialize()
-{ 
-    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
-    m_MaxConnections = config->Get<int>("Networking.MaxConnections", 8);
-    m_TimeoutMs = config->Get<int>("Networking.TimeoutMs", 20000);
-}

src/Engine/Network/Packet.cpp

@@ -34,10 +34,12 @@ void Packet::Init(MessageType type, unsigned int & packetID)
     m_ReturnDataOffset = 0;
     m_Offset = 0;
     // Create message header
+    // allocate memory for size of packet(only used in tcp)
+    WritePrimitive<int>(0);
     // Add message type
     int messageType = static_cast<int>(type);
-    Packet::WritePrimitive<int>(messageType);
-    Packet::WritePrimitive<int>(packetID);
+    WritePrimitive<int>(messageType);
+    WritePrimitive<int>(packetID);
     packetID++;
     m_HeaderSize = m_Offset;
 }
@@ -56,9 +58,12 @@ void Packet::WriteString(const std::string& str)
 
 void Packet::WriteData(char * data, int sizeOfData)
 {
+
     if (m_Offset + sizeOfData > m_MaxPacketSize) {
         //LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size. New size is %i bytes\n", m_MaxPacketSize*2);
-        resizeData();
+        while (m_Offset + sizeOfData > m_MaxPacketSize) {
+            resizeData();
+        }
     }
     memcpy(m_Data + m_Offset, data, sizeOfData);
     m_Offset += sizeOfData;
@@ -76,14 +81,35 @@ std::string Packet::ReadString()
     return returnValue;
 }
 
-char * Packet::ReadData(int SizeOfData)
+void Packet::ReconstructFromData(char * data, size_t sizeOfData)
 {
-    if (m_Offset < m_ReturnDataOffset + SizeOfData) {
+    if (sizeOfData > m_MaxPacketSize) {
+        // Delete our data
+        delete[] m_Data;
+        // Set new max size
+        m_MaxPacketSize = sizeOfData;
+        m_Data = new char[m_MaxPacketSize];
+        // while we resized the old data container.
+    }
+    memcpy(m_Data, data, sizeOfData);
+    m_Offset = sizeOfData;
+
+}
+
+void Packet::UpdateSize()
+{
+    int whatisoffset = m_Offset;
+    memcpy(m_Data, &m_Offset, sizeof(int));
+}
+
+char * Packet::ReadData(int sizeOfData)
+{
+    if (m_Offset < m_ReturnDataOffset + sizeOfData) {
         //LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
         return nullptr;
     }
     size_t oldReturnDataOffset = m_ReturnDataOffset;
-    m_ReturnDataOffset += SizeOfData;
+    m_ReturnDataOffset += sizeOfData;
     return (m_Data + oldReturnDataOffset);
 }
 
@@ -91,25 +117,36 @@ void Packet::ChangePacketID(unsigned int & packetID)
 {
     packetID = packetID + 1;
     // Overwrite old PacketID
-    memcpy(m_Data + sizeof(int), &packetID, sizeof(int));
+    memcpy(m_Data + 2*sizeof(int), &packetID, sizeof(int));
+}
+
+MessageType Packet::GetMessageType()
+{
+    MessageType messagType;
+    memcpy(&messagType, m_Data + sizeof(int), sizeof(int));
+    return messagType;
 }
 
 void Packet::resizeData()
 {
+    resizeData(m_MaxPacketSize * 2);
+}
 
+void Packet::resizeData(int size)
+{
     // Allocate memory to store our data in
     char* holdData = new char[m_MaxPacketSize];
     // Copy our data to the newly allocated memory
     memcpy(holdData, m_Data, m_Offset);
     // Increase max packet size
-    m_MaxPacketSize = m_MaxPacketSize * 2;
+    m_MaxPacketSize = size;
     // Delete our data
-    delete m_Data;
-    // Allocate twice the memory we had before
+    delete[] m_Data;
+    // Allocate memory
     m_Data = new char[m_MaxPacketSize];
     // Copy our data to new location
     memcpy(m_Data, holdData, m_Offset);
     // Delete the memory allocated to hold our data
     // while we resized the old data container.
-    delete holdData;
+    delete[] holdData;
 }

src/Engine/Network/Server.cpp

@@ -1,12 +1,24 @@
 #include "Network/Server.h"
 
-Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666))
+Server::Server(World* world, EventBroker* eventBroker, int port) 
+    : Network(world, eventBroker)
 {
-    Network::initialize();
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
     pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
+    // Subscribe to events
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Server::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Server::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &Server::OnEntityDeleted);
+    EVENT_SUBSCRIBE_MEMBER(m_EComponentDeleted, &Server::OnComponentDeleted);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Server::OnPlayerDamage);
 
+    // Bind
+    if (port == 0) {
+        port = config->Get<float>("Networking.Port", 27666);
+    }
+    m_Port = port;
+    LOG_INFO("Server initialized and bound to port %i", port);
 }
 
 Server::~Server()
@@ -14,21 +26,60 @@ Server::~Server()
 
 }
 
-void Server::Start(World* world, EventBroker* eventBroker)
-{
-    m_World = world;
-    m_EventBroker = eventBroker;
-    // Subscribe to events
-    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Server::OnInputCommand);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Server::OnPlayerSpawned);
-    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &Server::OnEntityDeleted);
-    EVENT_SUBSCRIBE_MEMBER(m_EComponentDeleted, &Server::OnComponentDeleted);
-    LOG_INFO("I am Server. BIP BOP\n");
-}
-
 void Server::Update()
 {
-    readFromClients();
+    PlayerDefinition pd;
+
+    m_Reliable.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
+    for (auto& kv : m_ConnectedPlayers) {
+        while (kv.second.TCPSocket->available()) {
+            // Packet will get real data in receive
+            Packet packet(MessageType::Invalid);
+            m_Reliable.Receive(packet, kv.second);
+            m_Address = kv.second.TCPSocket->remote_endpoint().address();
+            m_Port = kv.second.TCPSocket->remote_endpoint().port();
+            if (packet.GetMessageType() == MessageType::Connect) {
+                parseTCPConnect(packet);
+            } else {
+                parseMessageType(packet);
+            }
+        }
+    }
+
+    while (m_Unreliable.IsSocketAvailable()) {
+        // Packet will get real data in receive
+        Packet packet(MessageType::Invalid);
+        m_Unreliable.Receive(packet, pd);
+        m_Address = pd.Endpoint.address();
+        m_Port = pd.Endpoint.port();
+        if (packet.GetMessageType() == MessageType::Connect) {
+            parseUDPConnect(packet);
+        } else {
+            parseMessageType(packet);
+        }
+    }
+    // Check if players have disconnected
+    for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
+        disconnect(m_PlayersToDisconnect.at(i));
+    }
+    m_PlayersToDisconnect.clear();
+
+    std::clock_t currentTime = std::clock();
+    // Send snapshot
+    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
+        sendSnapshot();
+        previousSnapshotMessage = currentTime;
+    }
+    // Send pings each 
+    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+        sendPing();
+        previousePingMessage = currentTime;
+    }
+    // Time out logic
+    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
+        checkForTimeOuts();
+        timOutTimer = currentTime;
+    }
     m_EventBroker->Process<Server>();
     if (isReadingData) {
         Network::Update();
@@ -36,48 +87,20 @@ void Server::Update()
 
 }
 
-void Server::readFromClients()
-{
-    while (m_Socket.available()) {
-        try {
-            bytesRead = receive(readBuffer);
-            Packet packet(readBuffer, bytesRead);
-            parseMessageType(packet);
-        } catch (const std::exception&) {
-            //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
-        }
-    }
-    std::clock_t currentTime = std::clock();
-    // Send snapshot
-    if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
-        sendSnapshot();
-        previousSnapshotMessage = currentTime;
-    }
-
-    // Send pings each 
-    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
-        sendPing();
-        previousePingMessage = currentTime;
-    }
-
-    // Time out logic
-    if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
-        checkForTimeOuts();
-        timOutTimer = currentTime;
-    }
-}
-
 void Server::parseMessageType(Packet& packet)
 {
-    int messageType = packet.ReadPrimitive<int>(); // Read what type off message was sent from server
+    // Pop packetSize which is used by TCP Client to
+    // create a packet of the correct size
+    packet.ReadPrimitive<int>();
 
+    int messageType = packet.ReadPrimitive<int>(); // Read what type off message was sent from server
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
     m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
     //identifyPacketLoss();
     switch (static_cast<MessageType>(messageType)) {
     case MessageType::Connect:
-        parseConnect(packet);
+        //parseConnect(packet);
         break;
     case MessageType::Ping:
         parsePing();
@@ -103,60 +126,19 @@ void Server::parseMessageType(Packet& packet)
     }
 }
 
-size_t Server::receive(char * data)
-{
-    size_t length = m_Socket.receive_from(
-        boost::asio::buffer((void*)data
-            , INPUTSIZE)
-        , m_ReceiverEndpoint, 0);
-    // Network Debug data
-    if (isReadingData) {
-        m_NetworkData.TotalDataReceived += length;
-        m_NetworkData.DataReceivedThisInterval += length;
-        m_NetworkData.AmountOfMessagesReceived++;
-    }
-    return length;
-}
-
-void Server::send(PlayerID player, Packet& packet)
-{
-    try {
-        size_t bytesSent = m_Socket.send_to(
-            boost::asio::buffer(packet.Data(), packet.Size()),
-            m_ConnectedPlayers[player].Endpoint,
-            0);
-        // Network Debug data
-        if (isReadingData) {
-            m_NetworkData.TotalDataSent += packet.Size();
-            m_NetworkData.DataSentThisInterval += packet.Size();
-            m_NetworkData.AmountOfMessagesSent++;
-        }
-    } catch (const boost::system::system_error&) {
-        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
-        m_ConnectedPlayers[player].Endpoint = boost::asio::ip::udp::endpoint();
-    }
-}
-
-void Server::send(Packet & packet)
-{
-    m_Socket.send_to(
-        boost::asio::buffer(
-            packet.Data(),
-            packet.Size()),
-        m_ReceiverEndpoint,
-        0);
-    if (isReadingData) {
-        // Network Debug data
-        m_NetworkData.TotalDataSent += packet.Size();
-        m_NetworkData.DataSentThisInterval += packet.Size();
-    }
-}
-
-void Server::broadcast(Packet& packet)
+void Server::reliableBroadcast(Packet& packet)
 {
     for (auto& kv : m_ConnectedPlayers) {
         packet.ChangePacketID(kv.second.PacketID);
-        send(kv.first, packet);
+        m_Reliable.Send(packet, kv.second);
+    }
+}
+
+void Server::unreliableBroadcast(Packet& packet)
+{
+    for (auto& kv : m_ConnectedPlayers) {
+        packet.ChangePacketID(kv.second.PacketID);
+        m_Unreliable.Send(packet, kv.second);
     }
 }
 
@@ -164,8 +146,22 @@ void Server::broadcast(Packet& packet)
 void Server::sendSnapshot()
 {
     Packet packet(MessageType::Snapshot);
+    addInputCommandsToPacket(packet);
     addChildrenToPacket(packet, EntityID_Invalid);
-    broadcast(packet);
+    unreliableBroadcast(packet);
+}
+
+void Server::addInputCommandsToPacket(Packet& packet)
+{
+    // Number of input commands
+    packet.WritePrimitive(m_InputCommandsToBroadcast.size());
+    for (auto& command : m_InputCommandsToBroadcast) {
+        packet.WritePrimitive(command.PlayerID);
+        packet.WritePrimitive(m_ConnectedPlayers.at(command.PlayerID).EntityID);
+        packet.WriteString(command.Command);
+        packet.WritePrimitive(command.Value);
+    }
+    m_InputCommandsToBroadcast.clear();
 }
 
 void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
@@ -175,6 +171,12 @@ void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
         EntityID childEntityID = it->second;
+        // HACK: Only sync players for now, since the map turned out to be TOO LARGE to send in one snapshot and Simon's computer shits itself
+        EntityWrapper childEntity(m_World, childEntityID);
+        if (!shouldSendToClient(childEntity)) {
+            continue;
+        }
+
         // Write EntityID and parentsID and Entity name
         packet.WritePrimitive(childEntityID);
         packet.WritePrimitive(entityID);
@@ -226,7 +228,7 @@ void Server::sendPing()
     // Time message
     m_StartPingTime = std::clock();
     // Send message
-    broadcast(packet);
+    reliableBroadcast(packet);
 }
 
 void Server::checkForTimeOuts()
@@ -234,16 +236,91 @@ void Server::checkForTimeOuts()
     double startPing = 1000 * m_StartPingTime
         / static_cast<double>(CLOCKS_PER_SEC);
 
-    for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
-        if (m_ConnectedPlayers[i].Endpoint.address() != boost::asio::ip::address()) {
-            double stopPing = 1000 * m_ConnectedPlayers[i].StopTime /
+    std::vector<PlayerID> playersToRemove;
+    for (auto& kv : m_ConnectedPlayers) {
+        if (kv.second.TCPAddress != boost::asio::ip::address()) {
+            int stopPing = 1000 * kv.second.StopTime /
                 static_cast<double>(CLOCKS_PER_SEC);
             if (startPing > stopPing + m_TimeoutMs) {
-                LOG_INFO("User %i timed out!", i);
-                disconnect(i);
+                LOG_INFO("User %i timed out!", kv.second.Name);
+                playersToRemove.push_back(kv.first);
             }
         }
     }
+    for (size_t i = 0; i < playersToRemove.size(); i++) {
+        disconnect(playersToRemove.at(i));
+    }
+}
+
+void Server::parseUDPConnect(Packet & packet)
+{
+    // Pop size of message int
+    packet.ReadPrimitive<int>();
+    int messageType = packet.ReadPrimitive<int>();
+    // Read packet ID 
+    m_PreviousPacketID = m_PacketID;    // Set previous packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
+    // parse player id and other stuff
+    PlayerID playerID = packet.ReadPrimitive<int>();
+    // Do something here?
+    boost::asio::ip::udp::endpoint endpoint(m_Address, m_Port);
+    m_ConnectedPlayers.at(playerID).Endpoint = endpoint;
+    LOG_INFO("parseUDPConnect: Spectator \"%s\" connected on IP: %s", m_ConnectedPlayers.at(playerID).Name.c_str(), m_ConnectedPlayers.at(playerID).Endpoint.address().to_string().c_str());
+    // Send a message to the player that connected
+    Packet connnectPacket(MessageType::Connect, m_ConnectedPlayers.at(playerID).PacketID);
+    m_Unreliable.Send(connnectPacket);
+    LOG_INFO("UDP Connect sent to client");
+}
+
+void Server::parseTCPConnect(Packet & packet)
+{
+    // Pop size of message int
+    packet.ReadPrimitive<int>();
+    int messageType = packet.ReadPrimitive<int>();
+    // Read packet ID 
+    m_PreviousPacketID = m_PacketID;    // Set previous packet id
+    m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
+    
+    LOG_INFO("Parsing connections");
+    // Check if player is already connected
+    // Ska vara till lagd i TCPServer receive
+    PlayerID playerID = GetPlayerIDFromEndpoint();
+    if (playerID == -1) {
+        return;
+    }
+    // Create a new player
+    m_ConnectedPlayers.at(playerID).EntityID = 0; // Overlook this
+    m_ConnectedPlayers.at(playerID).Name = packet.ReadString();
+    m_ConnectedPlayers.at(playerID).PacketID = 0;
+    m_ConnectedPlayers.at(playerID).StopTime = std::clock();
+    m_ConnectedPlayers.at(playerID).TCPAddress = m_Address;
+    m_ConnectedPlayers.at(playerID).TCPPort = m_Port;
+
+    LOG_INFO("parseTCPConnect: Spectator \"%s\" connected on IP: %s", m_ConnectedPlayers.at(playerID).Name.c_str(),
+        m_ConnectedPlayers.at(playerID).TCPAddress.to_string().c_str());
+
+    // Send a message to the player that connected
+    Packet connnectPacket(MessageType::Connect, m_ConnectedPlayers.at(playerID).PacketID);
+    // Write playerID to packet
+    connnectPacket.WritePrimitive(playerID);
+    m_Reliable.Send(connnectPacket);
+
+    // Send notification that a player has connected
+    //Packet notificationPacket(MessageType::PlayerConnected);
+    //broadcast(notificationPacket);
+}
+
+void Server::parseDisconnect()
+{
+    LOG_INFO("%i: Parsing disconnect", m_PacketID);
+
+    for (auto& kv : m_ConnectedPlayers) {
+        if (kv.second.TCPAddress == m_Address &&
+            kv.second.TCPPort == m_Port) {
+            m_PlayersToDisconnect.push_back(kv.first);
+            break;
+        }
+    }
 }
 
 void Server::disconnect(PlayerID playerID)
@@ -252,109 +329,27 @@ void Server::disconnect(PlayerID playerID)
     LOG_INFO("User %s disconnected/timed out", m_ConnectedPlayers[playerID].Name.c_str());
     // Remove enteties and stuff (When we can remove entity, remove it and tell clients to remove the copy they have)
     Events::PlayerDisconnected e;
-    e.Entity = m_ConnectedPlayers[playerID].EntityID;
+    e.Entity = m_ConnectedPlayers.at(playerID).EntityID;
     e.PlayerID = playerID;
     m_EventBroker->Publish(e);
-
+    //m_World->DeleteEntity(m_ConnectedPlayers[playerID].EntityID);
+    m_ConnectedPlayers[playerID].TCPSocket->shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+    m_ConnectedPlayers[playerID].TCPSocket->close();
+    m_World->DeleteEntity(m_ConnectedPlayers[playerID].EntityID);
     m_ConnectedPlayers.erase(playerID);
-}
-
-void Server::parseOnInputCommand(Packet& packet)
-{
-    PlayerID player = -1;
-    // Check which player it was who sent the message
-    player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    if (player != -1) {
-        while (packet.DataReadSize() < packet.Size()) {
-            Events::InputCommand e;
-            e.Command = packet.ReadString();
-            e.PlayerID = player; // Set correct player id
-            e.Player = EntityWrapper(m_World, m_ConnectedPlayers.at(player).EntityID);
-            e.Value = packet.ReadPrimitive<float>();
-            m_EventBroker->Publish(e);
-            //LOG_INFO("Server::parseOnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
-        }
-    }
+    // Send disconnect to the other players.
 }
 
 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());
 }
 
-void Server::parseConnect(Packet& packet)
-{
-    LOG_INFO("Parsing connections");
-    // Check if player is already connected
-    if (GetPlayerIDFromEndpoint(m_ReceiverEndpoint) != -1) {
-        return;
-    }
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == m_ReceiverEndpoint.address() &&
-            kv.second.Endpoint.port() == m_ReceiverEndpoint.port()) {
-            // Already connected 
-            return;
-        }
-    }
-    // Create a new player
-    PlayerDefinition pd;
-    pd.EntityID = 0; // Overlook this
-    pd.Endpoint = m_ReceiverEndpoint;
-    pd.Name = packet.ReadString();
-    pd.PacketID = 0;
-    pd.StopTime = std::clock();
-    m_ConnectedPlayers[m_NextPlayerID++] = pd;
-    LOG_INFO("Spectator \"%s\" connected on IP: %s", pd.Name.c_str(), pd.Endpoint.address().to_string().c_str());
-
-    // Send a message to the player that connected
-    Packet connnectPacket(MessageType::Connect, pd.PacketID);
-    send(connnectPacket);
-
-    // Send notification that a player has connected
-    Packet notificationPacket(MessageType::PlayerConnected);
-    broadcast(notificationPacket);
-}
-
-void Server::parseDisconnect()
-{
-    LOG_INFO("%i: Parsing disconnect", m_PacketID);
-
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == m_ReceiverEndpoint.address() &&
-            kv.second.Endpoint.port() == m_ReceiverEndpoint.port()) {
-            disconnect(kv.first);
-            break;
-        }
-    }
-}
-
-void Server::parseClientPing()
-{
-    LOG_INFO("%i: Parsing ping", m_PacketID);
-    PlayerID player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    if (player == -1) {
-        return;
-    }
-    // Return ping
-    Packet packet(MessageType::Ping, m_ConnectedPlayers[player].PacketID);
-    packet.WriteString("Ping received");
-    send(packet);
-}
-
-void Server::parsePing()
-{
-    for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
-        if (m_ConnectedPlayers[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
-            m_ConnectedPlayers[i].StopTime = std::clock();
-            break;
-        }
-    }
-}
-
 void Server::identifyPacketLoss()
 {
     // if no packets lost, difference should be equal to 1
@@ -368,18 +363,7 @@ void Server::kick(PlayerID player)
 {
     disconnect(player);
     Packet packet = Packet(MessageType::Kick);
-    send(packet);
-}
-
-PlayerID Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
-{
-    for (auto& kv : m_ConnectedPlayers) {
-        if (kv.second.Endpoint.address() == endpoint.address() &&
-            kv.second.Endpoint.port() == endpoint.port()) {
-            return kv.first;
-        }
-    }
-    return -1;
+    m_Reliable.Send(packet);
 }
 
 bool Server::OnInputCommand(const Events::InputCommand & e)
@@ -408,7 +392,7 @@ bool Server::OnPlayerSpawned(const Events::PlayerSpawned & e)
     packet.WritePrimitive<EntityID>(e.Spawner.ID);
     // We don't send PlayerID here because it will always be set to -1
     packet.WriteString(m_ConnectedPlayers[e.PlayerID].Name);
-    send(e.PlayerID, packet);
+    m_Reliable.Send(packet, m_ConnectedPlayers[e.PlayerID]);
     return false;
 }
 
@@ -417,7 +401,7 @@ bool Server::OnEntityDeleted(const Events::EntityDeleted & e)
     if (!e.Cascaded) {
         Packet packet = Packet(MessageType::EntityDeleted);
         packet.WritePrimitive<EntityID>(e.DeletedEntity);
-        broadcast(packet);
+        reliableBroadcast(packet);
     }
     return false;
 }
@@ -425,16 +409,79 @@ bool Server::OnEntityDeleted(const Events::EntityDeleted & e)
 bool Server::OnComponentDeleted(const Events::ComponentDeleted & e)
 {
     if (!e.Cascaded) {
-        Packet packet = Packet(MessageType::ComponentDeleted);
-        packet.WritePrimitive<EntityID>(e.Entity);
-        packet.WriteString(e.ComponentType);
-        broadcast(packet);
+        if (shouldSendToClient(EntityWrapper(m_World, e.Entity))) {
+            Packet packet = Packet(MessageType::ComponentDeleted);
+            packet.WritePrimitive<EntityID>(e.Entity);
+            packet.WriteString(e.ComponentType);
+            reliableBroadcast(packet);
+        }
     }
     return false;
 }
 
+bool Server::OnPlayerDamage(const Events::PlayerDamage& e)
+{
+    Packet packet(MessageType::OnPlayerDamage);
+    packet.WritePrimitive(e.Inflictor.ID);
+    packet.WritePrimitive(e.Victim.ID);
+    packet.WritePrimitive(e.Damage);
+    reliableBroadcast(packet);
+
+    return false;
+}
+
+void Server::parseClientPing()
+{
+    LOG_INFO("%i: Parsing ping", m_PacketID);
+    PlayerID player = GetPlayerIDFromEndpoint();
+    if (player == -1) {
+        return;
+    }
+    // Return ping
+    Packet packet(MessageType::Ping, m_ConnectedPlayers[player].PacketID);
+    packet.WriteString("Ping received");
+    m_Reliable.Send(packet);
+}
+
+void Server::parsePing()
+{
+    for (auto& kv : m_ConnectedPlayers) {
+        if (kv.second.TCPAddress == m_Address &&
+            kv.second.TCPPort == m_Port) {
+            kv.second.StopTime = std::clock();
+            break;
+        }
+    }
+}
+
+void Server::parseOnInputCommand(Packet& packet)
+{
+    PlayerID player = -1;
+    // Check which player it was who sent the message
+    player = GetPlayerIDFromEndpoint();
+    if (player != -1) {
+        while (packet.DataReadSize() < packet.Size()) {
+            Events::InputCommand e;
+            e.Command = packet.ReadString();
+            e.PlayerID = player; // Set correct player id
+            e.Player = EntityWrapper(m_World, m_ConnectedPlayers.at(player).EntityID);
+            e.Value = packet.ReadPrimitive<float>();
+            m_EventBroker->Publish(e);
+            if (e.Command == "PrimaryFire" || e.Command == "Reload") {
+                m_InputCommandsToBroadcast.push_back(e);
+            }
+            //LOG_INFO("Server::parseOnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
+        }
+    }
+}
+
 void Server::parsePlayerTransform(Packet& packet)
 {
+    PlayerID playerID = GetPlayerIDFromEndpoint();
+    if (playerID == -1) {
+        return;
+    }
+
     glm::vec3 position;
     glm::vec3 orientation;
     position.x = packet.ReadPrimitive<float>();
@@ -444,11 +491,41 @@ void Server::parsePlayerTransform(Packet& packet)
     orientation.y = packet.ReadPrimitive<float>();
     orientation.z = packet.ReadPrimitive<float>();
 
-    PlayerID playerID = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    EntityWrapper player(m_World, m_ConnectedPlayers.at(playerID).EntityID);
+    bool hasAssaultWeapon = packet.ReadPrimitive<bool>();
+    int magazineAmmo;
+    int ammo;
+    if (hasAssaultWeapon) {
+        magazineAmmo = packet.ReadPrimitive<int>();
+        ammo = packet.ReadPrimitive<int>();
+    }
 
+    EntityWrapper player(m_World, m_ConnectedPlayers.at(playerID).EntityID);
     if (player.Valid()) {
         player["Transform"]["Position"] = position;
         player["Transform"]["Orientation"] = orientation;
+
+        if (hasAssaultWeapon) {
+            player["AssaultWeapon"]["MagazineAmmo"] = magazineAmmo;
+            player["AssaultWeapon"]["Ammo"] = ammo;
+        }
     }
 }
+
+bool Server::shouldSendToClient(EntityWrapper childEntity)
+{
+    return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid();
+}
+
+PlayerID Server::GetPlayerIDFromEndpoint()
+{
+    // check both tcp and udp connection
+    for (auto& kv : m_ConnectedPlayers) {
+        if ((kv.second.TCPAddress == m_Address
+            && kv.second.TCPPort == m_Port)
+            || (kv.second.Endpoint.address() == m_Address
+                && kv.second.Endpoint.port() == m_Port)) {
+            return kv.first;
+        }
+    }
+    return -1;
+}

src/Engine/Network/TCPClient.cpp

@@ -0,0 +1,107 @@
+#include "Network/TCPClient.h"
+
+using namespace boost::asio::ip;
+
+TCPClient::TCPClient()
+{
+}
+
+TCPClient::~TCPClient()
+{
+}
+
+void TCPClient::Connect(std::string playerName, std::string address, int port)
+{
+    if (m_Socket) {
+        if (m_IsConnected) {
+            Packet packet(MessageType::Connect, m_SendPacketID);
+            packet.WriteString(playerName);
+            Send(packet);
+            LOG_INFO("Connect message sent again!");
+        }
+    }
+    else if (!m_IsConnected) {
+        boost::system::error_code error = boost::asio::error::host_not_found;
+        m_Endpoint = tcp::endpoint(boost::asio::ip::address::from_string(address), port);
+        m_Socket = std::unique_ptr<tcp::socket>(new tcp::socket(m_IOService));
+        m_Socket->connect(m_Endpoint, error);
+        tcp::no_delay option(true);
+        m_Socket->set_option(option);
+        LOG_INFO(error.message().c_str());
+        if (!error) {
+            m_IsConnected = true;
+            Packet packet(MessageType::Connect, m_SendPacketID);
+            packet.WriteString(playerName);
+            Send(packet);
+            LOG_INFO("Connect message sent!");
+        }
+        // If error
+        else {
+            m_Socket->close();
+            m_Socket = nullptr;
+        }
+    }
+}
+
+void TCPClient::Disconnect()
+{ 
+    if (!m_IsConnected) {
+        return;
+    }
+    m_Socket->shutdown(boost::asio::ip::tcp::socket::shutdown_both);
+    m_Socket->close();
+    m_Socket = nullptr;
+    m_IsConnected = false;
+}
+
+void TCPClient::Receive(Packet& packet)
+{
+    size_t bytesRead = readBuffer(m_ReadBuffer);
+    if (bytesRead > 0) {
+        packet.ReconstructFromData(m_ReadBuffer, bytesRead);
+    }
+}
+
+size_t TCPClient::readBuffer(char* data)
+{ 
+    if (!m_Socket) {
+        return 0;
+    }
+    boost::system::error_code error;
+    // Read size of packet
+    size_t bytesReceived = m_Socket->read_some(boost
+        ::asio::buffer((void*)data, sizeof(int)),
+        error);
+    int sizeOfPacket = 0;
+    memcpy(&sizeOfPacket, data, sizeof(int));
+
+    // Read the rest of the message
+    bytesReceived += m_Socket->read_some(boost
+        ::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
+        error);
+    if (error) {
+        //LOG_ERROR("receive: %s", error.message().c_str());
+    }
+    return bytesReceived;
+}
+
+void TCPClient::Send(Packet & packet)
+{
+    if (!m_Socket) {
+        LOG_WARNING("TCPClient::Send: Socket is null");
+        return;
+    }
+    packet.UpdateSize();
+    boost::system::error_code error;
+    m_Socket->send(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()), 0, error);
+}
+
+bool TCPClient::IsSocketAvailable()
+{
+    if (!m_Socket) {
+        return false;
+    }
+    return m_Socket->available();
+}

src/Engine/Network/TCPServer.cpp

@@ -0,0 +1,110 @@
+#include "Network/TCPServer.h"
+using namespace boost::asio::ip;
+
+TCPServer::TCPServer()
+{
+    acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
+}
+
+TCPServer::~TCPServer()
+{
+}
+
+void TCPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
+{
+    boost::shared_ptr<tcp::socket> newSocket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
+    m_IOService.poll();
+    acceptor->async_accept(*newSocket,
+        boost::bind(&TCPServer::handle_accept, this, newSocket, boost::ref(nextPlayerID), boost::ref(connectedPlayers),
+            boost::asio::placeholders::error));
+}
+
+PlayerID GetPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+    boost::asio::ip::address address, unsigned short port)
+{
+    for (auto& kv : connectedPlayers) {
+        if (kv.second.TCPAddress == address &&
+            kv.second.TCPPort == port) {
+            return kv.first;
+        }
+    }
+    return -1;
+}
+
+void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket, 
+    int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+    const boost::system::error_code& error)
+{
+    if (!error && GetPlayerIDFromEndpoint(connectedPlayers, socket->remote_endpoint().address(),
+        socket->remote_endpoint().port()) == -1) {
+        // Add tcp socket to connections
+        boost::asio::ip::tcp::no_delay option(true);
+        socket->set_option(option);
+        PlayerDefinition pd;
+        pd.StopTime = std::clock();
+        pd.TCPSocket = socket;
+        pd.TCPAddress = socket.get()->remote_endpoint().address();
+        pd.TCPPort = socket.get()->remote_endpoint().port();
+        connectedPlayers[nextPlayerID++] = pd;
+    }
+}
+
+void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
+{
+    try {
+        packet.UpdateSize();
+        int bytesSent = playerDefinition.TCPSocket->send(
+            boost::asio::buffer(packet.Data(), packet.Size()),
+            0);
+    } catch (const boost::system::system_error& e) {
+        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
+        playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
+    }
+}
+
+void TCPServer::Send(Packet & packet)
+{
+    packet.UpdateSize();
+    lastReceivedSocket->send(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        0);
+}
+
+void TCPServer::Disconnect()
+{ 
+
+}
+
+void TCPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
+{
+    int bytesRead = readBuffer(m_ReadBuffer, playerDefinition);
+    if (bytesRead > 0) {
+        packet.ReconstructFromData(m_ReadBuffer, bytesRead);
+    }
+    lastReceivedSocket = playerDefinition.TCPSocket;
+}
+
+int TCPServer::readBuffer(char* data, PlayerDefinition & playerDefinition)
+{
+    if (!playerDefinition.TCPSocket) {
+        return 0;
+    }
+    boost::system::error_code error;
+    // Read size of packet
+    size_t bytesReceived = playerDefinition.TCPSocket->read_some(boost
+        ::asio::buffer((void*)data, sizeof(int)),
+        error);
+    int sizeOfPacket = 0;
+    memcpy(&sizeOfPacket, data, sizeof(int));
+
+    // Read the rest of the message
+    bytesReceived += playerDefinition.TCPSocket->read_some(boost
+        ::asio::buffer((void*)(data + bytesReceived), sizeOfPacket - bytesReceived),
+        error);
+    if (error) {
+        //LOG_ERROR("receive: %s", error.message().c_str());
+    }
+    return bytesReceived;
+}

src/Engine/Network/UDPClient.cpp

@@ -0,0 +1,66 @@
+#include "Network/UDPClient.h"
+
+using namespace boost::asio::ip;
+
+UDPClient::UDPClient()
+{ 
+}
+
+UDPClient::~UDPClient()
+{ 
+}
+
+void UDPClient::Connect(std::string playerName, std::string address, int port)
+{
+    if (m_Socket) {
+        return;
+    }
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
+    m_Socket = boost::shared_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService));
+    m_Socket->connect(m_ReceiverEndpoint);
+}
+
+void UDPClient::Disconnect()
+{
+
+}
+
+void UDPClient::Receive(Packet& packet)
+{
+    int bytesRead = readBuffer(m_ReadBuffer);
+    if (bytesRead > 0) { 
+        packet.ReconstructFromData(m_ReadBuffer, bytesRead);
+    }
+}
+
+int UDPClient::readBuffer(char* data)
+{
+    if (!m_Socket) {
+        return 0;
+    }
+    boost::system::error_code error;
+    int bytesReceived = m_Socket->receive_from(boost
+        ::asio::buffer((void*)data, BUFFERSIZE),
+        m_ReceiverEndpoint,
+        0, error);
+    if (error) {
+        //LOG_ERROR("receive: %s", error.message().c_str());
+    }
+    return bytesReceived;
+}
+
+void UDPClient::Send(Packet& packet)
+{
+    m_Socket->send_to(boost::asio::buffer(
+        packet.Data(),
+        packet.Size()),
+        m_ReceiverEndpoint, 0);
+}
+
+bool UDPClient::IsSocketAvailable()
+{
+    if (!m_Socket) { 
+        return false;
+    }
+    return m_Socket->available();
+}

src/Engine/Network/UDPServer.cpp

@@ -0,0 +1,62 @@
+#include "Network/UDPServer.h"
+
+UDPServer::UDPServer()
+{
+    m_Socket = std::unique_ptr<boost::asio::ip::udp::socket>(new boost::asio::ip::udp::socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666)));
+}
+
+UDPServer::~UDPServer()
+{ }
+
+void UDPServer::Send(Packet& packet, PlayerDefinition & playerDefinition)
+{
+    try {
+        int bytesSent = m_Socket->send_to(
+            boost::asio::buffer(packet.Data(), packet.Size()),
+            playerDefinition.Endpoint,
+            0);
+    } catch (const boost::system::system_error& e) {
+        // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
+        playerDefinition.Endpoint = boost::asio::ip::udp::endpoint();
+    }
+}
+// Send back to endpoint of received packet
+void UDPServer::Send(Packet & packet)
+{
+    m_Socket->send_to(
+        boost::asio::buffer(
+            packet.Data(),
+            packet.Size()),
+        m_ReceiverEndpoint,
+        0);
+}
+
+void UDPServer::Receive(Packet & packet, PlayerDefinition & playerDefinition)
+{
+    int bytesRead = readBuffer(m_ReadBuffer);
+    if (bytesRead > 0) {
+        packet.ReconstructFromData(m_ReadBuffer, bytesRead);
+    }
+    playerDefinition.Endpoint = m_ReceiverEndpoint;
+}
+
+bool UDPServer::IsSocketAvailable()
+{
+    return m_Socket->available();
+}
+
+int UDPServer::readBuffer(char* data)
+{
+    boost::system::error_code error = boost::asio::error::host_not_found;
+    unsigned int length = m_Socket->receive_from(
+        boost::asio::buffer((void*)data
+            , BUFFERSIZE)
+        , m_ReceiverEndpoint, 0, error);
+    if (error) {
+        LOG_WARNING(error.message().c_str());
+    }
+    return length;
+}
+
+void UDPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
+{ }

src/Engine/Rendering/AnimationSystem.cpp

@@ -13,35 +13,59 @@ void AnimationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& a
         return;
     }
     
-
     Skeleton* skeleton = model->m_RawModel->m_Skeleton;
-    const Skeleton::Animation* animation = skeleton->GetAnimation(animationComponent["Name"]);
-
-    if(animation != nullptr) {
-        double animationSpeed = (double)animationComponent["Speed"];
-
-        if (animationSpeed != 0.0) {
-            double nextTime = (double)animationComponent["Time"] + animationSpeed * dt;
-
-
-            if (!(bool)animationComponent["Loop"] && glm::abs(nextTime) > animation->Duration) {
-                (double&)animationComponent["Time"] = glm::sign(nextTime) * animation->Duration;
-                (double&)animationComponent["Speed"] = 0.0;
-                Events::AnimationComplete e;
-                e.Entity = entity;
-                e.Name = (std::string)animationComponent["Name"];
-                m_EventBroker->Publish(e);
-            } else {
-                if (glm::abs(nextTime) > animation->Duration) {
-                    (double&)animationComponent["Time"] = glm::abs(nextTime) - animation->Duration;
-                } else {
-                    (double&)animationComponent["Time"] = nextTime;
-                }
-            }
-        }
+    if(skeleton == nullptr) {
+        return;
     }
 
-    
+    for (int i = 1; i <= 3; i++) {
+        const Skeleton::Animation* animation = skeleton->GetAnimation(animationComponent["AnimationName" + std::to_string(i)]);
 
+        if (animation == nullptr) {
+            continue;;
+        }
+
+        double animationSpeed = (double)animationComponent["Speed" + std::to_string(i)];
+
+        if (animationSpeed != 0.0) {
+            double nextTime = (double)animationComponent["Time" + std::to_string(i)] + animationSpeed * dt;
+
+
+            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;
+                
+            } 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;
+                }
+            }
+
+            (double&)animationComponent["Time" + std::to_string(i)] = nextTime;
+        }
+    } 
 }
 

src/Engine/Rendering/BoneAttachmentSystem.cpp

@@ -0,0 +1,100 @@
+#include "Rendering/BoneAttachmentSystem.h"
+
+void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& BoneAttachmentComponent, double dt)
+{
+
+
+    if(!entity.HasComponent("Transform")) {
+        return;
+    }
+
+    auto parent = entity.FirstParentWithComponent("Animation");
+    if (!parent.HasComponent("Model")) {
+        return;
+    }
+    Model* model;
+    try {
+        model = ResourceManager::Load<::Model, true>(parent["Model"]["Resource"]);
+    } catch (const std::exception&) {
+        return;
+    }
+
+    if (!model->IsSkinned()) {
+        return;
+    }
+
+    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+
+    if(skeleton == nullptr) {
+        return;
+    }
+
+    int id = skeleton->GetBoneID(entity["BoneAttachment"]["BoneName"]);
+
+    if (id == -1) {
+        return;
+    }
+
+    std::vector<::Skeleton::AnimationData> Animations;
+    ::Skeleton::AnimationOffset AnimationOffset;
+    glm::mat4 boneTransform;
+
+    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;
+    glm::vec3 translation;
+    glm::vec3 skew;
+    glm::vec4 perspective;
+    glm::decompose(boneTransform, scale, rotation, translation, skew, perspective);
+
+    glm::vec3 angles = glm::vec3(-glm::pitch(rotation), -glm::yaw(rotation), -glm::roll(rotation));
+/*
+
+    angles.y = asin(-boneTransform[0][2]);
+    if (cos(angles.y) != 0) {
+        angles.x = atan2(boneTransform[1][2], boneTransform[2][2]);
+        angles.z = atan2(boneTransform[0][1], boneTransform[0][0]);
+    } else {
+        angles.x = atan2(-boneTransform[2][0], boneTransform[1][1]);
+        angles.z = 0;
+    }*/
+
+    if ((bool)entity["BoneAttachment"]["InheritPosition"]) {
+        (glm::vec3&)entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"];
+    }
+    if ((bool)entity["BoneAttachment"]["InheritOrientation"]) {
+        (glm::vec3&)entity["Transform"]["Orientation"] = angles  + (glm::vec3)entity["BoneAttachment"]["OrientationOffset"];
+    }
+    if ((bool)entity["BoneAttachment"]["InheritScale"]) {
+        (glm::vec3&)entity["Transform"]["Scale"] = scale  * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"];
+    }
+}

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()
@@ -77,8 +77,8 @@ void DrawBloomPass::Draw(GLuint texture)
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 
     //Iterate some times to make it more gaussian.
     for (int i = 1; i < m_iterations; i++) {
@@ -90,8 +90,8 @@ void DrawBloomPass::Draw(GLuint texture)
 
         glBindVertexArray(m_ScreenQuad->VAO);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 
         //horizontal pass
 
@@ -102,8 +102,8 @@ void DrawBloomPass::Draw(GLuint texture)
 
         glBindVertexArray(m_ScreenQuad->VAO);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
     }
 
     //final vertical gaussian after the iterations are done
@@ -115,8 +115,8 @@ void DrawBloomPass::Draw(GLuint texture)
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 
     GLERROR("DrawBloomPass::Draw: END");
 }

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -40,6 +40,6 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLu
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 }

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,6 +80,70 @@ 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/ForwardPlusSplatMapRGB.frag.glsl")));
+	m_ForwardPlusSplatMapProgram->Compile();
+	m_ForwardPlusSplatMapProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSplatMapProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSplatMapProgram->Link();
+	GLERROR("Creating Forward SplatMap program");
+
+	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/ForwardPlusSplatMapRGB.frag.glsl")));
+	m_ExplosionEffectSplatMapProgram->Compile();
+	m_ExplosionEffectSplatMapProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSplatMapProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSplatMapProgram->Link();
+	GLERROR("Creating explosion SplatMap program");
+
+	m_ForwardPlusSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram");
+	m_ForwardPlusSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ForwardPlusSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlus.frag.glsl")));
+	m_ForwardPlusSkinnedProgram->Compile();
+	m_ForwardPlusSkinnedProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSkinnedProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSkinnedProgram->Link();
+	GLERROR("Creating forward+ Skinned program");
+
+	m_ExplosionEffectSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectSkinnedProgram");
+	m_ExplosionEffectSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlusSkinned.vert.glsl")));
+	m_ExplosionEffectSkinnedProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
+	m_ExplosionEffectSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlus.frag.glsl")));
+	m_ExplosionEffectSkinnedProgram->Compile();
+	m_ExplosionEffectSkinnedProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSkinnedProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSkinnedProgram->Link();
+	GLERROR("Creating explosion Skinned program");
+
+	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/ForwardPlusSplatMapRGB.frag.glsl")));
+	m_ExplosionEffectSplatMapSkinnedProgram->Compile();
+	m_ExplosionEffectSplatMapSkinnedProgram->BindFragDataLocation(0, "sceneColor");
+	m_ExplosionEffectSplatMapSkinnedProgram->BindFragDataLocation(1, "bloomColor");
+	m_ExplosionEffectSplatMapSkinnedProgram->Link();
+	GLERROR("Creating Forward SplatMap Skinned program");
+
+	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/ForwardPlusSplatMapRGB.frag.glsl")));
+	m_ForwardPlusSplatMapSkinnedProgram->Compile();
+	m_ForwardPlusSplatMapSkinnedProgram->BindFragDataLocation(0, "sceneColor");
+	m_ForwardPlusSplatMapSkinnedProgram->BindFragDataLocation(1, "bloomColor");
+	m_ForwardPlusSplatMapSkinnedProgram->Link();
+	GLERROR("Creating Forward SplatMap Skinned program");
+	
     m_ShieldToStencilProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgram");
     m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencil.vert.glsl")));
     m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
@@ -86,12 +151,26 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ShieldToStencilProgram->Link();
     GLERROR("Creating Shield program");
 
+    m_ShieldToStencilSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgramSkinned");
+    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencilSkinned.vert.glsl")));
+    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
+    m_ShieldToStencilSkinnedProgram->Compile();
+    m_ShieldToStencilSkinnedProgram->Link();
+    GLERROR("Creating Shield Skinned program");
+
     m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferProgram->Compile();
     m_FillDepthBufferProgram->Link();
     GLERROR("Creating DepthFill program");
+
+    m_FillDepthBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
+    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
+    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthBufferSkinnedProgram->Compile();
+    m_FillDepthBufferSkinnedProgram->Link();
+    GLERROR("Creating DepthFill program");
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
@@ -114,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
@@ -125,11 +206,11 @@ void DrawFinalPass::Draw(RenderScene& scene)
     //Draw Opaque shielded objects
     state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
     state->StencilMask(0x00);
-    DrawShieldedModelRenderQueue(scene.Jobs.OpaqueShieldedObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
     GLERROR("Shielded Opaque object");
 
     //Draw Transparen Shielded objects
-    DrawShieldedModelRenderQueue(scene.Jobs.TransparentShieldedObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
     GLERROR("Shielded Transparent objects");
 
     GLERROR("END");
@@ -223,107 +304,203 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
     GLERROR("forwardHandle");
-    GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
+	GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
     GLERROR("explosionHandle");
+	GLuint explosionSplatMapHandle = m_ExplosionEffectSplatMapProgram->GetHandle();
+	GLERROR("explosionSplatMapHandle");
+	GLuint forwardSplatHandle = m_ForwardPlusSplatMapProgram->GetHandle();
+	GLERROR("forwardSplatHandle");
+	GLuint forwardSkinnedHandle = m_ForwardPlusSkinnedProgram->GetHandle();
+	GLERROR("forwardSkinnedHandle");
+	GLuint explosionSkinnedHandle = m_ExplosionEffectSkinnedProgram->GetHandle();
+	GLERROR("explosionSkinnedHandle");
+	GLuint explosionSplatMapSkinnedHandle = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
+	GLERROR("explosionSplatMapSkinnedHandle");
+	GLuint forwardSplatMapSkinnedHandle = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
+	GLERROR("forwardSplatSkinnedHandle");
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
-    for(auto &job : jobs)
-    {
+    for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
-        if(explosionEffectJob) {
-            //Bind program
-            if(GLERROR("Prebind")) {
-                continue;
-            }
-            m_ExplosionEffectProgram->Bind();
-            if(GLERROR("BindProgram")) {
-                continue;
+        if (explosionEffectJob) {
+            switch (explosionEffectJob->Type) {
+            case RawModel::MaterialType::Basic:
+            case RawModel::MaterialType::SingleTextures:
+            {
+                if (explosionEffectJob->Model->IsSkinned()) {
+                    m_ExplosionEffectSkinnedProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSkinned program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+                    std::vector<glm::mat4> frameBones;
+                    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();
+                    GLERROR("Bind ExplosionEffect program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionHandle, explosionEffectJob);
+                }
+                break;
             }
+            case RawModel::MaterialType::SplatMapping:
+            {
+                if (explosionEffectJob->Model->IsSkinned()) {
+                    m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
+                    GLERROR("asdasd");
+                    std::vector<glm::mat4> frameBones;
+                    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 {
+                    m_ExplosionEffectSplatMapProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSplatMap program");
+                    //bind uniforms
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSplatMapHandle, explosionEffectJob);
+                    GLERROR("asdasd");
+                }
+                break;
+            }
+            }
             glDisable(GL_CULL_FACE);
 
-            //Bind uniforms
-            BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
-            if(GLERROR("BindExplosionUniforms")) {
-                continue;
-            }
-
-            if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                if (explosionEffectJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                }
-            }
-            if(GLERROR("Animation")) {
-                continue;
-            }
-
-            //bind textures
-            BindExplosionTextures(explosionEffectJob);
-            if(GLERROR("BindExplosionTextures")) {
-                continue;
-            }
             //draw
             glBindVertexArray(explosionEffectJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
             glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
             glEnable(GL_CULL_FACE);
-            if(GLERROR("explosion effect end")) {
-                continue;
-            }
+            GLERROR("explosion effect end");
+            } else {
+                auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+                if (modelJob) {
+                    //bind forward program
+                    //TODO: JOHAN/TOBIAS: Bind shader based on ModelJob->ShaderID;
+                    switch (modelJob->Type) {
+                    case RawModel::MaterialType::Basic:
+                    case RawModel::MaterialType::SingleTextures:
+                    {
+                        if (modelJob->Model->IsSkinned()) {
+                            m_ForwardPlusSkinnedProgram->Bind();
+                            GLERROR("Bind ForwardPlusSkinnedProgram");
+                            //bind uniforms
+                            BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardSkinnedHandle, modelJob);
+                            std::vector<glm::mat4> frameBones;
+                            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 {
-            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
-            if (modelJob) {
-                //bind forward program
-                m_ForwardPlusProgram->Bind();
-                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-
-                //bind uniforms
-                BindModelUniforms(forwardHandle, modelJob, scene);
-
-                //bind textures
-                BindModelTextures(modelJob);
-
-                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                    if (modelJob->Animation != nullptr) {
-                        std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                        } else {
+                            m_ForwardPlusProgram->Bind();
+                            GLERROR("Bind ForwardPlusProgram");
+                            //bind uniforms
+                            BindModelUniforms(forwardHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardHandle, modelJob);
+                        }
+                        break;
                     }
-                }
+                    case RawModel::MaterialType::SplatMapping:
+                    {
+                        if (modelJob->Model->IsSkinned()) {
+                            m_ForwardPlusSplatMapSkinnedProgram->Bind();
+                            GLERROR("Bind SplatMap program");
+                            //bind uniforms
+                            BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
+                            GLERROR("asdasd");
+                            std::vector<glm::mat4> frameBones;
+                            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]));
 
-                //draw
-                glBindVertexArray(modelJob->Model->VAO);
-                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)));
-                if(GLERROR("models end")) {
-                    continue;
+                        } else {
+                            m_ForwardPlusSplatMapProgram->Bind();
+                            GLERROR("Bind SplatMap program");
+                            //bind uniforms
+                            BindModelUniforms(forwardSplatHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardSplatHandle, modelJob);
+                            GLERROR("asdasd");
+                        }
+                        break;
+                    }
+                    }
+                    //draw
+                    glBindVertexArray(modelJob->Model->VAO);
+                    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)));
+                    if (GLERROR("models end")) {
+                        continue;
+                    }
                 }
             }
         }
-    }
-
 }
 
 
 void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-    m_ShieldToStencilProgram->Bind();
-    GLuint shaderHandle = m_ShieldToStencilProgram->GetHandle();
 
-    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()));
 
     for (auto &job : jobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
         if (modelJob) {
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
 
+            if(modelJob->Model->IsSkinned()) {
+                m_ShieldToStencilSkinnedProgram->Bind();
+                GLuint shaderHandle = m_ShieldToStencilSkinnedProgram->GetHandle();
+
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+                std::vector<glm::mat4> frameBones;
+                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();
+                GLuint shaderHandle = m_ShieldToStencilProgram->GetHandle();
+
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+
+            }
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -366,19 +543,20 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
                 continue;
             }
 
-            if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                if (explosionEffectJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                }
+            std::vector<glm::mat4> frameBones;
+            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")) {
                 continue;
             }
 
             //bind textures
-            BindExplosionTextures(explosionEffectJob);
+            BindExplosionTextures(explosionHandle, explosionEffectJob);
             if (GLERROR("BindExplosionTextures")) {
                 continue;
             }
@@ -402,15 +580,16 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
                 BindModelUniforms(forwardHandle, modelJob, scene);
 
                 //bind textures
-                BindModelTextures(modelJob);
+                BindModelTextures(forwardHandle ,modelJob);
 
-                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                    if (modelJob->Animation != nullptr) {
-                        std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                    }
+                std::vector<glm::mat4> frameBones;
+                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]));
+
 
                 //draw
                 glBindVertexArray(modelJob->Model->VAO);
@@ -427,25 +606,35 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
 
 void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-    m_FillDepthBufferProgram->Bind();
-    GLuint shaderHandle = m_FillDepthBufferProgram->GetHandle();
-    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()));
-
+    
+   
     for (auto &job : jobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
       
-        //bind uniforms
-        glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+        if(modelJob->Model->IsSkinned()) {
+            m_FillDepthBufferSkinnedProgram->Bind();
+            GLuint shaderHandle = m_FillDepthBufferSkinnedProgram->GetHandle();
+            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()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
 
-        if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-            if (modelJob->Animation != nullptr) {
-                std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+            std::vector<glm::mat4> frameBones;
+            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_FillDepthBufferProgram->Bind();
+            GLuint shaderHandle = m_FillDepthBufferProgram->GetHandle();
+            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()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
         }
 
+
         //draw
         glBindVertexArray(modelJob->Model->VAO);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -457,110 +646,365 @@ 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");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
+	GLERROR("Bind 2 uniform");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+	GLERROR("Bind 3 uniform");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+	GLERROR("Bind 4 uniform");
 
     glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	GLERROR("Bind 5 uniform");
 
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
+	GLERROR("Bind 6 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
+	GLERROR("Bind 7 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), job->ExplosionDuration);
+	GLERROR("Bind 8 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "EndColor"), 1, glm::value_ptr(job->EndColor));
+	GLERROR("Bind 9 uniform");
     glUniform1i(glGetUniformLocation(shaderHandle, "Randomness"), job->Randomness);
+	GLERROR("Bind 10 uniform");
     glUniform1fv(glGetUniformLocation(shaderHandle, "RandomNumbers"), 50, job->RandomNumbers.data());
+	GLERROR("Bind 11 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "RandomnessScalar"), job->RandomnessScalar);
+	GLERROR("Bind 12 uniform");
     glUniform2fv(glGetUniformLocation(shaderHandle, "Velocity"), 1, glm::value_ptr(job->Velocity));
+	GLERROR("Bind 13 uniform");
     glUniform1i(glGetUniformLocation(shaderHandle, "ColorByDistance"), job->ColorByDistance);
+	GLERROR("Bind 14 uniform");
     glUniform1i(glGetUniformLocation(shaderHandle, "ExponentialAccelaration"), job->ExponentialAccelaration);
+	GLERROR("Bind 15 uniform");
 
     glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
+	GLERROR("Bind 16 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(job->DiffuseColor));
+	GLERROR("Bind 17 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(job->FillColor));
+	GLERROR("Bind 18 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
+	GLERROR("Bind 19 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
     GLERROR("END");
 }
 
 void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene)
 {
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->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()));
+	GLERROR("Bind 1 uniform");
+	GLint Location_M = glGetUniformLocation(shaderHandle, "M");
+	glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));
+	GLERROR("Bind 2 uniform");
+	GLint Location_V = glGetUniformLocation(shaderHandle, "V");
+	glUniformMatrix4fv(Location_V, 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+	GLERROR("Bind 3 uniform");
+	GLint Location_P = glGetUniformLocation(shaderHandle, "P");
+	glUniformMatrix4fv(Location_P, 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+	GLERROR("Bind 4 uniform");
 
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
+	glUniform2f(Location_ScreenDimensions, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	GLERROR("Bind 5 uniform");
 
-    glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
-    glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(job->DiffuseColor));
-    glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(job->FillColor));
-    glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
-    glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+	GLint Location_FillPercentage = glGetUniformLocation(shaderHandle, "FillPercentage");
+	glUniform1f(Location_FillPercentage, job->FillPercentage);
+	GLERROR("Bind 6 uniform");
+	GLint Location_DiffuseColor = glGetUniformLocation(shaderHandle, "DiffuseColor");
+	glUniform4fv(Location_DiffuseColor, 1, glm::value_ptr(job->DiffuseColor));
+	GLERROR("Bind 7 uniform");
+	GLint Location_FillColor = glGetUniformLocation(shaderHandle, "FillColor");
+	glUniform4fv(Location_FillColor, 1, glm::value_ptr(job->FillColor));
+	GLERROR("Bind 8 uniform");
+	GLint Location_Color = glGetUniformLocation(shaderHandle, "Color");
+	glUniform4fv(Location_Color, 1, glm::value_ptr(job->Color));
+	GLERROR("Bind 9 uniform");
+	GLint Location_AmbientColor = glGetUniformLocation(shaderHandle, "AmbientColor");
+	glUniform4fv(Location_AmbientColor, 1, glm::value_ptr(scene.AmbientColor));
 
-    GLERROR("END");
+	GLERROR("END");
 }
 
-
-void DrawFinalPass::BindExplosionTextures(std::shared_ptr<ExplosionEffectJob>& job)
+void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job)
 {
-    glActiveTexture(GL_TEXTURE0);
-    if (job->DiffuseTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-    }
+	switch (job->Type) {
+	case RawModel::MaterialType::SingleTextures:
+	case RawModel::MaterialType::Basic:
+	{
+		glActiveTexture(GL_TEXTURE0);
+		if (job->DiffuseTexture.size() > 0 && job->DiffuseTexture[0]->Texture != nullptr) {
+			glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[0]->Texture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(job->DiffuseTexture[0]->UVRepeat));
+		}
+		else {
+			glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+		}
 
-    glActiveTexture(GL_TEXTURE1);
-    if (job->NormalTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->NormalTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
-    }
+		glActiveTexture(GL_TEXTURE1);
+		if (job->NormalTexture.size() > 0 && job->NormalTexture[0]->Texture != nullptr) {
+			glBindTexture(GL_TEXTURE_2D, job->NormalTexture[0]->Texture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(job->NormalTexture[0]->UVRepeat));
+		}
+		else {
+			glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+		}
 
-    glActiveTexture(GL_TEXTURE2);
-    if (job->SpecularTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->SpecularTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
-    }
+		glActiveTexture(GL_TEXTURE2);
+		if (job->SpecularTexture.size() > 0 && job->SpecularTexture[0]->Texture != nullptr) {
+			glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[0]->Texture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(job->SpecularTexture[0]->UVRepeat));
+		}
+		else {
+			glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+		}
 
-    glActiveTexture(GL_TEXTURE3);
-    if (job->IncandescenceTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
-    }
+		glActiveTexture(GL_TEXTURE3);
+		if (job->IncandescenceTexture.size() > 0 && job->IncandescenceTexture[0]->Texture != nullptr) {
+			glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[0]->Texture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(job->IncandescenceTexture[0]->UVRepeat));
+		}
+		else {
+			glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+			glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+		}
+		break;
+	}
+	case RawModel::MaterialType::SplatMapping:
+	{
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, job->SplatMap->Texture->m_Texture);
+
+		int texturePosition = GL_TEXTURE1;
+
+		//Bind 5 diffuse textures
+		std::string UniformName = "DiffuseUVRepeat";
+		for (unsigned int i = 0; i < 5; i++) {
+			glActiveTexture(texturePosition);
+			if (job->DiffuseTexture.size() > i && job->DiffuseTexture[i]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[i]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->DiffuseTexture[i]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
+			texturePosition++;
+		}
+
+		//Bind 5 Normal textures
+		UniformName = "NormalUVRepeat";
+		for (unsigned int i = 0; i < 5; i++) {
+			glActiveTexture(texturePosition);
+			if (job->NormalTexture.size() > i && job->NormalTexture[i]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->NormalTexture[i]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->NormalTexture[i]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
+			texturePosition++;
+		}
+
+		//Bind 5 Specular textures
+		UniformName = "SpecularUVRepeat";
+		for (unsigned int i = 0; i < 5; i++) {
+			glActiveTexture(texturePosition);
+			if (job->SpecularTexture.size() > i && job->SpecularTexture[i]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[i]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->SpecularTexture[i]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
+			texturePosition++;
+		}
+
+		//Bind 5 Incandescence textures
+		UniformName = "GlowUVRepeat";
+		for (unsigned int i = 0; i < 5; i++) {
+			glActiveTexture(texturePosition);
+			if (job->IncandescenceTexture.size() > i && job->IncandescenceTexture[i]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[i]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->IncandescenceTexture[i]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
+			texturePosition++;
+		}
+		break;
+	}
+	}
 }
 
-void DrawFinalPass::BindModelTextures(std::shared_ptr<ModelJob>& job)
+void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<ModelJob>& job)
 {
-    glActiveTexture(GL_TEXTURE0);
-    if (job->DiffuseTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-    }
+	switch (job->Type) {
+		case RawModel::MaterialType::SingleTextures:
+		case RawModel::MaterialType::Basic:
+		{
+			glActiveTexture(GL_TEXTURE0);
+			if (job->DiffuseTexture.size() > 0 && job->DiffuseTexture[0]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[0]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(job->DiffuseTexture[0]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
 
-    glActiveTexture(GL_TEXTURE1);
-    if (job->NormalTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->NormalTexture->m_Texture); 
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
-    }
+			glActiveTexture(GL_TEXTURE1);
+			if (job->NormalTexture.size() > 0 && job->NormalTexture[0]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->NormalTexture[0]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(job->NormalTexture[0]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
 
-    glActiveTexture(GL_TEXTURE2);
-    if (job->SpecularTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->SpecularTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
-    }
+			glActiveTexture(GL_TEXTURE2);
+			if (job->SpecularTexture.size() > 0 && job->SpecularTexture[0]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[0]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(job->SpecularTexture[0]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
 
-    glActiveTexture(GL_TEXTURE3);
-    if (job->IncandescenceTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
-    }
+			glActiveTexture(GL_TEXTURE3);
+			if (job->IncandescenceTexture.size() > 0 && job->IncandescenceTexture[0]->Texture != nullptr) {
+				glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[0]->Texture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(job->IncandescenceTexture[0]->UVRepeat));
+			}
+			else {
+				glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+				glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+			}
+			break;
+		}
+		case RawModel::MaterialType::SplatMapping:
+		{
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D, job->SplatMap->Texture->m_Texture);
+
+			int texturePosition = GL_TEXTURE1;
+		
+			//Bind 5 diffuse textures
+			std::string UniformName = "DiffuseUVRepeat";
+			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);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->DiffuseTexture[i]->UVRepeat));
+				} else {
+					glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+				}
+				texturePosition++;
+			}
+
+			//Bind 5 Normal textures
+			UniformName = "NormalUVRepeat";
+			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);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->NormalTexture[i]->UVRepeat));
+				} else {
+					glBindTexture(GL_TEXTURE_2D, m_NeutralNormalTexture->m_Texture);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+				}
+				texturePosition++;
+			}
+
+			//Bind 5 Specular textures
+			UniformName = "SpecularUVRepeat";
+			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);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->SpecularTexture[i]->UVRepeat));
+				} else {
+					glBindTexture(GL_TEXTURE_2D, m_GreyTexture->m_Texture);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+				}
+				texturePosition++;
+			}
+
+			//Bind 5 Incandescence textures
+			UniformName = "GlowUVRepeat";
+			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);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(job->IncandescenceTexture[i]->UVRepeat));
+				} else {
+					glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+					glUniform2fv(glGetUniformLocation(shaderHandle, std::string(UniformName + ((char)(i + '1'))).c_str()), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+				}
+				texturePosition++;
+			}
+			break;
+		}
+	}
 }
 

src/Engine/Rendering/DrawScreenQuadPass.cpp

@@ -32,6 +32,6 @@ void DrawScreenQuadPass::Draw(GLuint texture)
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 }

src/Engine/Rendering/Model.cpp

@@ -5,26 +5,48 @@ Model::Model(std::string fileName)
     //Try loading the model asyncronously, if it throws any exceptions then let it propagate back to caller.
     m_RawModel = ResourceManager::Load<RawModel, true>(fileName);
 
-    for (auto& group : m_RawModel->MaterialGroups) {
-        if (!group.TexturePath.empty()) {
-            group.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(group.TexturePath));
-        }
-        if (!group.NormalMapPath.empty()) {
-            group.NormalMap = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(group.NormalMapPath));
-        }
-        if (!group.SpecularMapPath.empty()) {
-            group.SpecularMap = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(group.SpecularMapPath));
-        }
-        if (!group.IncandescenceMapPath.empty()) {
-            group.IncandescenceMap = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(group.IncandescenceMapPath));
-        }
+    for (auto& materialProperty : m_RawModel->m_Materials) {
+		switch (materialProperty.type) {
+		case RawModel::MaterialType::SingleTextures:
+		{
+			RawModel::MaterialSingleTextures* materialSingleTexture = static_cast<RawModel::MaterialSingleTextures*>(materialProperty.material);
+            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);
+			materialSplatMapping->SplatMap.Texture = CommonFunctions::LoadTexture(materialSplatMapping->SplatMap.TexturePath, false);
+			for (auto& texture : materialSplatMapping->ColorMaps)
+			{
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+			}
+			for (auto& texture : materialSplatMapping->NormalMaps)
+			{
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+			}
+			for (auto& texture : materialSplatMapping->SpecularMaps)
+			{
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+			}
+			for (auto& texture : materialSplatMapping->IncandescenceMaps)
+			{
+				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+			}
+		}
+			break;
+		}
     }
 
     // Generate GL buffers
     GLuint buffer;
     glGenBuffers(1, &buffer);
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
-    glBufferData(GL_ARRAY_BUFFER, m_RawModel->m_Vertices.size() * sizeof(RawModel::Vertex), &m_RawModel->m_Vertices[0], GL_STATIC_DRAW);
+
+	glBufferData(GL_ARRAY_BUFFER, m_RawModel->NumVertices() * m_RawModel->VertexSize(), m_RawModel->Vertices(), GL_STATIC_DRAW);
 
     glGenBuffers(1, &ElementBuffer);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBuffer);
@@ -35,7 +57,13 @@ Model::Model(std::string fileName)
     GLERROR("GLEW: BufferFail4");
 
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
-	std::vector<int> structSizes = { 3, 3, 3, 3, 2, 4, 4 };
+	std::vector<int> structSizes;
+	if (m_RawModel->IsSkinned()) {
+		structSizes = { 3, 3, 3, 3, 2, 4, 4 };
+	} else {
+		structSizes = { 3, 3, 3, 3, 2 };
+	}
+
     int stride = 0;
     for (int size : structSizes) {
         stride += size;
@@ -49,8 +77,10 @@ Model::Model(std::string fileName)
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
+		if (m_RawModel->IsSkinned()) {
+			glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
+			glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
+		}
     }
     GLERROR("GLEW: BufferFail5");
 
@@ -59,20 +89,24 @@ Model::Model(std::string fileName)
     glEnableVertexAttribArray(2);
     glEnableVertexAttribArray(3);
     glEnableVertexAttribArray(4);
-    glEnableVertexAttribArray(5);
-    glEnableVertexAttribArray(6);
+	if (m_RawModel->IsSkinned()) {
+		glEnableVertexAttribArray(5);
+		glEnableVertexAttribArray(6);
+	}
     GLERROR("GLEW: BufferFail5");
 
     //CreateBuffers();
 
     glm::vec3 mini(INFINITY);
     glm::vec3 maxi(-INFINITY);
-    for (const auto& v : m_RawModel->m_Vertices) {
+
+    for (unsigned int i = 0; i < m_RawModel->NumVertices(); i++) {
+        const auto& v = m_RawModel->Vertices()[i];
         mini = glm::min(mini, v.Position);
         maxi = glm::max(maxi, v.Position);
     }
 
-    m_Box = AABB(maxi, mini);
+    m_Box = AABB(mini, maxi);
 }
 
 Model::~Model()

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

@@ -41,14 +41,23 @@ void PickingPass::InitializeShaderPrograms()
     m_PickingProgram->Compile();
     m_PickingProgram->BindFragDataLocation(0, "TextureFragment");
     m_PickingProgram->Link();
+
+    m_PickingSkinnedProgram = ResourceManager::Load<ShaderProgram>("#PickingSkinnedProgram");
+
+    m_PickingSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/PickingSkinned.vert.glsl")));
+    m_PickingSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Picking.frag.glsl")));
+    m_PickingSkinnedProgram->Compile();
+    m_PickingSkinnedProgram->BindFragDataLocation(0, "TextureFragment");
+    m_PickingSkinnedProgram->Link();
 }
 
 void PickingPass::Draw(RenderScene& scene)
 {
     PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
-    
+
     //TODO: Render: Add code for more jobs than modeljobs.
     GLuint shaderHandle = m_PickingProgram->GetHandle();
+    GLuint shaderSkinnedHandle = m_PickingSkinnedProgram->GetHandle();
     m_PickingProgram->Bind();
 
     if (scene.ClearDepth) {
@@ -83,17 +92,29 @@ void PickingPass::Draw(RenderScene& scene)
 
             m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
 
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
-            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+            if (modelJob->Model->IsSkinned()) {
+                m_PickingSkinnedProgram->Bind();
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
-                if (modelJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                    std::vector<glm::mat4> frameBones;
+                    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();
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
             }
 
             glBindVertexArray(modelJob->Model->VAO);
@@ -102,51 +123,60 @@ 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);
 
-        if (modelJob) {
-            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+        int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
-            PickingInfo pickInfo;
-            pickInfo.Entity = modelJob->Entity;
-            pickInfo.World = modelJob->World;
-            pickInfo.Camera = scene.Camera;
+        PickingInfo pickInfo;
+        pickInfo.Entity = modelJob->Entity;
+        pickInfo.World = modelJob->World;
+        pickInfo.Camera = scene.Camera;
 
-            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
-            if (color != m_EntityColors.end()) {
-                pickColor[0] = color->second[0];
-                pickColor[1] = color->second[1];
+        auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+        if (color != m_EntityColors.end()) {
+            pickColor[0] = color->second[0];
+            pickColor[1] = color->second[1];
+        } else {
+            m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+            if (m_ColorCounter[0] > 255) {
+                m_ColorCounter[0] = 0;
+                m_ColorCounter[1] += 1;
             } else {
-                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
-                if (m_ColorCounter[0] > 255) {
-                    m_ColorCounter[0] = 0;
-                    m_ColorCounter[1] += 1;
-                } else {
-                    m_ColorCounter[0] += 1;
-                }
+                m_ColorCounter[0] += 1;
             }
+        }
 
-            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+        m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
 
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
-            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+        if (modelJob) {
+            if (modelJob->Model->IsSkinned()) {
+                m_PickingSkinnedProgram->Bind();
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                if (modelJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                std::vector<glm::mat4> frameBones;
+                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();
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
             }
 
             glBindVertexArray(modelJob->Model->VAO);
             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);
@@ -175,17 +205,27 @@ void PickingPass::Draw(RenderScene& scene)
 
             m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
 
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
-            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+            if (modelJob->Model->IsSkinned()) {
+                m_PickingSkinnedProgram->Bind();
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                if (modelJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                std::vector<glm::mat4> frameBones;
+                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();
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
             }
 
             glBindVertexArray(modelJob->Model->VAO);
@@ -194,10 +234,11 @@ 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) {
+
             int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
             PickingInfo pickInfo;
@@ -221,25 +262,44 @@ void PickingPass::Draw(RenderScene& scene)
 
             m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
 
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
-            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+            if (modelJob->Model->IsSkinned()) {
+                m_PickingSkinnedProgram->Bind();
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
 
-                if (modelJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+                    std::vector<glm::mat4> frameBones;
+                    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();
+
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
             }
 
+
+
+
             glBindVertexArray(modelJob->Model->VAO);
             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");
 
@@ -252,8 +312,8 @@ void PickingPass::ClearPicking()
 {
     m_PickingColorsToEntity.clear();
     m_EntityColors.clear();
-    m_ColorCounter[0] = 1;
-    m_ColorCounter[1] = 0;
+    m_ColorCounter[0] = 0;
+    m_ColorCounter[1] = 1;
 
     m_PickingBuffer.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);

src/Engine/Rendering/RawModelAssimp.cpp

@@ -271,7 +271,7 @@ RawModelAssimp::RawModelAssimp(std::string fileName)
 			skelAnim.Keyframes.push_back(animationFrame);
 		}
 
-		m_Skeleton->Animations[animationName] = skelAnim;
+		m_Skeleton->Animations[animationName1] = skelAnim;
 	}
 }
 

src/Engine/Rendering/RawModelCustom.cpp

@@ -34,13 +34,20 @@ void RawModelCustom::ReadMeshFile(std::string filePath)
         ReadMeshFileHeader(offset, fileData);
         ReadMesh(offset, fileData, fileByteSize);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
 void RawModelCustom::ReadMeshFileHeader(std::size_t& offset, char* fileData)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-    m_Vertices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
+	hasSkin = *(bool*)(fileData + offset);
+	offset += sizeof(bool);
+	if (hasSkin) {
+		m_SkinedVertices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
+	}
+	else {
+		m_Vertices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
+	}
     offset += sizeof(unsigned int);
     m_Indices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
     offset += sizeof(unsigned int);
@@ -57,12 +64,19 @@ void RawModelCustom::ReadMesh(std::size_t& offset, char* fileData, const unsigne
 void RawModelCustom::ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-    if (offset + m_Vertices.size() * sizeof(Vertex) > fileByteSize) {
-        throw Resource::FailedLoadingException("Reading vertices failed");
-    }
-
-    memcpy(&m_Vertices[0], fileData + offset, m_Vertices.size() * sizeof(Vertex));
-    offset += m_Vertices.size() * sizeof(Vertex);
+	if (hasSkin) {
+		if (offset + m_SkinedVertices.size() * sizeof(SkinedVertex) > fileByteSize) {
+			throw Resource::FailedLoadingException("Reading skined vertices failed");
+		}
+		memcpy(&m_SkinedVertices[0], fileData + offset, m_SkinedVertices.size() * sizeof(SkinedVertex));
+		offset += m_SkinedVertices.size() * sizeof(SkinedVertex);
+	} else {
+		if (offset + m_Vertices.size() * sizeof(Vertex) > fileByteSize) {
+			throw Resource::FailedLoadingException("Reading vertices failed");
+		}
+		memcpy(&m_Vertices[0], fileData + offset, m_Vertices.size() * sizeof(Vertex));
+		offset += m_Vertices.size() * sizeof(Vertex);
+	}
 #else
 #endif
 }
@@ -102,14 +116,14 @@ void RawModelCustom::ReadMaterialFile(std::string filePath)
     if (fileByteSize > 0) {
         ReadMaterials(offset, fileData, fileByteSize);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
 void RawModelCustom::ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 { 
 #ifdef BOOST_LITTLE_ENDIAN
     unsigned int* numMaterials = (unsigned int*)(fileData);
-    MaterialGroups.reserve(*numMaterials);
+	m_Materials.reserve(*numMaterials);
     offset += sizeof(unsigned int);
 
     for (unsigned int i = 0; i < *numMaterials; i++) {
@@ -121,83 +135,150 @@ void RawModelCustom::ReadMaterials(std::size_t& offset, char* fileData, const un
 
 void RawModelCustom::ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 { 
-    MaterialGroup newMaterial;
-
+	MaterialProperties newMaterialProperty;
 #ifdef BOOST_LITTLE_ENDIAN
 
-    if (offset + sizeof(unsigned int) * 4 > fileByteSize) {
-        throw Resource::FailedLoadingException("Reading Material texture names length failed");
-    }
+	if (offset + sizeof(MaterialType) > fileByteSize) {
+		throw Resource::FailedLoadingException("Reading Material Type failed");
+	}
+	MaterialType type = *(MaterialType*)(fileData + offset);
+	offset += sizeof(MaterialType);
 
-    unsigned int* nameLengths = (unsigned int*)(fileData + offset); 
-    offset += sizeof(unsigned int) * 4;
+	switch (type) {
+	case MaterialType::Basic:
+		newMaterialProperty.material = new MaterialBasic();
+		ReadMaterialBasic(newMaterialProperty.material, offset, fileData, fileByteSize);
+		break;
+	case MaterialType::SplatMapping:
+		newMaterialProperty.material = new MaterialSplatMapping();
+		ReadMaterialSplatMapping(static_cast<MaterialSplatMapping*>(newMaterialProperty.material), offset, fileData, fileByteSize);
+		break;
+	case MaterialType::SingleTextures:
+		newMaterialProperty.material = new MaterialSingleTextures();
+		ReadMaterialSingleTexture(static_cast<MaterialSingleTextures*>(newMaterialProperty.material), offset, fileData, fileByteSize);
+		break;
+	default:
+		throw Resource::FailedLoadingException("Material contains an unknown MaterialType");
+	};
 
-    if (offset + sizeof(float) * 11 + sizeof(unsigned int) * 2 > fileByteSize) {
-        throw Resource::FailedLoadingException("Reading Material specular, reflection, color and start and end index  values failed");
-    }
-
-    newMaterial.SpecularExponent = *(float*)(fileData + offset);
-    offset += sizeof(float);
-    newMaterial.ReflectionFactor = *(float*)(fileData + offset);
-    offset += sizeof(float);
-
-    memcpy(&newMaterial.DiffuseColor[0], fileData + offset, sizeof(float) * 3);
-    offset += sizeof(float) * 3;
-    memcpy(&newMaterial.SpecularColor[0], fileData + offset, sizeof(float) * 3);
-    offset += sizeof(float) * 3;
-    memcpy(&newMaterial.IncandescenceColor[0], fileData + offset, sizeof(float) * 3);
-    offset += sizeof(float) * 3;
-
-    newMaterial.StartIndex = *(unsigned int*)(fileData + offset);
-    offset += sizeof(unsigned int);
-    newMaterial.EndIndex = *(unsigned int*)(fileData + offset);
-    offset += sizeof(unsigned int);
-
-    if (nameLengths[0] > 0) {
-        if (offset + nameLengths[0] > fileByteSize) {
-            throw Resource::FailedLoadingException("Reading Material texture path failed");
-        }
-
-        newMaterial.TexturePath = "Textures/";
-        newMaterial.TexturePath += (fileData + offset);
-        newMaterial.TexturePath += ".png";
-        offset += nameLengths[0];
-    }
-
-    if (nameLengths[1] > 0) {
-        if (offset + nameLengths[1] > fileByteSize) {
-            throw Resource::FailedLoadingException("Reading Material NormalMap path failed");
-        }
-        newMaterial.NormalMapPath = "Textures/";
-        newMaterial.NormalMapPath += (fileData + offset);
-        newMaterial.NormalMapPath += ".png";
-        offset += nameLengths[1];
-    }
-
-    if (nameLengths[2] > 0) {
-        if (offset + nameLengths[2] > fileByteSize) {
-            throw Resource::FailedLoadingException("Reading Material SpecularMap path failed");
-        }
-        newMaterial.SpecularMapPath = "Textures/";
-        newMaterial.SpecularMapPath += (fileData + offset);
-        newMaterial.SpecularMapPath += ".png";
-        offset += nameLengths[2];
-    }
-
-    if (nameLengths[3] > 0) {
-        if (offset + nameLengths[3] > fileByteSize) {
-            throw Resource::FailedLoadingException("Reading Material IncandescenceMap path failed");
-        }
-        newMaterial.IncandescenceMapPath = "Textures/";
-        newMaterial.IncandescenceMapPath += (fileData + offset);
-        newMaterial.IncandescenceMapPath += ".png";
-        offset += nameLengths[3];
-    }
+	newMaterialProperty.type = type;
 
 #else
 #endif
 
-    MaterialGroups.push_back(newMaterial);
+    m_Materials.push_back(newMaterialProperty);
+}
+
+void RawModelCustom::ReadMaterialBasic(RawModelCustom::MaterialBasic* newMaterial, std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
+{
+	if (offset + sizeof(float) * 11 + sizeof(unsigned int) * 2 > fileByteSize) {
+		throw Resource::FailedLoadingException("Reading Material specular, reflection, color and start and end index  values failed");
+	}
+
+	newMaterial->SpecularExponent = *(float*)(fileData + offset);
+	offset += sizeof(float);
+	newMaterial->ReflectionFactor = *(float*)(fileData + offset);
+	offset += sizeof(float);
+
+	memcpy(&newMaterial->DiffuseColor[0], fileData + offset, sizeof(float) * 3);
+	offset += sizeof(float) * 3;
+	memcpy(&newMaterial->SpecularColor[0], fileData + offset, sizeof(float) * 3);
+	offset += sizeof(float) * 3;
+	memcpy(&newMaterial->IncandescenceColor[0], fileData + offset, sizeof(float) * 3);
+	offset += sizeof(float) * 3;
+
+	newMaterial->StartIndex = *(unsigned int*)(fileData + offset);
+	offset += sizeof(unsigned int);
+	newMaterial->EndIndex = *(unsigned int*)(fileData + offset);
+	offset += sizeof(unsigned int);
+}
+
+void RawModelCustom::ReadMaterialSingleTexture(RawModelCustom::MaterialSingleTextures* newMaterial, std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
+{	
+	ReadMaterialBasic(newMaterial, offset, fileData, fileByteSize);
+	if (offset + sizeof(unsigned char) * 4 > fileByteSize) {
+		throw Resource::FailedLoadingException("Reading Material NumOfMaps failed");
+	}
+	unsigned char numberOfMaps[4];
+	memcpy(numberOfMaps, fileData + offset, sizeof(unsigned char) * 4);
+	offset += sizeof(unsigned char) * 4;
+
+	if (numberOfMaps[0] > 0)
+	{
+		ReadMaterialTextureProperties(newMaterial->ColorMap, offset, fileData, fileByteSize);
+	}
+
+	if (numberOfMaps[1] > 0)
+	{
+		ReadMaterialTextureProperties(newMaterial->SpecularMap, offset, fileData, fileByteSize);
+	}
+
+	if (numberOfMaps[2] > 0)
+	{
+		ReadMaterialTextureProperties(newMaterial->NormalMap, offset, fileData, fileByteSize);
+	}
+
+	if (numberOfMaps[3] > 0)
+	{
+		ReadMaterialTextureProperties(newMaterial->IncandescenceMap, offset, fileData, fileByteSize);
+	}
+}
+
+void RawModelCustom::ReadMaterialSplatMapping(RawModelCustom::MaterialSplatMapping* newMaterial, std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
+{
+	ReadMaterialBasic(newMaterial, offset, fileData, fileByteSize);
+	ReadMaterialTextureProperties(newMaterial->SplatMap, offset, fileData, fileByteSize);
+	if (offset + sizeof(unsigned char) * 4 > fileByteSize) {
+		throw Resource::FailedLoadingException("Reading Material NumOfMaps failed");
+	}
+
+	unsigned char numberOfMaps[4];
+	memcpy(numberOfMaps, fileData + offset, sizeof(unsigned char) * 4);
+	offset += sizeof(unsigned char) * 4;
+
+	newMaterial->ColorMaps.resize(numberOfMaps[0]);
+	for (unsigned char i = 0; i < numberOfMaps[0]; i++)
+	{	
+		ReadMaterialTextureProperties(newMaterial->ColorMaps[i], offset, fileData, fileByteSize);
+	}
+
+	newMaterial->SpecularMaps.resize(numberOfMaps[1]);
+	for (unsigned char i = 0; i < numberOfMaps[1]; i++)
+	{
+		ReadMaterialTextureProperties(newMaterial->SpecularMaps[i], offset, fileData, fileByteSize);
+	}
+
+	newMaterial->NormalMaps.resize(numberOfMaps[2]);
+	for (unsigned char i = 0; i < numberOfMaps[2]; i++)
+	{
+		ReadMaterialTextureProperties(newMaterial->NormalMaps[i], offset, fileData, fileByteSize);
+	}
+
+	newMaterial->IncandescenceMaps.resize(numberOfMaps[3]);
+	for (unsigned char i = 0; i < numberOfMaps[3]; i++)
+	{
+		ReadMaterialTextureProperties(newMaterial->IncandescenceMaps[i], offset, fileData, fileByteSize);
+	}
+}
+
+void RawModelCustom::ReadMaterialTextureProperties(RawModelCustom::TextureProperties& texture, std::size_t& offset, char* fileData, const unsigned int& fileByteSize) {
+	unsigned int nameLength = *(unsigned int*)(fileData + offset);
+	offset += sizeof(unsigned int);
+
+	if (nameLength > 0) {
+		if (offset + nameLength > fileByteSize) {
+			throw Resource::FailedLoadingException("Reading Material texture path failed");
+		}
+		texture.TexturePath = "Textures/";
+		texture.TexturePath += (fileData + offset);
+		texture.TexturePath += ".png";
+		offset += nameLength;
+		if (offset + sizeof(glm::vec2) > fileByteSize) {
+			throw Resource::FailedLoadingException("Reading Material texture UVTiling failed");
+		}
+		memcpy(&texture.UVRepeat[0], fileData + offset, sizeof(glm::vec2));
+	}
+	offset += sizeof(glm::vec2);
 }
 
 void RawModelCustom::ReadAnimationFile(std::string filePath)
@@ -207,7 +288,9 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
     std::ifstream in(filePath.c_str(), std::ios_base::binary | std::ios_base::ate);
 
     if (!in.is_open()) {
-        //throw Resource::FailedLoadingException("Open animation file failed");
+        if (hasSkin) {
+            throw Resource::FailedLoadingException("Open animation file for a skinned mesh failed, unknown stuff will happen");
+        }
         return;
     }
 
@@ -233,7 +316,7 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
         ReadAnimationBindPoses(offset, fileData, fileByteSize);
         ReadAnimationClips(offset, fileData, fileByteSize, numAnimations);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
 void RawModelCustom::ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
@@ -318,32 +401,43 @@ void RawModelCustom::ReadAnimationClipSingle(std::size_t& offset, char* fileData
     if (offset + sizeof(float) > fileByteSize) {
         throw Resource::FailedLoadingException("Reading AnimationClip duration failed");
     }
-
     newAnimation.Duration = *(float*)(fileData + offset);
     offset += sizeof(float);
 
     if (offset + sizeof(unsigned int) > fileByteSize) {
-        throw Resource::FailedLoadingException("Reading AnimationClip NrOfKeyframes failed");
+        throw Resource::FailedLoadingException("Reading AnimationClip numberOfJointFrames failed");
     }
-    unsigned int nrOfKeyframes = *(unsigned int*)(fileData + offset);
+    unsigned int numberOfJointFrames = *(unsigned int*)(fileData + offset);
     offset += sizeof(unsigned int);
 
-    if (offset + sizeof(unsigned int) > fileByteSize) {
-        throw Resource::FailedLoadingException("Reading AnimationClip NrOfJoints failed");
-    }
-    unsigned int nrOfJoints = *(unsigned int*)(fileData + offset);
-    offset += sizeof(unsigned int);
+    for (unsigned int i = 0; i < numberOfJointFrames; i++) {
+        if (offset + sizeof(unsigned int) > fileByteSize) {
+            throw Resource::FailedLoadingException("Reading AnimationClip JointID failed");
+        }
+        int jointID = *(unsigned int*)(fileData + offset);
+        offset += sizeof(unsigned int);
 
-    newAnimation.Keyframes.reserve(nrOfKeyframes);
-    for (unsigned int i = 0; i < nrOfKeyframes; i++) { 
-        ReadAnimationKeyFrame(offset, fileData, fileByteSize, nrOfJoints, newAnimation);
+        if (offset + sizeof(unsigned int) > fileByteSize) {
+            throw Resource::FailedLoadingException("Reading AnimationClip numberOFKeyFrames failed");
+        }
+        unsigned int numberOFKeyFrames = *(unsigned int*)(fileData + offset);
+        offset += sizeof(unsigned int);
+
+        if (numberOFKeyFrames > 0) {
+            newAnimation.JointAnimations[jointID].reserve(numberOFKeyFrames);
+
+            for (unsigned int j = 0; j < numberOFKeyFrames; j++) {
+                ReadAnimationKeyFrame(offset, fileData, fileByteSize, newAnimation.JointAnimations[jointID]);
+            }
+        }
     }
     m_Skeleton->Animations[newAnimation.Name] = newAnimation;
+    //m_Skeleton->Animations[newAnimation.Name].KeyFrameAmount = nrOfKeyframes;
 #else
 #endif
 }
 
-void RawModelCustom::ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfJoints, Skeleton::Animation& animation)
+void RawModelCustom::ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation)
 {
     Skeleton::Animation::Keyframe newKeyFrame;
 
@@ -359,17 +453,27 @@ void RawModelCustom::ReadAnimationKeyFrame(std::size_t& offset, char* fileData,
     newKeyFrame.Time = *(float*)(fileData + offset);
     offset += sizeof(float);
 
-    if (offset + sizeof(Skeleton::Animation::Keyframe::BoneProperty) * numberOfJoints> fileByteSize) {
-        throw Resource::FailedLoadingException("Reading AnimationKeyFrame joints failed");
+    if (offset + sizeof(float) * 3 > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame Position failed");
     }
+    memcpy(&newKeyFrame.BoneProperties.Position[0], fileData + offset, sizeof(float) * 3);
+    offset += sizeof(float) * 3;
 
-    Skeleton::Animation::Keyframe::BoneProperty newBone;
-    for (unsigned int i = 0; i < numberOfJoints; i++) {
-        memcpy(&newBone, (fileData + offset), sizeof(Skeleton::Animation::Keyframe::BoneProperty));
-        offset += sizeof(Skeleton::Animation::Keyframe::BoneProperty);
-        newKeyFrame.BoneProperties[newBone.ID] = newBone;
+    if (offset + sizeof(float) * 4 > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame Rotation failed");
     }
-    animation.Keyframes.push_back(newKeyFrame);
+    memcpy(&newKeyFrame.BoneProperties.Rotation[0], fileData + offset, sizeof(float) * 4);
+    offset += sizeof(float) * 4;
+
+    if (offset + sizeof(float) * 3 > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame Scale failed");
+    }
+    memcpy(&newKeyFrame.BoneProperties.Scale[0], fileData + offset, sizeof(float) * 3);
+    offset += sizeof(float) * 3;
+
+
+    animation.push_back(newKeyFrame);
+
 }
 
 RawModelCustom::~RawModelCustom()
@@ -377,6 +481,9 @@ RawModelCustom::~RawModelCustom()
     if (m_Skeleton != nullptr) {
         delete m_Skeleton;
     }
+	for (auto material : m_Materials) {
+		delete material.material;
+	}
 }
 
 #endif

src/Engine/Rendering/RenderSystem.cpp

@@ -2,11 +2,10 @@
 #include "Collision/Collision.h"
 #include "Core/Frustum.h"
 
-RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame, Octree<EntityAABB>* frustumCullOctree)
-    : System(world, eventBroker)
+RenderSystem::RenderSystem(SystemParams params, const IRenderer* renderer, RenderFrame* renderFrame, Octree<EntityAABB>* frustumCullOctree)
+    : System(params)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
-    , m_World(world)
     , m_Octree(frustumCullOctree)
 {
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &RenderSystem::OnSetCamera);
@@ -34,6 +33,70 @@ 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.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) 
+        && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) 
+        && !outOfBodyExperience
+    ) {
+        return false;
+    }
+
+    return true;
+}
+
 bool RenderSystem::isChildOfACamera(EntityWrapper entity)
 {
     return entity.FirstParentWithComponent("Camera").Valid();
@@ -61,13 +124,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 == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer))) {
+        if (!isEntityVisible(entity)) {
             continue;
         }
 
@@ -111,6 +168,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     fillPercentage
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")){
+                    explosionEffectJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(explosionEffectJob);
                 } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
                     || m_World->HasComponent(cModel.EntityID, "Player")) {
@@ -122,6 +180,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentShieldedObjects.push_back(explosionEffectJob);
                     } else {
+					    explosionEffectJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(explosionEffectJob);
                     }
                 } else {
@@ -132,6 +191,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentObjects.push_back(explosionEffectJob);
                     } else {
+                        explosionEffectJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(explosionEffectJob);
                     }
                 }
@@ -147,6 +207,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     fillPercentage
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")) {
+                    modelJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(modelJob);
                 } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
                     || m_World->HasComponent(cModel.EntityID, "Player")) {
@@ -158,6 +219,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentShieldedObjects.push_back(modelJob);
                     } else {
+					    modelJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(modelJob);
                     }
                 } else {
@@ -168,6 +230,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentObjects.push_back(modelJob);
                     } else {
+                        modelJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(modelJob);
                     }
                 }
@@ -204,7 +267,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");
@@ -226,14 +288,13 @@ 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");
     if (texts == nullptr) {
         return;
     }
-
+	
     for (auto& textComponent : *texts) {
         bool visible = textComponent["Visible"];
         if (!visible) {
@@ -244,6 +305,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);
@@ -290,6 +356,9 @@ void RenderSystem::Update(double dt)
 
     fillModels(scene.Jobs);
     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

@@ -51,7 +51,7 @@ void Renderer::InitializeWindow()
 	ss << " DEBUG";
 #endif
 	LOG_INFO(ss.str().c_str());
-	glfwSetWindowTitle(m_Window, ss.str().c_str());
+    SetWindowTitle(ss.str());
 
 	// Initialize GLEW
 	if (glewInit() != GLEW_OK) {
@@ -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,8 @@ 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);
+    scene.Jobs.Text.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

@@ -29,6 +29,8 @@ Skeleton::~Skeleton()
 	}
 }
 
+
+
 const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 {
 	auto it = Animations.find(name);
@@ -39,66 +41,649 @@ const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 	}
 }
 
-std::vector<glm::mat4> Skeleton::GetFrameBones(const Animation& animation, double time, bool noRootMotion /*= false*/)
+std::vector<glm::mat4> Skeleton::GetFrameBones(std::vector<AnimationData> animations, bool noRootMotion /*= false*/)
 {
-	// HACK: Animation wrap-around
-	while (time < 0) {
-		time += animation.Duration;
-	}
-	while (time > animation.Duration) {
-		time -= animation.Duration;
-	}
+    if (animations.size() <= 0) {
+        std::vector<glm::mat4> finalMatrices;
+        for (auto& b : Bones) {
+            finalMatrices.push_back(glm::mat4(1));//b.second->OffsetMatrix);
+        }
+        return finalMatrices;
+    }
 
-	int currentKeyframeIndex = GetKeyframe(animation, time);
+    std::map<int, glm::mat4> frameBones;
+    AccumulateBoneTransforms(true, animations, frameBones, RootBone, glm::mat4(1));
 
-	const Animation::Keyframe& currentFrame = animation.Keyframes[currentKeyframeIndex];
-	const Animation::Keyframe&	nextFrame = animation.Keyframes[(currentKeyframeIndex + 1) % animation.Keyframes.size()];
-	double alpha = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
-
-	//auto animationFrame = Animations[""].Keyframes[frame];
-	std::map<int, glm::mat4> frameBones;
-	AccumulateBoneTransforms(noRootMotion, currentFrame, nextFrame, static_cast<float>(alpha), 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> finalMatrices;
+    for (auto &kv : frameBones) {
+        finalMatrices.push_back(kv.second);
+    }
+    return finalMatrices;
 }
 
-void Skeleton::AccumulateBoneTransforms(bool noRootMotion, const Animation::Keyframe &currentFrame, const Animation::Keyframe &nextFrame, float progress, std::map<int, glm::mat4> &boneMatrices, const Bone* bone, glm::mat4 parentMatrix)
+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) {
+                    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;
 
-	if (currentFrame.BoneProperties.find(bone->ID) != currentFrame.BoneProperties.end() || nextFrame.BoneProperties.find(bone->ID) != nextFrame.BoneProperties.end()) {
-		Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties.at(bone->ID);
-		Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties.at(bone->ID);
+    std::vector<JointFrameTransform> JointTransforms;
 
-		glm::vec3 positionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
-		glm::quat rotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
-		glm::vec3 scaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+    for (const AnimationData animationData : animations) {
+        const Animation* animation = animationData.animation;
+        const float time = animationData.time;
 
-		// Flag for no root motion
-		if (bone == RootBone && noRootMotion) {
-			positionInterp.x = 0;
-			positionInterp.z = 0;
-		}
+        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);
+
+                }
 
 
-		boneMatrix = parentMatrix * (glm::translate(positionInterp) * glm::toMat4(rotationInterp) * glm::scale(scaleInterp));
-		boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
-	} else {
-        if (bone->Parent) {
-            boneMatrix = parentMatrix; // * glm::inverse(bone->OffsetMatrix);
+                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
+
         }
-		boneMatrices[bone->ID] = boneMatrix; // * bone->OffsetMatrix;
-	}
 
-	for (auto &child : bone->Children) {
-		std::string name = child->Name;
-		AccumulateBoneTransforms(noRootMotion, currentFrame, nextFrame, progress, boneMatrices, child, boneMatrix);
-	}
+    }
 
+
+    glm::mat4 offset = GetOffsetTransform(bone, animationOffset);
+
+    if (JointTransforms.size() == 0) {
+        if (bone->Parent) {
+            if (offset != glm::mat4(1)) {
+                boneMatrix = parentMatrix * offset;// *((glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix));
+            } else {
+                boneMatrix = parentMatrix  *((glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix));
+
+            }
+            boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
+        } else {
+            boneMatrix = offset * glm::inverse(bone->OffsetMatrix);
+            boneMatrices[bone->ID] = parentMatrix;
+        }
+    } 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 = parentMatrix * ((glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) + offset);
+        } else {
+            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, animationOffset, boneMatrices, child, boneMatrix);
+    }
+}
+
+glm::mat4 Skeleton::GetOffsetTransform(const Bone* bone, AnimationOffset animationOffset)
+{
+    const Animation* animation = animationOffset.animation;
+    float time = animationOffset.time;
+
+    glm::vec3 position = glm::vec3(0);
+    glm::quat rotation = glm::quat();
+    glm::vec3 scale = glm::vec3(1);
+
+    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);
+
+            }
+
+            progress = glm::clamp(progress, 0.0f, 1.0f);
+            
+            Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
+            Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
+
+            position = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+            rotation = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+            scale = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+
+        } else { // 1 keyframes for the current bone
+            currentFrame = boneKeyFrames.at(0);
+            position = currentFrame.BoneProperties.Position;
+            rotation = currentFrame.BoneProperties.Rotation;
+            scale = currentFrame.BoneProperties.Scale;
+        }
+    }
+
+    return (glm::translate(position) * glm::toMat4(rotation) * glm::scale(scale));
+}
+
+
+glm::mat4 Skeleton::GetBoneTransform(const Bone* bone, const Animation* animation, float time, glm::mat4 childMatrix)
+{
+    glm::mat4 boneMatrix;
+
+    Animation::Keyframe currentFrame;
+    Animation::Keyframe nextFrame;
+
+    if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
+        std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
+
+        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;
+
+            glm::vec3 positionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+            glm::quat rotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+            glm::vec3 scaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+            boneMatrix = (glm::translate(positionInterp) * glm::toMat4(rotationInterp) * glm::scale(scaleInterp)) * childMatrix;
+
+        } else { // 1 keyframes for the current bone
+            currentFrame = boneKeyFrames.at(0);
+            boneMatrix = (glm::translate(currentFrame.BoneProperties.Position) * glm::toMat4(currentFrame.BoneProperties.Rotation) * glm::scale(currentFrame.BoneProperties.Scale)) * childMatrix;
+
+        }
+    } else { // 0 keyframes for the current bone
+        if (bone->Parent) {
+            boneMatrix = bone->Parent->OffsetMatrix * glm::inverse(bone->OffsetMatrix) * childMatrix;
+        } else {
+            boneMatrix = glm::inverse(bone->OffsetMatrix) * childMatrix;
+        }
+    }
+
+    if (bone->Parent) {
+        return  GetBoneTransform(bone->Parent, animation, time, boneMatrix);
+    } else {
+        return boneMatrix;
+    }
+}
+
+
+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) {
+                    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) {
+                    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)
@@ -134,11 +719,13 @@ void Skeleton::PrintSkeleton(const Bone* bone, int depthCount)
 
 int Skeleton::GetKeyframe(const Animation& animation, double time)
 {
+
+/*
 	if (time < 0) {
 		time = 0;
 	}
 	if (time >= animation.Duration) {
-		return animation.Keyframes.size() - 1;
+		return animation..size() - 1;
 	}
 
 	for (int keyframe = 0; keyframe < animation.Keyframes.size(); ++keyframe) {
@@ -146,6 +733,8 @@ int Skeleton::GetKeyframe(const Animation& animation, double time)
 			return (keyframe - 1) % animation.Keyframes.size();
 		}
 	}
+*/
+
 
 	return 0;
 }

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,10 +33,11 @@ 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);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     GLERROR("Texture load");
 }

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

@@ -1,6 +1,6 @@
 project(TacticalZ-Game)
 
-find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono)
+find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono program_options)
 
 set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include/Game)
 include_directories(
@@ -16,19 +16,31 @@ 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"
 )
 source_group(Events FILES ${SOURCE_FILES_Events})
 
+file(GLOB SOURCE_FILES_Network
+	"${INCLUDE_PATH}/Network/*.h"
+	"Network/*.cpp"
+)
+source_group(Network FILES ${SOURCE_FILES_Network})
 set(SOURCE_FILES
     ${SOURCE_FILES}
     "Game.cpp"
+	"MiniDump.cpp"
     ${SOURCE_FILES_Systems}
+    ${SOURCE_FILES_Systems_Weapon}
     ${SOURCE_FILES_Events}
-
-    
+	${SOURCE_FILES_Network}
 )
 
 set(LIBRARIES

src/Game/Game.cpp

@@ -12,19 +12,32 @@
 #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/PlayerHUD.h"
+#include "Game/Systems/AmmoPickupSystem.h"
+#include "Game/Systems/DamageIndicatorSystem.h"
+#include "Game/Systems/Weapon/WeaponSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Game/Systems/HealthHUDSystem.h"
+#include "Rendering/BoneAttachmentSystem.h"
 #include "Game/Systems/LifetimeSystem.h"
-#include "../Engine/Rendering/AnimationSystem.h"
+#include "../Engine/Core/UniformScaleSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Network/MultiplayerSnapshotFilter.h"
+#include "Game/Systems/AmmunitionHUDSystem.h"
+#include "Game/Systems/KillFeedSystem.h"
+
 
 Game::Game(int argc, char* argv[])
 {
+    parseArgs(argc, argv);
+
     ResourceManager::RegisterType<ConfigFile>("ConfigFile");
     ResourceManager::RegisterType<Sound>("Sound");
     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");
@@ -33,6 +46,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();
@@ -77,6 +91,18 @@ Game::Game(int argc, char* argv[])
     // Create the sound manager
     m_SoundManager = new SoundManager(m_World, m_EventBroker);
 
+    // Initialize network
+    if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
+        if (m_IsServer) {
+            m_NetworkServer = new Server(m_World, m_EventBroker, m_NetworkPort);
+            m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " SERVER");
+        } else if (m_IsClient) {
+            m_NetworkClient = new Client(m_World, m_EventBroker, std::make_unique<MultiplayerSnapshotFilter>(m_EventBroker));
+            m_NetworkClient->Connect(m_NetworkAddress, m_NetworkPort);
+            m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " CLIENT");
+        }
+    }
+
     // Create Octrees
     // TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
     AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
@@ -84,33 +110,40 @@ Game::Game(int argc, char* argv[])
     m_OctreeTrigger = new Octree<EntityAABB>(boxContainingTheWorld, 4);
     m_OctreeFrustrumCulling = new Octree<EntityAABB>(boxContainingTheWorld, 4);
     // Create system pipeline
-    m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker);
+    m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker, m_IsClient, m_IsServer);
 
     // All systems with orderlevel 0 will be updated first.
     unsigned int updateOrderLevel = 0;
+    m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
+    ++updateOrderLevel;
     m_SystemPipeline->AddSystem<SoundSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<ExplosionEffectSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer);
+    m_SystemPipeline->AddSystem<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);
+    m_SystemPipeline->AddSystem<AmmunitionHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<KillFeedSystem>(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<PlayerHUD>(updateOrderLevel);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
-
+    m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<HealthHUDSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
     // Collision and TriggerSystem should update after player.
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
     ++updateOrderLevel;
@@ -118,12 +151,6 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
 
-    // Invoke network
-    if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
-        //boost::thread workerThread(&Game::networkFunction, this);
-        networkFunction();
-    }
-
     m_LastTime = glfwGetTime();
 }
 
@@ -134,6 +161,12 @@ Game::~Game()
     delete m_OctreeCollision;
     delete m_OctreeTrigger;
     delete m_SoundManager;
+    if (m_NetworkClient != nullptr) {
+        delete m_NetworkClient;
+    }
+    if (m_NetworkServer != nullptr) {
+        delete m_NetworkServer;
+    }
     delete m_World;
     delete m_FrameStack;
     delete m_InputProxy;
@@ -164,40 +197,56 @@ void Game::Tick()
     m_SoundManager->Update(dt);
 
     // Update network
-    if (m_IsClientOrServer) {
-        m_ClientOrServer->Update();
+    m_EventBroker->Process<MultiplayerSnapshotFilter>();
+    if (m_NetworkClient != nullptr) {
+        m_NetworkClient->Update();
+    }
+    if (m_NetworkServer != nullptr) {
+        m_NetworkServer->Update();
     }
     //m_SoundManager->Update(dt);
 
     // Iterate through systems and update world!
     m_EventBroker->Process<SystemPipeline>();
     m_SystemPipeline->Update(dt);
-    debugTick(dt);
     m_Renderer->Update(dt);
-    GLERROR("Game::Tick m_RenderQueueFactory->Update");
     m_Renderer->Draw(*m_RenderFrame);
     m_RenderFrame->Clear();
-    GLERROR("Game::Tick m_Renderer->Draw");
     m_EventBroker->Swap();
     m_EventBroker->Clear();
 }
 
-void Game::debugTick(double dt)
+int Game::parseArgs(int argc, char* argv[])
 {
-    m_EventBroker->Process<Game>();
+    namespace po = boost::program_options;
+
+    po::options_description desc("Options");
+    desc.add_options()
+        ("help", "Help")
+        ("server,s", po::bool_switch(&m_IsServer), "Launch game in server mode")
+        ("connect", po::value<std::string>(&m_NetworkAddress)->default_value(""), "Connect to this address in client mode")
+        ("port,p", po::value<int>(&m_NetworkPort), "Port to listen on or connect to");
+    ;
+
+    po::variables_map vm;
+    try {
+        po::store(po::parse_command_line(argc, argv, desc), vm);
+        po::notify(vm);
+    } catch (std::exception& e) {
+        LOG_ERROR(e.what());
+        return 1;
+    }
+
+    if (vm.count("help")) {
+        std::cout << desc << std::endl;
+        exit(1);
+    }
+
+    // HACK: Right now, client and server are mutually exclusive
+    m_IsClient = true;
+    if (m_IsServer) {
+        m_IsClient = false;
+    }
+
+    return 0;
 }
-
-void Game::networkFunction()
-{
-    bool isServer = m_Config->Get<bool>("Networking.IsServer", false);
-    if (!isServer) {
-        m_IsClientOrServer = true;
-        m_ClientOrServer = new Client(m_Config);
-    }
-    if (isServer) {
-        m_IsClientOrServer = true;
-        m_ClientOrServer = new Server();
-    }
-    m_ClientOrServer->Start(m_World, m_EventBroker);
-
-}

src/Game/MiniDump.cpp

@@ -0,0 +1,110 @@
+/*
+	Author:	Vladimir Sedach.
+
+	Purpose: demo of Call Stack creation by our own means,
+	and with MiniDumpWriteDump() function of DbgHelp.dll.
+*/
+
+#include <iostream>
+#include <ctime>
+
+#include <windows.h>
+#include <tlhelp32.h>
+//#include "dbghelp.h"
+
+//#define DEBUG_DPRINTF		1	//allow d()
+//#include "wfun.h"
+
+#pragma optimize("y", off)		//generate stack frame pointers for all functions - same as /Oy- in the project
+#pragma warning(disable: 4200)	//nonstandard extension used : zero-sized array in struct/union
+#pragma warning(disable: 4100)	//unreferenced formal parameter
+
+// In case you don't have dbghelp.h.
+#ifndef _DBGHELP_
+
+typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
+	DWORD	ThreadId;
+	PEXCEPTION_POINTERS	ExceptionPointers;
+	BOOL	ClientPointers;
+} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
+
+typedef enum _MINIDUMP_TYPE {
+	MiniDumpNormal =			0x00000000,
+	MiniDumpWithDataSegs =		0x00000001,
+} MINIDUMP_TYPE;
+
+typedef	BOOL (WINAPI * MINIDUMP_WRITE_DUMP)(
+	IN HANDLE			hProcess,
+	IN DWORD			ProcessId,
+	IN HANDLE			hFile,
+	IN MINIDUMP_TYPE	DumpType,
+	IN CONST PMINIDUMP_EXCEPTION_INFORMATION	ExceptionParam, OPTIONAL
+	IN PVOID									UserStreamParam, OPTIONAL
+	IN PVOID									CallbackParam OPTIONAL
+	);
+
+#else
+
+typedef	BOOL (WINAPI * MINIDUMP_WRITE_DUMP)(
+	IN HANDLE			hProcess,
+	IN DWORD			ProcessId,
+	IN HANDLE			hFile,
+	IN MINIDUMP_TYPE	DumpType,
+	IN CONST PMINIDUMP_EXCEPTION_INFORMATION	ExceptionParam, OPTIONAL
+	IN PMINIDUMP_USER_STREAM_INFORMATION		UserStreamParam, OPTIONAL
+	IN PMINIDUMP_CALLBACK_INFORMATION			CallbackParam OPTIONAL
+	);
+#endif //#ifndef _DBGHELP_
+
+HMODULE	hDbgHelp;
+MINIDUMP_WRITE_DUMP	MiniDumpWriteDump_;
+
+// Tool Help functions.
+typedef	HANDLE (WINAPI * CREATE_TOOL_HELP32_SNAPSHOT)(DWORD dwFlags, DWORD th32ProcessID);
+
+//*************************************************************************************
+void WINAPI Create_Dump(PEXCEPTION_POINTERS pException, BOOL File_Flag, BOOL Show_Flag)
+//*************************************************************************************
+// Create dump. 
+// pException can be either GetExceptionInformation() or NULL.
+// If File_Flag = TRUE - write dump files (.dmz and .dmp) with the name of the current process.
+// If Show_Flag = TRUE - show message with Get_Exception_Info() dump.
+{
+    // Try to get MiniDumpWriteDump() address.
+    hDbgHelp = LoadLibrary("DBGHELP.DLL");
+    MiniDumpWriteDump_ = (MINIDUMP_WRITE_DUMP)GetProcAddress(hDbgHelp, "MiniDumpWriteDump");
+
+	// If MiniDumpWriteDump() of DbgHelp.dll available.
+	if (MiniDumpWriteDump_)
+	{
+	    HANDLE	hDump_File;
+	    CHAR	Dump_Path[MAX_PATH];
+
+	    GetModuleFileName(NULL, Dump_Path, sizeof(Dump_Path));	//path of current process
+        std::time_t t = std::time(NULL);
+        char tStr[16];
+        std::strftime(tStr, 32, " %a %H-%M-%S", std::localtime(&t));
+        std::string time(tStr);
+        std::string path(Dump_Path);
+        path = path.substr(0, path.length() - 4);
+        path += time + ".dmp";
+
+		MINIDUMP_EXCEPTION_INFORMATION	M;
+		M.ThreadId = GetCurrentThreadId();
+		M.ExceptionPointers = pException;
+		M.ClientPointers = 0;
+
+		hDump_File = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+
+		MiniDumpWriteDump_(GetCurrentProcess(), GetCurrentProcessId(), hDump_File,
+			MiniDumpNormal, (pException) ? &M : NULL, NULL, NULL);
+
+		CloseHandle(hDump_File);
+
+        std::cout << "Memory dumped to: \"" << path.c_str() << "\"";
+        MessageBox(NULL, ("Application crashed, memory dumped to: " + path).c_str(), "MiniDump", MB_ICONHAND | MB_OK);
+    } else {
+        MessageBox(NULL, "Application crashed, memory dump failed.", "MiniDump", MB_ICONHAND | MB_OK);
+    }
+}
+

src/Game/Network/MultiplayerSnapshotFilter.cpp

@@ -0,0 +1,42 @@
+#include "Network/MultiplayerSnapshotFilter.h"
+
+MultiplayerSnapshotFilter::MultiplayerSnapshotFilter(EventBroker* eventBroker) 
+    : m_EventBroker(eventBroker)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &MultiplayerSnapshotFilter::OnPlayerSpawned);
+}
+
+bool MultiplayerSnapshotFilter::FilterComponent(EntityWrapper entity, SharedComponentWrapper& component)
+{
+    if (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) {
+        if (
+            component.Info.Name == "Transform"
+            || component.Info.Name == "Physics"
+            || component.Info.Name == "AssaultWeapon"
+            || component.Info.Name == "Animation"
+            || component.Info.Name == "AnimationOffset"
+            || entity.Name() == "PlayerName"
+        ) {
+            return false;
+        }
+    }
+
+    if (component.Info.Name == "Physics") {
+        return false;
+    }
+
+    if (component.Info.Name == "Transform" || component.Info.Name == "Physics") {
+        m_EventBroker->Publish(Events::Interpolate(entity, component));
+        return false;
+    }
+
+    return true;
+}
+
+bool MultiplayerSnapshotFilter::OnPlayerSpawned(Events::PlayerSpawned ePlayerSpawned)
+{
+    if (ePlayerSpawned.PlayerID == -1) {
+        m_LocalPlayer = ePlayerSpawned.Player;
+    }
+    return true;
+}

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/AmmunitionHUDSystem.cpp

@@ -0,0 +1,36 @@
+#include "Game/Systems/AmmunitionHUDSystem.h"
+
+void AmmunitionHUDSystem::Update(double dt)
+{
+    //Hud element for tracking ammunition from parent with AssaultWeapon component.Child with the name "MagazineAmmo" tracks clip ammunition.Child with the name "Ammo" tracks ammo.</xs:documentation>
+
+    auto ammunitionHUDs = m_World->GetComponents("AmmunitionHUD");
+    if (ammunitionHUDs == nullptr) {
+        return;
+    }
+
+    for (auto& ammunitionHUDComponent : *ammunitionHUDs) {
+        EntityWrapper entity = EntityWrapper(m_World, ammunitionHUDComponent.EntityID);
+
+        EntityWrapper playerEntity = entity.FirstParentWithComponent("AssaultWeapon");
+
+        if (!playerEntity.Valid()) {
+            return;
+        }
+        
+
+        EntityWrapper magazineAmmo = entity.FirstChildByName("MagazineAmmo");
+        if(magazineAmmo.Valid()) {
+            if(magazineAmmo.HasComponent("Text")) {
+                (std::string&)magazineAmmo["Text"]["Content"] = std::to_string((int)playerEntity["AssaultWeapon"]["MagazineAmmo"]);
+            }
+        }
+
+        EntityWrapper ammo = entity.FirstChildByName("Ammo");
+        if (ammo.Valid()) {
+            if (ammo.HasComponent("Text")) {
+                (std::string&)ammo["Text"]["Content"] = std::to_string((int)playerEntity["AssaultWeapon"]["Ammo"]);
+            }
+        }
+    }
+}

src/Game/Systems/CapturePointHUDSystem.cpp

@@ -0,0 +1,59 @@
+#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;
+    }
+
+    if(!CapturePointHUDElements) {
+        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

@@ -1,20 +1,26 @@
 #include "Systems/CapturePointSystem.h"
 #include <algorithm>
 
-CapturePointSystem::CapturePointSystem(World* world, EventBroker* eventBroker) 
-    : System(world, eventBroker)
+CapturePointSystem::CapturePointSystem(SystemParams params) 
+    : System(params)
     , PureSystem("CapturePoint")
 {
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
-    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
-    EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
-    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
+    if (IsClient) {
+        EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
+        EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
+        EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
+    }
 }
 
 //here all capturepoints will update their component
 //NOTE: needs to run each frame, since we're possibly modifying the captureTimer for the capturePoints by dt
 void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, ComponentWrapper& cCapturePoint, double dt)
 {
+    if (!IsClient) {
+        return;
+    }
+
     if (m_WinnerWasFound) {
         return;
     }
@@ -32,6 +38,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 +64,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 +105,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 +173,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 +180,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,76 @@
+#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.Victim.Valid() && e.Victim != LocalPlayer && !e.Victim.IsChildOf(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/ExplosionEffectSystem.cpp

@@ -0,0 +1,14 @@
+#include "Systems/ExplosionEffectSystem.h"
+
+void ExplosionEffectSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+{
+    if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
+        (double)component["TimeSinceDeath"] = 0.f;
+    }
+    (double&)component["TimeSinceDeath"] += dt;
+
+    //if ((bool)Component["Gravity"] == true) {
+    //    (bool)Component["ExponentialAccelaration"] = false;
+    //}
+}
+

src/Game/Systems/HealthHUDSystem.cpp

@@ -1,21 +1,6 @@
-#include "Game/Systems/PlayerHUD.h"
+#include "Game/Systems/HealthHUDSystem.h"
 
-PlayerHUD::PlayerHUD(World* world, EventBroker* eventBrokerer)
-    :System(world, eventBrokerer)
-    , m_World(world)
-    , m_EventBroker(eventBrokerer)
-{
-    
-    
-}
-
-PlayerHUD::~PlayerHUD()
-{
-    
-
-}
-
-void PlayerHUD::Update(double dt)
+void HealthHUDSystem::Update(double dt)
 {
     auto healthHUDs = m_World->GetComponents("HealthHUD");
     if (healthHUDs == nullptr) {
@@ -42,13 +27,13 @@ void PlayerHUD::Update(double dt)
                 s = s + "/";
                 s = s + std::to_string((int)(double)entityIDParent["Health"]["MaxHealth"]);
                 float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
-                (glm::vec4&)entity["Text"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, 1.f);
+                //(glm::vec4&)entity["Text"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Text"]["Color"]).a);
                 entity["Text"]["Content"] = s;
             }
 
             if(entity.HasComponent("Fill")) {
                 float healthPercentage = (double)entityIDParent["Health"]["Health"]/(double)entityIDParent["Health"]["MaxHealth"];
-                (glm::vec4&)entity["Fill"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, 0.f);
+                (glm::vec4&)entity["Fill"]["Color"] = glm::vec4(1.0 - healthPercentage, 0.f, healthPercentage, glm::vec4(entity["Fill"]["Color"]).a);
                 (double&)entity["Fill"]["Percentage"] = healthPercentage;
 
             }

src/Game/Systems/HealthSystem.cpp

@@ -1,34 +1,52 @@
 #include "Systems/HealthSystem.h"
 
-HealthSystem::HealthSystem(World* m_World, EventBroker* eventBroker)
-    : System(m_World, eventBroker)
+HealthSystem::HealthSystem(SystemParams params)
+    : System(params)
     , PureSystem("Health")
 {
     //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);
+    m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
 }
 
-void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cHealth, double dt)
 {
+    double& health = cHealth["Health"];
+    if (health <= 0.0) {
+        Events::PlayerDeath ePlayerDeath;
+        ePlayerDeath.Player = entity;
+        m_EventBroker->Publish(ePlayerDeath);
+        //Note: we will delete the entity in PlayerDeathSystem
+    }
 }
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
 {
-    ComponentWrapper cHealth = e.Player["Health"];
+    if (!IsServer && m_NetworkEnabled) {
+        return false;
+    }
+
+    ComponentWrapper cHealth = e.Victim["Health"];
     double& health = cHealth["Health"];
     if (e.Player.HasComponent("BoostDefender")) {
         e.Damage -= (double)e.Player["BoostDefender"]["StrengthOfEffect"];
     }
     health -= e.Damage;
 
-    if (health <= 0.0) {
-        Events::PlayerDeath ePlayerDeath;
-        ePlayerDeath.Player = e.Player;
-        m_EventBroker->Publish(ePlayerDeath);
-        //Note: we will delete the entity in PlayerDeathSystem
-    }
+    return true;
+}
 
+bool HealthSystem::OnInputCommand(Events::InputCommand& e)
+{
+    if (e.Command == "TakeDamage" && e.Value > 0 && LocalPlayer.Valid()) {
+        Events::PlayerDamage ev;
+        ev.Inflictor = LocalPlayer;
+        ev.Victim = LocalPlayer;
+        ev.Damage = e.Value;
+        m_EventBroker->Publish(ev);
+    }
     return true;
 }
 

src/Game/Systems/InterpolationSystem.cpp

@@ -1,84 +1,98 @@
 #include "Systems/InterpolationSystem.h"
 
-InterpolationSystem::InterpolationSystem(World* world, EventBroker* eventBroker) 
-    : System(world, eventBroker)
-    , PureSystem("Transform")
+InterpolationSystem::InterpolationSystem(SystemParams params) 
+    : System(params)
 {
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05f);
     EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &InterpolationSystem::OnPlayerSpawned);
 }
 
-void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt)
+void InterpolationSystem::Update(double dt)
 {
-    // Don't interpolate entities that might already have been removed
-    if (!entity.Valid()) {
-        return;
+    // Position
+    for (auto& kv : m_InterpolatePosition) {
+        EntityWrapper entity = kv.first;
+        if (!entity.Valid()) {
+            continue;
+        }
+        auto& iPosition = kv.second;
+        glm::vec3& position = iPosition.Component[iPosition.Field];
+
+        iPosition.Alpha += dt;
+        float alpha = glm::min(iPosition.Alpha / m_SnapshotInterval, 1.0);
+        position = iPosition.Start + ((iPosition.Goal - iPosition.Start) * alpha);
     }
 
-    if (m_NextTransform.find(transform.EntityID) != m_NextTransform.end()) { // Exists in map
-        m_NextTransform[transform.EntityID].interpolationTime += static_cast<float>(dt);
-        Transform sTransform = m_NextTransform[transform.EntityID];
-        float time = sTransform.interpolationTime;
-        if (time > m_SnapshotInterval) {
-            if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
-                m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];
-                m_NextTransform[transform.EntityID].interpolationTime = time - m_SnapshotInterval;
-                sTransform = m_NextTransform[transform.EntityID];
-                m_LastReceivedTransform.erase(transform.EntityID);
-            } else {
-                m_NextTransform.erase(transform.EntityID);
-            }
+    // Orientation
+    for (auto& kv : m_InterpolateOrientation) {
+        EntityWrapper entity = kv.first;
+        if (!entity.Valid()) {
+            continue;
         }
-        if (transform.Info.Name == "Transform") {
-            bool isLocalPlayer = entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer);
-            // Position
-            glm::vec3 nextPosition = sTransform.Position;
-            glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
-            // HACK: Don't force position for players 
-            if (!isLocalPlayer) {
-                (glm::vec3&)transform["Position"] += vectorInterpolation<glm::vec3>(currentPosition, nextPosition, sTransform.interpolationTime);
-            }
-            // Orientation
-            // Don't force orientation for players
-            if (!isLocalPlayer) {
-                glm::quat nextOrientation = sTransform.Orientation;
-                glm::quat currentOrientation = glm::quat(static_cast<glm::vec3>(transform["Orientation"]));
-                (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / m_SnapshotInterval));
-            }
-            // Scale
-            glm::vec3 nextScale = sTransform.Scale;
-            glm::vec3 currentScale = static_cast<glm::vec3>(transform["Scale"]);
-            (glm::vec3&)transform["Scale"] += vectorInterpolation<glm::vec3>(currentScale, nextScale, sTransform.interpolationTime);
+        auto& iOrientation = kv.second;
+        glm::vec3& orientation = iOrientation.Component[iOrientation.Field];
+
+        iOrientation.Alpha += dt / m_SnapshotInterval;
+        iOrientation.Alpha = glm::min(iOrientation.Alpha, 1.0);
+        orientation = glm::eulerAngles(glm::slerp(iOrientation.Start, iOrientation.Goal, (float)iOrientation.Alpha));
+    }
+
+    // Velocity
+    for (auto& kv : m_InterpolateVelocity) {
+        EntityWrapper entity = kv.first;
+        if (!entity.Valid()) {
+            continue;
         }
+        auto& iVelocity = kv.second;
+        glm::vec3& position = iVelocity.Component[iVelocity.Field];
+
+        iVelocity.Alpha += dt;
+        float alpha = glm::min(iVelocity.Alpha / m_SnapshotInterval, 1.0);
+        position = iVelocity.Start + ((iVelocity.Goal - iVelocity.Start) * alpha);
     }
 }
 
-bool InterpolationSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+bool InterpolationSystem::OnInterpolate(Events::Interpolate& e)
 {
-    m_LocalPlayer = e.Player;
+    if (e.Component.Info.Name == "Transform") {
+        auto cTransform = e.Entity["Transform"];
+
+        // Position
+        Interpolation<glm::vec3> iPosition(
+            cTransform,
+            "Position",
+            cTransform["Position"],
+            e.Component["Position"]
+        );
+        m_InterpolatePosition.erase(e.Entity);
+        m_InterpolatePosition.insert(std::make_pair(e.Entity, iPosition));
+
+        // Orientation
+        Interpolation<glm::quat> iOrientation(
+            cTransform,
+            "Orientation",
+            glm::quat((glm::vec3&)cTransform["Orientation"]),
+            glm::quat((glm::vec3&)e.Component["Orientation"])
+        );
+        m_InterpolateOrientation.erase(e.Entity);
+        m_InterpolateOrientation.insert(std::make_pair(e.Entity, iOrientation));
+    } else if (e.Component.Info.Name == "Physics") {
+        auto cPhysics = e.Entity["Physics"];
+        if (!e.Entity.HasComponent("Player")) {
+            return false;
+        }
+
+        // Velocity
+        Interpolation<glm::vec3> iVelocity(
+            cPhysics,
+            "Velocity",
+            cPhysics["Velocity"],
+            e.Component["Velocity"]
+        );
+        m_InterpolateVelocity.erase(e.Entity);
+        m_InterpolateVelocity.insert(std::make_pair(e.Entity, iVelocity));
+    }
+
     return true;
 }
-
-bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
-{
-    Transform transform;
-    int offset = 0;
-    // Read the data
-    memcpy(&transform.Position, e.DataArray.get() + offset, sizeof(glm::vec3));
-    offset += sizeof(glm::vec3);
-    glm::vec3 tempOrientation;
-    memcpy(&tempOrientation, e.DataArray.get() + offset, sizeof(glm::vec3));
-    transform.Orientation = glm::quat(tempOrientation);
-    offset += sizeof(glm::vec3);
-    memcpy(&transform.Scale, e.DataArray.get() + offset, sizeof(glm::vec3));
-    transform.interpolationTime = 0.0f;
-
-    if (m_NextTransform.find(e.Entity) != m_NextTransform.end()) { // Did exist
-        m_LastReceivedTransform[e.Entity] = transform;
-    } else { // Did not
-        m_NextTransform[e.Entity] = transform;
-    }
-    return false;
-}

src/Game/Systems/KillFeedSystem.cpp

@@ -0,0 +1,80 @@
+#include "Game/Systems/KillFeedSystem.h"
+
+void KillFeedSystem::Update(double dt)
+{
+    auto killFeeds = m_World->GetComponents("KillFeed");
+    if (killFeeds == nullptr) {
+        return;
+    }
+
+    for (auto& killFeedComponent : *killFeeds) {
+        EntityWrapper entity = EntityWrapper(m_World, killFeedComponent.EntityID);
+
+        for (int i = 1; i <= 3; i++) {
+            EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(i));
+            if (child.HasComponent("Text")) {
+                (std::string&)child["Text"]["Content"] = "";
+            }
+        }
+        
+
+
+
+        int feedIndex = 1;
+        for (auto it = m_DeathQueue.begin(); it != m_DeathQueue.end(); ) {
+            bool remove = false;
+            
+            EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(feedIndex));
+
+            if (child.HasComponent("Text")) {
+                (std::string&)child["Text"]["Content"] = (*it).Content;
+                (glm::vec4&)child["Text"]["Color"] = (*it).Color;
+
+                (*it).TimeToLive -= dt;
+
+                if ((*it).TimeToLive <= 0.f) {
+                    (std::string&)child["Text"]["Content"] = "";
+                    (glm::vec4&)child["Text"]["Color"] = (*it).Color;
+                    remove = true;
+                }
+            }
+            feedIndex++;
+            if(feedIndex > 3) {
+                break;
+            }
+
+            if(remove) {
+                it = m_DeathQueue.erase(it);
+            } else {
+                it++;
+            }
+        }
+    }
+}
+
+bool KillFeedSystem::OnPlayerDeath(Events::PlayerDeath& e)
+{
+    KillFeedInfo kfInfo;
+
+    if (e.Player.HasComponent("Team")) {
+        int red = e.Player["Team"].Enum("Team", "Red");
+        int blue = e.Player["Team"].Enum("Team", "Blue");
+
+        if ((int)e.Player["Team"]["Team"] == red) {
+            kfInfo.Content = "Blue Player killed Red Player";
+            kfInfo.Color = glm::vec4(0.f, 0.2f, 1.f, 0.8f);
+            m_DeathQueue.push_back(kfInfo);
+        } else if ((int)e.Player["Team"]["Team"] == blue) {
+            kfInfo.Content = "Red Player killed blue Player";
+            kfInfo.Color = glm::vec4(1.f, 0.f, 0.f, 0.8f);
+            m_DeathQueue.push_back(kfInfo);
+        }
+    }
+
+
+    if(m_DeathQueue.size() > 3) {
+        m_DeathQueue.pop_front();
+    }
+
+    return true;
+}

src/Game/Systems/PickupSpawnSystem.cpp

@@ -1,7 +1,7 @@
 #include "Systems/PickupSpawnSystem.h"
 
-PickupSpawnSystem::PickupSpawnSystem(World* m_World, EventBroker* eventBroker)
-    : System(m_World, eventBroker)
+PickupSpawnSystem::PickupSpawnSystem(SystemParams params)
+    : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &PickupSpawnSystem::OnTriggerTouch);
 }

src/Game/Systems/PlayerDeathSystem.cpp

@@ -1,7 +1,7 @@
 #include "Systems/PlayerDeathSystem.h"
 
-PlayerDeathSystem::PlayerDeathSystem(World* m_World, EventBroker* eventBroker)
-    : System(m_World, eventBroker)
+PlayerDeathSystem::PlayerDeathSystem(SystemParams params)
+    : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerDeathSystem::OnPlayerDeath);
 }
@@ -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

@@ -1,8 +1,7 @@
 #include "Systems/PlayerMovementSystem.h"
 
-PlayerMovementSystem::PlayerMovementSystem(World* world, EventBroker* eventBroker)
-    : System(world, eventBroker)
-    , PureSystem("Player")
+PlayerMovementSystem::PlayerMovementSystem(SystemParams params)
+    : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &PlayerMovementSystem::OnPlayerSpawned);
 }
@@ -15,6 +14,12 @@ PlayerMovementSystem::~PlayerMovementSystem()
 }
 
 void PlayerMovementSystem::Update(double dt)
+{
+    updateMovementControllers(dt);
+    updateVelocity(dt);
+}
+
+void PlayerMovementSystem::updateMovementControllers(double dt)
 {
     for (auto& kv : m_PlayerInputControllers) {
         EntityWrapper player = kv.first;
@@ -24,12 +29,21 @@ void PlayerMovementSystem::Update(double dt)
             continue;
         }
 
+        // Aim pitch
         EntityWrapper cameraEntity = player.FirstChildByName("Camera");
         if (cameraEntity.Valid()) {
             glm::vec3& cameraOrientation = cameraEntity["Transform"]["Orientation"];
             cameraOrientation.x += controller->Rotation().x;
             // Limit camera pitch so we don't break our necks
             cameraOrientation.x = glm::clamp(cameraOrientation.x, -glm::half_pi<float>(), glm::half_pi<float>());
+            // Set third person model aim pitch
+            EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
+            if (playerModel.Valid()) {
+                ComponentWrapper cAnimationOffset = playerModel["AnimationOffset"];
+                float pitch = cameraOrientation.x + 0.2;
+                double time = (pitch + glm::half_pi<float>()) / glm::pi<float>();
+                cAnimationOffset["Time"] = time;
+            }
         }
 
         ComponentWrapper& cTransform = player["Transform"];
@@ -38,6 +52,7 @@ void PlayerMovementSystem::Update(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"];
@@ -45,7 +60,7 @@ void PlayerMovementSystem::Update(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));
@@ -64,18 +79,18 @@ void PlayerMovementSystem::Update(double dt)
             }
             glm::vec3& velocity = cPhysics["Velocity"];
             bool isOnGround = (bool)cPhysics["IsOnGround"];
-            ImGui::Text(isOnGround ? "On ground" : "In air");
-            ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
+            //ImGui::Text(isOnGround ? "On ground" : "In air");
+            //ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             glm::vec3 groundVelocity(0.f, 0.f, 0.f);
             groundVelocity.x = velocity.x;
             groundVelocity.z = velocity.z;
-            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(groundVelocity));
-            ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
+            //ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(groundVelocity));
+            //ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
             float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
             float addSpeed = wishSpeed - currentSpeedProj;
-            ImGui::Text("currentSpeedProj: %f", currentSpeedProj);
-            ImGui::Text("wishSpeed: %f", wishSpeed);
-            ImGui::Text("addSpeed: %f", addSpeed);
+            //ImGui::Text("currentSpeedProj: %f", currentSpeedProj);
+            //ImGui::Text("wishSpeed: %f", wishSpeed);
+            //ImGui::Text("addSpeed: %f", addSpeed);
 
             if (addSpeed > 0) {
                 static float accel = 15.f;
@@ -100,12 +115,20 @@ void PlayerMovementSystem::Update(double dt)
             //you cant jump and dash at the same time - since there is no friction in the air and we would thus dash much further in the air
             if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (isOnGround || !controller->DoubleJumping())) {
                 (bool)cPhysics["IsOnGround"] = false;
-                if (velocity.y == 0.f) {
+                if (isOnGround) {
                     controller->SetDoubleJumping(false);
                 } else {
-                    controller->SetDoubleJumping(true);
-                    Events::DoubleJump e;
-                    m_EventBroker->Publish(e);
+                    if (IsClient) {
+                        //put a hexagon at the players feet
+                        auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
+                        EntityFileParser parser(hexagonEffect);
+                        EntityID hexagonEffectID = parser.MergeEntities(m_World);
+                        EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
+                        hexagonEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
+                        controller->SetDoubleJumping(true);
+                        Events::DoubleJump e;
+                        m_EventBroker->Publish(e);
+                    }
                 }
                 velocity.y = 4.f;
             }
@@ -123,24 +146,74 @@ void PlayerMovementSystem::Update(double dt)
             EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
             if (playerModel.Valid()) {
                 ComponentWrapper cAnimation = playerModel["Animation"];
+                std::string& animationName1 = cAnimation["AnimationName1"];
+                std::string& animationName2 = cAnimation["AnimationName2"];
+                double& animationTime1 = cAnimation["Time1"];
+                double& animationTime2 = cAnimation["Time2"];
+                double& animationSpeed1 = cAnimation["Speed1"];
+                double& animationSpeed2 = cAnimation["Speed2"];
+                double& animationWeight1 = cAnimation["Weight1"];
+                double& animationWeight2 = cAnimation["Weight2"];
 
                 float movementLength = glm::length(groundVelocity);
                 //TODO: add assault dash animation here
                 if (glm::length(controller->Movement()) > 0.f) {
-                    if (controller->Crouching()) {
-                        cAnimation["Name"] = "Crouch Walk";
-                        (double&)cAnimation["Speed"] = 1.f * -glm::sign(controller->Movement().z);
+                    double forwardMovement = controller->Movement().z;
+                    double strafeMovement = controller->Movement().x;
+
+                    if (controller->Crouching() && animationName1 != "CrouchWalk") {
+                        animationName1 = "CrouchWalk";
+                        animationSpeed1 = 1.0 * -glm::sign(controller->Movement().z);
                     } else {
-                        cAnimation["Name"] = "Run";
-                        (double&)cAnimation["Speed"] = 2.f * -glm::sign(controller->Movement().z);
+                        if (glm::abs(forwardMovement) > 0) {
+                            if (animationName1 != "Run") {
+                                animationName1 = "Run";
+                                if (animationName2 == "StrafeLeft" || animationName2 == "StrafeRight") {
+                                    animationTime1 = animationTime2;
+                                } else {
+                                    animationTime1 = 0.0;
+                                }
+                            }
+                            animationSpeed1 = 2.f * -glm::sign(forwardMovement);
+                        }
+
+                        if (glm::abs(strafeMovement) > 0) {
+                            if (animationName2 != "StrafeLeft" && animationName2 != "StrafeRight") {
+                                if (strafeMovement < 0) {
+                                    animationName2 = "StrafeLeft";
+                                }
+                                if (strafeMovement > 0) {
+                                    animationName2 = "StrafeRight";
+                                }
+                                if (animationName1 == "Run") {
+                                    animationTime2 = animationTime1;
+                                } else {
+                                    animationTime2 = 0.0;
+                                }
+                            }
+                            animationSpeed2 = 2.f * glm::abs(strafeMovement);
+                        }
+
+                        double strafeWeight = glm::abs(strafeMovement) / (glm::abs(forwardMovement) + glm::abs(strafeMovement));
+                        animationWeight2 = strafeWeight;
+                        animationWeight1 = 1.0 - strafeWeight;
                     }
                 } else {
                     if (controller->Crouching()) {
-                        cAnimation["Name"] = "Crouch";
-                        (double&)cAnimation["Speed"] = 1.f;
+                        animationName1 = "Crouch";
+                        animationName2 = "";
+                        animationSpeed1 = 1.0;
+                        animationSpeed2 = 0.0;
+                        animationWeight1 = 1.0;
+                        animationWeight2 = 0.0;
                     } else {
-                        cAnimation["Name"] = "Hold Pos";
-                        (double&)cAnimation["Speed"] = 1.f;
+                        animationName1 = "Idle";
+                        animationName2 = "";
+                        animationSpeed1 = 1.f;
+                        animationSpeed2 = 0.0;
+                        animationWeight1 = 1.0;
+                        animationWeight2 = 0.0;
+                        //cAnimation["AnimationName2"] = "Idle";
                     }
                 }
             }
@@ -151,14 +224,16 @@ void PlayerMovementSystem::Update(double dt)
     playerStep(dt);
 }
 
-void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+
+void PlayerMovementSystem::updateVelocity(double dt)
 {
-    ComponentWrapper& cTransform = entity["Transform"];
-    if (!entity.HasComponent("Physics")) {
+    // Only apply velocity to local player
+    if (!LocalPlayer.Valid()) {
         return;
     }
 
-    ComponentWrapper& cPhysics = entity["Physics"];
+    ComponentWrapper& cTransform = LocalPlayer["Transform"];
+    ComponentWrapper& cPhysics = LocalPlayer["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
     bool isOnGround = (bool)cPhysics["IsOnGround"];
 
@@ -166,7 +241,8 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
     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) {
@@ -176,6 +252,7 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
         velocity.z *= multiplier;
     }
 
+    // Gravity
     if (cPhysics["Gravity"]) {
         velocity.y -= 9.82f * (float)dt;
     }
@@ -191,13 +268,12 @@ void PlayerMovementSystem::playerStep(double dt)
     }
     // Position of the local player, used see how far a player has moved.
     glm::vec3 pos = (glm::vec3)m_World->GetComponent(m_LocalPlayer.ID, "Transform")["Position"];
-    // Velocity of the local player, used to see if a player is airborne.
-    glm::vec3 vel = (glm::vec3)m_World->GetComponent(m_LocalPlayer.ID, "Physics")["Velocity"];
+    // Used to see if a player is airborne.
+    bool grounded = (bool)m_World->GetComponent(m_LocalPlayer.ID, "Physics")["IsOnGround"];
     m_DistanceMoved += glm::length(pos - m_LastPosition);
     // Set the last position for next iteration
     m_LastPosition = pos;
-    bool isAirborne = vel.y != 0;
-    if (m_DistanceMoved > m_PlayerStepLength && !isAirborne) {
+    if (m_DistanceMoved > m_PlayerStepLength && grounded) {
         // Player moved a step's distance
         // Create footstep sound
         Events::PlaySoundOnEntity e;

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,20 +1,39 @@
 #include "Systems/PlayerSpawnSystem.h"
 
-PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker) 
-    : System(m_World, eventBroker)
+//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,22 +121,27 @@ bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
 
 bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
-    // When a player is actually spawned (since the actual spawning is handled on the server)
-
-    // 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;
+    m_PlayerIDs[e.Player.ID] = e.PlayerID;
+
+    // When a player is actually spawned (since the actual spawning is handled on the server)
+    // Hack should be moved.
+
+    // TODO: Set the player name to whatever
+    EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
+    if (playerName.Valid()) {
+        playerName["Text"]["Content"] = e.PlayerName;
+    }
+
+    if (!IsClient) {
+        return false;
+    }
 
     // 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);
@@ -103,11 +159,32 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
         }
     }
 
-    // TODO: Set the player name to whatever
-    EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
-    if (playerName.Valid()) {
-        playerName["Text"]["Content"] = e.PlayerName;
+    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;
     }
 
+    if (m_PlayerIDs.count(e.Player.ID) == 0) {
+        return false;
+    }
+
+    SpawnRequest req;
+    req.PlayerID = m_PlayerIDs.at(e.Player.ID);
+    req.Team = cTeam["Team"];
+    m_SpawnRequests.push_back(req);
+
     return true;
-}
+}

src/Game/Systems/SoundSystem.cpp

@@ -1,22 +1,20 @@
 #include "Game/Systems/SoundSystem.h"
 
-SoundSystem::SoundSystem(World* world, EventBroker* eventbroker)
-    : System(world, eventbroker)
+SoundSystem::SoundSystem(SystemParams params)
+    : System(params)
     , PureSystem("SoundEmitter")
-    //, ImpureSystem()
 {
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Announcer = ResourceManager::Load<ConfigFile>("Config.ini")->Get<std::string>("Sound.Announcer", "female");
-    m_World = world;
-    m_EventBroker = eventbroker;
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundSystem::OnPlayerSpawned);
-    EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &SoundSystem::OnInputCommand);
-    EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &SoundSystem::OnDoubleJump);
-    EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &SoundSystem::OnDashAbility);
-    EVENT_SUBSCRIBE_MEMBER(m_EShoot, &SoundSystem::OnShoot);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
-    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
-    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
+    if (IsClient) {
+        EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundSystem::OnPlayerSpawned);
+        EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &SoundSystem::OnInputCommand);
+        EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &SoundSystem::OnDoubleJump);
+        EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &SoundSystem::OnDashAbility);
+        EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
+        EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
+        EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
+    }
 }
 
 void SoundSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComponent, double dt)
@@ -24,8 +22,12 @@ void SoundSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComp
 
 void SoundSystem::Update(double dt)
 {
+    if (!IsClient) {
+        return;
+    }
+
     // Temp for play test.
-    if(m_DrumsIsPlaying) {
+    if (m_DrumsIsPlaying) {
         m_DrumsIsPlaying = !drumTimer(dt);
     }
 }
@@ -34,9 +36,8 @@ bool SoundSystem::OnPlayerSpawned(const Events::PlayerSpawned &e)
 {
     if (e.PlayerID == -1) { // Local player
         m_World->AttachComponent(e.Player.ID, "Listener");
-        m_LocalPlayer = e.Player;
         Events::PlaySoundOnEntity go;
-        go.EmitterID = m_LocalPlayer.ID;
+        go.EmitterID = LocalPlayer.ID;
         go.FilePath = "Audio/announcer/" + m_Announcer + "/go.wav";
         m_EventBroker->Publish(go);
         // TEMP: starts bgm
@@ -57,22 +58,20 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
             return true;
         }
     }
-    if (e.Command == "TakeDamage" && e.Value > 0) {
-        Events::PlayerDamage ev;
-        ev.Player = m_LocalPlayer;
-        ev.Damage = 1.0;
-        m_EventBroker->Publish(ev);
-    }
 
     return false;
 }
 
 void SoundSystem::playerJumps()
 {
-    glm::vec3 vel = (glm::vec3)m_World->GetComponent(m_LocalPlayer.ID, "Physics")["Velocity"];
-    if (vel.y == 0) {
+    if (!LocalPlayer.Valid()) {
+        return;
+    }
+
+    bool grounded = (bool)m_World->GetComponent(LocalPlayer.ID, "Physics")["IsOnGround"];
+    if (grounded) {
         Events::PlaySoundOnEntity e;
-        e.EmitterID = m_LocalPlayer.ID;
+        e.EmitterID = LocalPlayer.ID;
         e.FilePath = "Audio/jump/jump1.wav";
         m_EventBroker->Publish(e);
     }
@@ -89,26 +88,17 @@ bool SoundSystem::drumTimer(double dt)
     }
 }
 
-bool SoundSystem::OnShoot(const Events::Shoot & e)
-{
-    Events::PlaySoundOnEntity ev;
-    ev.EmitterID = m_LocalPlayer.ID;
-    ev.FilePath = "Audio/laser/laser1.wav";
-    m_EventBroker->Publish(ev);
-    return true;
-}
-
 bool SoundSystem::OnCaptured(const Events::Captured & e)
 {
     int homeTeam = (int)m_World->GetComponent(e.CapturePointID, "Team")["Team"];
-    int team = (int)m_World->GetComponent(m_LocalPlayer.ID, "Team")["Team"];
+    int team = (int)m_World->GetComponent(LocalPlayer.ID, "Team")["Team"];
     Events::PlaySoundOnEntity ev;
     if (team == homeTeam) {
         ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_achieved.wav";
     } else {
         ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_failed.wav"; // have not been tested
     }
-    ev.EmitterID = m_LocalPlayer.ID;
+    ev.EmitterID = LocalPlayer.ID;
     m_EventBroker->Publish(ev);
     // Temp for play test.
     m_DrumsIsPlaying = false;
@@ -124,13 +114,13 @@ bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
     std::vector<std::string> paths;
     paths.push_back("Audio/hurt/hurt" + std::to_string(rand) + ".wav");
 
-//     // Breathe
-//     int ammountOfbreaths = (static_cast<int>(e.Damage) / 10) + 2; // TEMP: Idk something stupid like this shit
-//     for (int i = 0; i < ammountOfbreaths; i++) {
-//         paths.push_back("Audio/exhausted/breath.wav");
-//     }
+    //     // Breathe
+    //     int ammountOfbreaths = (static_cast<int>(e.Damage) / 10) + 2; // TEMP: Idk something stupid like this shit
+    //     for (int i = 0; i < ammountOfbreaths; i++) {
+    //         paths.push_back("Audio/exhausted/breath.wav");
+    //     }
     Events::PlayQueueOnEntity ev;
-    ev.Emitter = m_LocalPlayer;
+    ev.Emitter = LocalPlayer;
     ev.FilePaths = paths;
     m_EventBroker->Publish(ev);
     return false;
@@ -139,8 +129,8 @@ bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
 bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
 {
     Events::PlaySoundOnEntity ev;
-    ev.EmitterID = m_LocalPlayer.ID;
-    ev.FilePath = "Audio/die/die2.wav"; 
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/die/die2.wav";
     m_EventBroker->Publish(ev);
     return false;
 }
@@ -148,7 +138,7 @@ bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
 bool SoundSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup & e)
 {
     Events::PlaySoundOnEntity ev;
-    ev.EmitterID = m_LocalPlayer.ID;
+    ev.EmitterID = LocalPlayer.ID;
     ev.FilePath = "Audio/pickup/pickup2.wav";
     m_EventBroker->Publish(ev);
     return false;
@@ -162,7 +152,7 @@ bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
     }
     if (m_World->HasComponent(e.Trigger.ID, "CapturePoint")) {
         Events::PlaySoundOnEntity ev; // should be BGM
-        ev.EmitterID = m_LocalPlayer.ID;
+        ev.EmitterID = LocalPlayer.ID;
         ev.FilePath = "Audio/bgm/drumstest.wav";
         m_EventBroker->Publish(ev);
         // Temp for play test.
@@ -174,7 +164,7 @@ bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
 bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
 {
     Events::PlaySoundOnEntity ev;
-    ev.EmitterID = m_LocalPlayer.ID;
+    ev.EmitterID = LocalPlayer.ID;
     ev.FilePath = "Audio/jump/jump2.wav";
     m_EventBroker->Publish(ev);
     return false;
@@ -183,7 +173,7 @@ bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
 bool SoundSystem::OnDashAbility(const Events::DashAbility &e)
 {
     Events::PlaySoundOnEntity ev;
-    ev.EmitterID = m_LocalPlayer.ID;
+    ev.EmitterID = LocalPlayer.ID;
     ev.FilePath = "Audio/jump/dash1.wav";
     m_EventBroker->Publish(ev);
     return false;

src/Game/Systems/SpawnerSystem.cpp

@@ -1,7 +1,7 @@
 #include "Systems/SpawnerSystem.h"
 
-SpawnerSystem::SpawnerSystem(World* world, EventBroker* eventBroker) 
-    : System(world, eventBroker)
+SpawnerSystem::SpawnerSystem(SystemParams params) 
+    : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnSpawnerSpawn, &SpawnerSystem::OnSpawnerSpawn);
 }
@@ -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.World, spawnPoint.ID));
+    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,413 @@
+#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");
+    m_ThirdPersonModel = m_Player.FirstChildByName("PlayerModel");
+    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) {
+        playEmptySound();
+        m_TimeSinceLastFire = -0.0f; // HACK: To make empty sound play with interval
+        return;
+    }
+
+    m_Reloading = true;
+    m_ReloadTimer = cAssaultWeapon["ReloadTime"];
+    playReloadAnimation();
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = cAssaultWeapon.EntityID;
+    e.FilePath = "Audio/weapon/reload.wav";
+    m_EventBroker->Publish(e);
+}
+
+void AssaultWeaponBehaviour::Update(double dt)
+{
+    if (m_Reloading) {
+        m_ReloadTimer -= dt;
+        // Re-enable glow on reload impersonator half-way through the animation
+        if (IsClient) {
+            if (m_ReloadTimer <= (double)m_Player["AssaultWeapon"]["ReloadTime"] / 2.0) {
+                if (m_FirstPersonReloadImpersonator.Valid()) {
+                    m_FirstPersonReloadImpersonator["Model"]["GlowMap"] = true;
+                }
+                if (m_ThirdPersonReloadImpersonator.Valid()) {
+                    m_ThirdPersonReloadImpersonator["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) {
+        if (IsClient) {
+            playIdleAnimation();
+        }
+    }
+
+    // Disable glow map on weapon if it's out of ammo
+    // Make real first person weapon model visible again
+    if (IsClient) {
+        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;
+    m_TimeSinceLastFire = 0.0;
+
+    // Effects
+    if (IsClient) {
+        spawnTracer();
+    playFireSound();  
+        viewPunch();
+        playShootAnimation();
+        bool hit = shoot(cAssaultWeapon["BaseDamage"]);
+        if (hit) {
+            showHitMarker();
+        }
+    }
+}
+
+void AssaultWeaponBehaviour::spawnTracer()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    EntityWrapper spawner;
+    bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false);
+    if (m_Player == LocalPlayer && !outOfBodyExperience) {
+        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::playFireSound()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = m_Player.ID;
+    e.FilePath = "Audio/laser/laser1.wav";
+    m_EventBroker->Publish(e);
+}
+
+
+void AssaultWeaponBehaviour::playEmptySound()
+{
+    if (!IsClient) {
+        return;
+    }
+
+    Events::PlaySoundOnEntity e;
+    e.EmitterID = m_Player.ID;
+    e.FilePath = "Audio/weapon/zeroAmmo.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");
+    if (firstPersonWeaponModel.Valid()) {
+        firstPersonWeaponModel["Model"]["Visible"] = true;
+    }
+    EntityWrapper thirdPersonWeaponModel = m_Player.FirstChildByName("ThirdPersonWeaponModel");
+    if (thirdPersonWeaponModel.Valid()) {
+        thirdPersonWeaponModel["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
+    // First person
+    if (IsClient)
+    {
+        ComponentWrapper cAnimation = m_FirstPersonModel["Animation"];
+        cAnimation["AnimationName1"] = "ReloadSwitch";
+        cAnimation["Weight1"] = 1.0;
+        cAnimation["Time1"] = 0.0;
+        cAnimation["Speed1"] = 0.5;
+        cAnimation["Loop1"] = true;
+    }
+    // TODO: Third person
+    //{
+    //    ComponentWrapper cAnimation = m_ThirdPersonModel["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");
+        if (IsClient) {
+            m_FirstPersonReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+            firstPersonWeaponModel["Model"].Copy(m_FirstPersonReloadImpersonator["Model"]);
+        }
+        firstPersonWeaponModel["Model"]["Visible"] = false;
+    }
+    {
+        EntityWrapper thirdPersonWeaponModel = m_Player.FirstChildByName("ThirdPersonWeaponModel");
+        EntityWrapper reloadSpawner = m_Player.FirstChildByName("ThirdPersonReloadSpawner");
+        if (IsClient) {
+            m_ThirdPersonReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+            thirdPersonWeaponModel["Model"].Copy(m_ThirdPersonReloadImpersonator["Model"]);
+        }
+        thirdPersonWeaponModel["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);
+    if (!victim.Valid()) {
+        return false;
+    }
+
+    // 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);
+        Events::PlaySoundOnEntity e;
+        e.EmitterID = m_Player.ID; 
+        e.FilePath = "Audio/weapon/hitclick.wav";
+        m_EventBroker->Publish(e);
+    }
+}

src/Game/Systems/Weapon/WeaponSystem.cpp

@@ -0,0 +1,96 @@
+#include "Systems/Weapon/WeaponSystem.h"
+
+WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
+    : System(params)
+    , PureSystem("Player")
+    , m_SystemParams(params)
+    , m_Renderer(renderer)
+    , m_CollisionOctree(collisionOctree)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
+}
+
+void WeaponSystem::Update(double dt)
+{
+
+}
+
+void WeaponSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt)
+{
+    // Update potential weapon behaviour for player
+    auto it = m_ActiveWeapons.find(entity);
+    if (it == m_ActiveWeapons.end()) {
+        selectWeapon(entity, 1);
+    }
+    
+    m_EventBroker->Process<WeaponBehaviour>();
+    m_ActiveWeapons.at(entity)->Update(dt);
+}
+
+bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
+{
+    EntityWrapper player = e.Player;
+    if (e.PlayerID == -1) {
+        player = LocalPlayer;
+    }
+
+    // Make sure player is alive
+    if (!player.Valid()) {
+        return false;
+    }
+
+    // Weapon selection
+    if (e.Command == "SelectWeapon") {
+        if (e.Value != 0) {
+            //selectWeapon(player, static_cast<ComponentInfo::EnumType>(e.Value));
+        }
+    }
+
+    // Fire
+    if (e.Command == "PrimaryFire") {
+        if (m_ActiveWeapons.find(player) != m_ActiveWeapons.end()) {
+            auto weapon = m_ActiveWeapons.at(player);
+            if (e.Value > 0) {
+                weapon->Fire();
+            } else {
+                weapon->CeaseFire();
+            }
+        }
+    }
+
+    // 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;
+}
+
+void WeaponSystem::selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot)
+{
+    // Primary
+    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_Renderer, m_CollisionOctree, player)));
+        } else {
+            //m_ActiveWeapons.erase(player);
+        }
+    }
+
+    // Secondary
+    if (slot == 2) {
+        //m_ActiveWeapons[player] = std::make_shared<PistolWeaponBehaviour>();
+    }
+}
+
+bool WeaponSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+{
+    // Select primary weapon on player spawn
+    // TODO: Select the active one specified by player component
+    return true;
+}

src/Game/Systems/WeaponSystem.cpp

@@ -1,141 +0,0 @@
-#include "Systems/WeaponSystem.h"
-
-WeaponSystem::WeaponSystem(World* world, EventBroker* eventBroker, IRenderer* renderer)
-    : System(world, eventBroker)
-    , ImpureSystem()
-    , m_Renderer(renderer)
-{
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
-    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
-    EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
-}
-
-void WeaponSystem::Update(double dt)
-{
-
-}
-
-bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e)
-{
-    if (e.PlayerID == -1) {
-        m_LocalPlayer = e.Player;
-    }
-    return true;
-}
-
-bool WeaponSystem::OnInputCommand(const Events::InputCommand& e)
-{
-    // Only shoot client-side!
-    if (e.PlayerID != -1) {
-        return false;
-    }
-
-    // Only shoot if the player is alive
-    if (!m_LocalPlayer.Valid()) {
-        return false;
-    }
-
-    if (e.Command == "PrimaryFire" && e.Value > 0) {
-        Events::Shoot eShoot;
-        if (e.PlayerID == -1) {
-            eShoot.Player = m_LocalPlayer;
-        } else {
-            eShoot.Player = e.Player;
-        }
-        m_EventBroker->Publish(eShoot);
-    }
-
-    return true;
-}
-
-bool WeaponSystem::OnShoot(Events::Shoot& eShoot) 
-{
-    if (!eShoot.Player.Valid()) {
-        return false;
-    }
-
-    // TODO: Weapon firing effects here
-
-    auto rayRed = ResourceManager::Load<EntityFile>("Schema/Entities/RayRed.xml");
-    auto rayBlue = ResourceManager::Load<EntityFile>("Schema/Entities/RayBlue.xml");
-
-    EntityWrapper weapon = eShoot.Player.FirstChildByName("WeaponMuzzle");
-    if (weapon.Valid()) {
-        EntityWrapper ray;
-        if ((ComponentInfo::EnumType)eShoot.Player["Team"]["Team"] == eShoot.Player["Team"]["Team"].Enum("Red")) {
-            EntityFileParser parser(rayRed);
-            EntityID rayID = parser.MergeEntities(m_World);
-            ray = EntityWrapper(m_World, rayID);
-        } else {
-            EntityFileParser parser(rayBlue);
-            EntityID rayID = parser.MergeEntities(m_World);
-            ray = EntityWrapper(m_World, rayID);
-        }
-
-        glm::mat4 transformation = Transform::AbsoluteTransformation(weapon);
-        glm::vec3 scale;
-        glm::vec3 translation;
-        glm::quat orientation;
-        glm::vec3 skew;
-        glm::vec4 perspective;
-        glm::decompose(transformation, scale, orientation, translation, skew, perspective);
-        
-        // Matrix to euler angles
-        glm::vec3 euler;
-        euler.y = glm::asin(-transformation[0][2]);
-        if (cos(euler.y) != 0) {
-            euler.x = atan2(transformation[1][2], transformation[2][2]);
-            euler.z = atan2(transformation[0][1], transformation[0][0]);
-        } else {
-            euler.x = atan2(-transformation[2][0], transformation[1][1]);
-            euler.z = 0;
-        }
-
-        //LOG_DEBUG("rotation: %f %f %f", euler.x, euler.y, euler.z);
-        (glm::vec3&)ray["Transform"]["Position"] = translation;
-        (glm::vec3&)ray["Transform"]["Orientation"] = euler;
-        //(glm::vec3&)ray["Transform"]["Orientation"] = Transform::AbsoluteOrientationEuler(weapon);
-    }
-
-    // Only run further picking code client-side!
-    if (eShoot.Player != m_LocalPlayer) {
-        return false;
-    }
-
-    // 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/Game/main.cpp

@@ -1,11 +1,25 @@
 #include "Game.h"
+#include "MiniDump.h"
+
+LONG WINAPI CrashHandler(EXCEPTION_POINTERS* pException);
 
 int main(int argc, char* argv[])
 {
-	Game game(argc, argv);
-	while (game.Running()) {
-		game.Tick();
-	}
+    ::SetUnhandledExceptionFilter(CrashHandler);
+
+    Game game(argc, argv);
+    while (game.Running()) {
+        game.Tick();
+    }
 
 	return 0;
+}
+
+LONG WINAPI CrashHandler(EXCEPTION_POINTERS* pException)
+{
+    //Take minidump. path should be bin/TacticalZ.dmp
+    //Then show MessageBox, and exit application.
+    Create_Dump(pException, 1, 1);
+
+    return EXCEPTION_EXECUTE_HANDLER;// EXCEPTION_CONTINUE_SEARCH
 }

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