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

# Conflicts:
#	include/Game/Systems/PlayerMovementSystem.h

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

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <bitset>
 
 #include "Collision/Collision.h"
 #include "Engine/GLM.h"
@@ -183,7 +184,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.
@@ -330,7 +331,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;
@@ -355,8 +356,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,
@@ -385,7 +386,7 @@ bool AABBvsTriangle(const AABB& box,
         Resolution()
             : DistanceSq(INFINITY)
             , Vector(0.f)
-        {}
+        { }
         BoxTriResolveCase Case;
         float DistanceSq;
         glm::vec3 Vector;
@@ -525,9 +526,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,
@@ -564,48 +565,77 @@ bool AABBvsTriangles(const AABB& box,
     return hit;
 }
 
-bool AttachAABBComponentFromModel(EntityWrapper entity)
+boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeModelBox)
 {
-    if (!entity.HasComponent("Model")) {
-        return false;
-    }
-    //Derive AABB from model
-    RawModel* model;
-    try {
-        model = ResourceManager::Load<RawModel, true>(entity["Model"]["Resource"]);
-    } catch (const std::exception&) {
-        return false;
-    }
-
-    glm::vec3 mini(INFINITY);
-    glm::vec3 maxi(-INFINITY);
-    for (const auto& v : model->m_Vertices) {
-        mini = glm::min(mini, v.Position);
-        maxi = glm::max(maxi, v.Position);
-    }
-
-    entity.AttachComponent("AABB");
-    entity["AABB"]["Origin"] = 0.5f * (maxi + mini);
-    entity["AABB"]["Size"] = maxi - mini;
-    return true;
-}
-
-boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity)
-{
-    if (!entity.HasComponent("AABB")) {
+    AABB modelSpaceBox;
+    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;
+        }
+        try {
+            model = ResourceManager::Load<::Model, true>(res);
+        } catch (const Resource::StillLoadingException&) {
+            return boost::none;
+        } catch (const std::exception&) {
+            return boost::none;
+        }
+        modelSpaceBox = model->Box();
+    } else {
         return boost::none;
     }
 
-    ComponentWrapper& cAABB = entity["AABB"];
-    glm::vec3 absPosition = Transform::AbsolutePosition(entity.World, entity.ID);
-    glm::vec3 absScale = Transform::AbsoluteScale(entity.World, entity.ID);
-    glm::vec3 origin = absPosition + (glm::vec3)cAABB["Origin"];
-    glm::vec3 size = (glm::vec3)cAABB["Size"] * absScale;
+    glm::mat4 modelMat = Transform::AbsoluteTransformation(entity);
+    glm::vec3 mini(INFINITY);
+    glm::vec3 maxi(-INFINITY);
+    glm::vec3 maxCorner = modelSpaceBox.MaxCorner();
+    glm::vec3 minCorner = modelSpaceBox.MinCorner();
+    for (int i = 0; i < 8; ++i) {
+        std::bitset<3> bits(i);
+        glm::vec3 corner;
+        corner.x = bits.test(0) ? maxCorner.x : minCorner.x;
+        corner.y = bits.test(1) ? maxCorner.y : minCorner.y;
+        corner.z = bits.test(2) ? maxCorner.z : minCorner.z;
+        corner = Transform::TransformPoint(corner, modelMat);
+        mini = glm::min(mini, corner);
+        maxi = glm::max(maxi, corner);
+    }
+
+    EntityAABB aabb;
+    aabb = AABB(mini, maxi);
 
-    EntityAABB aabb = EntityAABB::FromOriginSize(origin, size);
     aabb.Entity = 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;
 }
+
+}

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

@@ -0,0 +1,19 @@
+#include "Collision/FillFrustumOctreeSystem.h"
+
+void FillFrustumOctreeSystem::Update(double dt)
+{
+    m_Octree->ClearDynamicObjects();
+}
+
+void FillFrustumOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+{
+    boost::optional<EntityAABB> absoluteAABB;
+    if (entity.HasComponent("ExplosionEffect")) {
+        absoluteAABB = Collision::AbsoluteAABBExplosionEffect(entity);
+    } else {
+        absoluteAABB = Collision::EntityAbsoluteAABB(entity, true);
+    }
+    if (absoluteAABB) {
+        m_Octree->AddDynamicObject(*absoluteAABB);
+    }
+}

src/Engine/Collision/FillOctreeSystem.cpp

@@ -7,12 +7,6 @@ void FillOctreeSystem::Update(double dt)
 
 void FillOctreeSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
-    if (!entity.HasComponent("AABB")) {
-        //Derive AABB from model.
-        if (!Collision::AttachAABBComponentFromModel(entity)) {
-            return;
-        }
-    }
     boost::optional<EntityAABB> absoluteAABB = Collision::EntityAbsoluteAABB(entity);
     if (absoluteAABB) {
         m_Octree->AddDynamicObject(*absoluteAABB);

src/Engine/Collision/TriggerSystem.cpp

@@ -5,11 +5,6 @@
 
 void TriggerSystem::UpdateComponent(EntityWrapper& triggerEntity, ComponentWrapper& cTrigger, double dt)
 {
-    // The trigger *should* have a bounding box, or something, to test against so it can be triggered.
-    // If it doesn't, add one as big as the model for now, then size can be modified in editor if necessary.
-    if (!triggerEntity.HasComponent("AABB")) {
-        Collision::AttachAABBComponentFromModel(triggerEntity);
-    }
     boost::optional<EntityAABB> triggerBox = Collision::EntityAbsoluteAABB(triggerEntity);
     if (!triggerBox) {
         return;

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

@@ -78,7 +78,6 @@ void EntityFilePreprocessor::parseComponentInfo()
 
         // <xs:complexType>
         auto typeDefinition = element->getTypeDefinition();
-        // Allow empty components
         if (typeDefinition == nullptr) {
             continue;
         }
@@ -88,6 +87,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 +126,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/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);
@@ -100,9 +100,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

@@ -2,40 +2,50 @@
 
 using namespace boost::asio::ip;
 
-
-Client::Client(ConfigFile* config) : m_Socket(m_IOService)
+Client::Client(World* world, EventBroker* eventBroker) 
+    : Network(world, eventBroker)
+    , m_Socket(m_IOService)
 {
-    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)
+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);
 
+    auto config = ResourceManager::Load<ConfigFile>("Config.ini");
+    if (address.empty()) {
+        address = config->Get<std::string>("Networking.Address", "127.0.0.1");
+    }
+    if (port == 0) {
+        port = config->Get<int>("Networking.Port", 27666);
+    }
+
+    m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
+    LOG_INFO("Client connecting...");
     m_Socket.connect(m_ReceiverEndpoint);
-    LOG_INFO("I am client. BIP BOP");
+    connect();
 }
 
 void Client::Update()
@@ -49,6 +59,7 @@ void Client::Update()
             sendInputCommands();
             m_TimeSinceSentInputs = std::clock();
         }
+        // HACK: Send absolute player positions for now to avoid desync until we have reliable messages
         sendLocalPlayerTransform();
     }
     Network::Update();
@@ -173,40 +184,64 @@ 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>();
+        e.Player = EntityWrapper(m_World, m_ServerIDToClientID.at(packet.ReadPrimitive<EntityID>()));
+        e.Command = packet.ReadString();
+        e.Value = packet.ReadPrimitive<float>();
+        m_EventBroker->Publish(e);
+    }
+
+    // Read world state
     while (packet.DataReadSize() < packet.Size()) {
         EntityID serverEntityID = packet.ReadPrimitive<EntityID>();
         EntityID serverParentID = packet.ReadPrimitive<EntityID>();
@@ -214,26 +249,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 +287,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
@@ -310,6 +351,10 @@ void Client::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();

src/Engine/Network/Network.cpp

@@ -1,5 +1,14 @@
 #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();
@@ -59,10 +68,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/Server.cpp

@@ -1,29 +1,30 @@
 #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);
 
-}
-
-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");
+
+    // Bind
+    if (port == 0) {
+        port = config->Get<float>("Networking.Port", 27666);
+    }
+    m_Port = port;
+    m_Socket = std::make_unique<boost::asio::ip::udp::socket>(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), port));
+    LOG_INFO("Server initialized and bound to port %i", port);
+}
+
+Server::~Server()
+{
+
 }
 
 void Server::Update()
@@ -38,7 +39,7 @@ void Server::Update()
 
 void Server::readFromClients()
 {
-    while (m_Socket.available()) {
+    while (m_Socket->available()) {
         try {
             bytesRead = receive(readBuffer);
             Packet packet(readBuffer, bytesRead);
@@ -105,7 +106,7 @@ void Server::parseMessageType(Packet& packet)
 
 size_t Server::receive(char * data)
 {
-    size_t length = m_Socket.receive_from(
+    size_t length = m_Socket->receive_from(
         boost::asio::buffer((void*)data
             , INPUTSIZE)
         , m_ReceiverEndpoint, 0);
@@ -121,7 +122,7 @@ size_t Server::receive(char * data)
 void Server::send(PlayerID player, Packet& packet)
 {
     try {
-        size_t bytesSent = m_Socket.send_to(
+        size_t bytesSent = m_Socket->send_to(
             boost::asio::buffer(packet.Data(), packet.Size()),
             m_ConnectedPlayers[player].Endpoint,
             0);
@@ -139,7 +140,7 @@ void Server::send(PlayerID player, Packet& packet)
 
 void Server::send(Packet & packet)
 {
-    m_Socket.send_to(
+    m_Socket->send_to(
         boost::asio::buffer(
             packet.Data(),
             packet.Size()),
@@ -164,10 +165,24 @@ void Server::broadcast(Packet& packet)
 void Server::sendSnapshot()
 {
     Packet packet(MessageType::Snapshot);
+    addInputCommandsToPacket(packet);
     addChildrenToPacket(packet, EntityID_Invalid);
     broadcast(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)
 {
     auto itPair = m_World->GetChildren(entityID);
@@ -239,8 +254,8 @@ void Server::checkForTimeOuts()
             double stopPing = 1000 * m_ConnectedPlayers[i].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!", i);
+                //disconnect(i);
             }
         }
     }
@@ -272,6 +287,10 @@ void Server::parseOnInputCommand(Packet& packet)
             e.Player = EntityWrapper(m_World, m_ConnectedPlayers.at(player).EntityID);
             e.Value = packet.ReadPrimitive<float>();
             m_EventBroker->Publish(e);
+
+            if (e.Command == "PrimaryFire") {
+                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);
         }
     }

src/Engine/Rendering/AnimationSystem.cpp

@@ -13,35 +13,73 @@ 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;
+                } else if (nextTime < 0) {
+                    nextTime = 0;
+                }
+
+                (double&)animationComponent["Speed" + std::to_string(i)] = 0.0;
+                Events::AnimationComplete e;
+                e.Entity = entity;
+                e.Name = (std::string)animationComponent["AnimationName" + std::to_string(i)];
+                m_EventBroker->Publish(e);
+            } else {
+                if (nextTime > animation->Duration) {
+                    nextTime -= animation->Duration;
+                } else if (nextTime < 0) {
+                    nextTime += animation->Duration;
+                }
+            }
+
+            (double&)animationComponent["Time" + std::to_string(i)] = nextTime;
+        }
+    } 
+
+    //Calculate bone transforms
+    if (skeleton != nullptr) {
+        std::vector<Skeleton::AnimationData> animations;
+        if (entity.HasComponent("Animation")) {
+            for (int i = 1; i <= 3; i++) {
+                Skeleton::AnimationData animationData;
+                animationData.animation = model->m_RawModel->m_Skeleton->GetAnimation(entity["Animation"]["AnimationName" + std::to_string(i)]);
+                if (animationData.animation == nullptr) {
+                    continue;
+                }
+                animationData.time = (double)entity["Animation"]["Time" + std::to_string(i)];
+                animationData.weight = (double)entity["Animation"]["Weight" + std::to_string(i)];
+
+                animations.push_back(animationData);
+            }
+        }
+
+        if (entity.HasComponent("AnimationOffset")) {
+            Skeleton::AnimationOffset animationOffset;
+            animationOffset.animation = skeleton->GetAnimation(entity["AnimationOffset"]["AnimationName"]);
+            animationOffset.time = (double)entity["AnimationOffset"]["Time"];
+            skeleton->CalculateFrameBones(animations, animationOffset);
+        } else {
+            skeleton->CalculateFrameBones(animations);
+        }
+    }
 }
 

src/Engine/Rendering/BoneAttachmentSystem.cpp

@@ -0,0 +1,73 @@
+#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;
+    }
+
+
+    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+
+    if(skeleton == nullptr) {
+        return;
+    }
+
+    const Skeleton::Animation* animation = skeleton->GetAnimation(parent["Animation"]["AnimationName1"]);
+
+    if (!animation) {
+        return;
+    }
+
+    int id = skeleton->GetBoneID(entity["BoneAttachment"]["BoneName"]);
+
+    if(id == -1) {
+        return;
+    }
+
+
+    glm::mat4 boneTransform = skeleton->GetBoneTransformSuper(id);
+    //glm::mat4 boneTransform = skeleton->GetBoneTransform(skeleton->Bones[id], animation, (double)parent["Animation"]["Time1"], 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/DrawBloomPass.cpp

@@ -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

@@ -79,6 +79,62 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ExplosionEffectProgram->Link();
     GLERROR("Creating explosion program");
 
+	m_ForwardPlusSplatMapProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram");
+	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+	m_ForwardPlusSplatMapProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlusSplatMap.frag.glsl")));
+	m_ForwardPlusSplatMapProgram->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/ForwardPlusSplatMap.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/ForwardPlusSplatMap.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/ForwardPlusSplatMap.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 +142,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)
@@ -125,11 +195,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 +293,184 @@ 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)
-    {
-        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
-        if(explosionEffectJob) {
-            //Bind program
-            if(GLERROR("Prebind")) {
-                continue;
-            }
-            m_ExplosionEffectProgram->Bind();
-            if(GLERROR("BindProgram")) {
-                continue;
-            }
 
+    for (auto &job : jobs) {
+        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
+        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;
+                    frameBones = explosionEffectJob->Skeleton->GetBones();
+                    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;
+                    frameBones = explosionEffectJob->Skeleton->GetBones();
+                    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;
+                            frameBones = modelJob->Skeleton->GetBones();
+                            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;
+                            frameBones = modelJob->Skeleton->GetBones();
+                            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;
+                frameBones = modelJob->Skeleton->GetBones();
+                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 +513,16 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
                 continue;
             }
 
-            if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
+            std::vector<glm::mat4> frameBones;
+            frameBones = explosionEffectJob->Skeleton->GetBones();
+            glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                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);
+            BindExplosionTextures(explosionHandle, explosionEffectJob);
             if (GLERROR("BindExplosionTextures")) {
                 continue;
             }
@@ -402,15 +546,12 @@ 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) {
+                std::vector<glm::mat4> frameBones;
+                frameBones = modelJob->Skeleton->GetBones();
+                glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                    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]));
-                    }
-                }
 
                 //draw
                 glBindVertexArray(modelJob->Model->VAO);
@@ -427,25 +568,31 @@ 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) {
+            std::vector<glm::mat4> frameBones;
+           frameBones = modelJob->Skeleton->GetBones();
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-            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]));
-            }
+        } 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);
@@ -459,108 +606,314 @@ void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& job
 
 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 < 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;
+		}
+	}
 }
 

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,77 @@ 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);
+			if (!materialSingleTexture->ColorMap.TexturePath.empty()) {
+				materialSingleTexture->ColorMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->ColorMap.TexturePath));
+			}
+			if (!materialSingleTexture->NormalMap.TexturePath.empty()) {
+				materialSingleTexture->NormalMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->NormalMap.TexturePath));
+			}
+			if (!materialSingleTexture->SpecularMap.TexturePath.empty()) {
+				materialSingleTexture->SpecularMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->SpecularMap.TexturePath));
+			}
+			if (!materialSingleTexture->IncandescenceMap.TexturePath.empty()) {
+				materialSingleTexture->IncandescenceMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSingleTexture->IncandescenceMap.TexturePath));
+			}
+		}
+			break;
+		case RawModel::MaterialType::SplatMapping:
+		{
+			RawModel::MaterialSplatMapping* materialSplatMapping = static_cast<RawModel::MaterialSplatMapping*>(materialProperty.material);
+			if (!materialSplatMapping->SplatMap.TexturePath.empty()) {
+				materialSplatMapping->SplatMap.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(materialSplatMapping->SplatMap.TexturePath));
+			}
+			for (auto& texture : materialSplatMapping->ColorMaps)
+			{
+				if (!texture.TexturePath.empty()) {
+					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
+				}
+				else {
+					texture.Texture = nullptr;
+				}
+			}
+			for (auto& texture : materialSplatMapping->NormalMaps)
+			{
+				if (!texture.TexturePath.empty()) {
+					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
+				} else {
+					texture.Texture = nullptr;
+				}
+			}
+			for (auto& texture : materialSplatMapping->SpecularMaps)
+			{
+				if (!texture.TexturePath.empty()) {
+					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
+				}
+				else {
+					texture.Texture = nullptr;
+				}
+			}
+			for (auto& texture : materialSplatMapping->IncandescenceMaps)
+			{
+				if (!texture.TexturePath.empty()) {
+					texture.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(texture.TexturePath));
+				}
+				else {
+					texture.Texture = nullptr;
+				}
+			}
+		}
+			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 +86,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 +106,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,11 +118,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 (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(mini, maxi);
 }
 
 Model::~Model()

src/Engine/Rendering/PickingPass.cpp

@@ -41,6 +41,14 @@ 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)
@@ -49,6 +57,7 @@ void PickingPass::Draw(RenderScene& scene)
     
     //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,18 +92,28 @@ 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;
+                    frameBones = modelJob->Skeleton->GetBones();
+                    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);
@@ -105,41 +124,46 @@ void PickingPass::Draw(RenderScene& scene)
     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;
+                frameBones = modelJob->Skeleton->GetBones();
+                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);
@@ -175,17 +199,23 @@ 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) {
+                std::vector<glm::mat4> frameBones;
+                frameBones = modelJob->Skeleton->GetBones();
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                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]));
-                }
+            } 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);
@@ -198,6 +228,7 @@ void PickingPass::Draw(RenderScene& scene)
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
+
             int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
             PickingInfo pickInfo;
@@ -221,19 +252,34 @@ 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) {
+                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;
+                    frameBones = modelJob->Skeleton->GetBones();
+                    glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                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]));
                 }
+            } 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)));
@@ -252,8 +298,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

@@ -1,10 +1,12 @@
 #include "Rendering/RenderSystem.h"
+#include "Collision/Collision.h"
+#include "Core/Frustum.h"
 
-RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame) 
-    : 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);
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
@@ -42,12 +44,13 @@ bool RenderSystem::isChildOfCurrentCamera(EntityWrapper entity)
 
 void RenderSystem::fillModels(RenderScene::Queues &Jobs)
 {
-    auto models = m_World->GetComponents("Model");
-    if (models == nullptr) {
-        return;
-    }
+    Frustum frustum(m_Camera->ProjectionMatrix() * m_Camera->ViewMatrix());
+    std::vector<EntityAABB> seenEntities;
+    m_Octree->ObjectsInFrustum(frustum, seenEntities);
 
-    for (auto& cModel : *models) {
+    for (auto& seenEntity : seenEntities) {
+        EntityWrapper entity = seenEntity.Entity;
+        ComponentWrapper cModel = entity["Model"];
         bool visible = cModel["Visible"];
         if (!visible) {
             continue;
@@ -57,15 +60,13 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
             continue;
         }
 
-        EntityWrapper entity(m_World, cModel.EntityID);
-
         // 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 ((entity.HasComponent("HiddenForLocalPlayer") || entity.FirstParentWithComponent("HiddenForLocalPlayer").Valid()) && (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer))) {
             continue;
         }
 
@@ -109,6 +110,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")) {
@@ -120,6 +122,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentShieldedObjects.push_back(explosionEffectJob);
                     } else {
+					    explosionEffectJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(explosionEffectJob);
                     }
                 } else {
@@ -130,6 +133,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentObjects.push_back(explosionEffectJob);
                     } else {
+                        explosionEffectJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(explosionEffectJob);
                     }
                 }
@@ -145,6 +149,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")) {
@@ -156,6 +161,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentShieldedObjects.push_back(modelJob);
                     } else {
+					    modelJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(modelJob);
                     }
                 } else {
@@ -166,6 +172,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     if (cModel["Transparent"]) {
                         Jobs.TransparentObjects.push_back(modelJob);
                     } else {
+                        modelJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(modelJob);
                     }
                 }
@@ -231,7 +238,7 @@ void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World*
     if (texts == nullptr) {
         return;
     }
-
+	
     for (auto& textComponent : *texts) {
         bool visible = textComponent["Visible"];
         if (!visible) {
@@ -288,6 +295,8 @@ 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();
     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) {

src/Engine/Rendering/Skeleton.cpp

@@ -29,6 +29,32 @@ Skeleton::~Skeleton()
 	}
 }
 
+
+void Skeleton::CalculateFrameBones(std::vector<AnimationData> animations, AnimationOffset animationOffset, bool noRootMotion /*= false*/)
+{
+    if (animations.size() <= 0 || animationOffset.animation == nullptr) {
+        for (auto& b : Bones) {
+            m_BoneLocalTransforms[b.first] = glm::mat4(1);
+            m_BoneTransforms[b.first] = glm::mat4(1);
+        }
+    } else {
+        AccumulateBoneTransforms(noRootMotion, animations, animationOffset, RootBone, glm::mat4(1));
+    }
+}
+
+
+void Skeleton::CalculateFrameBones(std::vector<AnimationData> animations, bool noRootMotion /*= false*/)
+{
+    if (animations.size() <= 0) {
+        for (auto& b : Bones) {
+            m_BoneLocalTransforms[b.first] = glm::mat4(1);
+            m_BoneTransforms[b.first] = glm::mat4(1);
+        }
+    } else {
+        AccumulateBoneTransforms(noRootMotion, animations, RootBone, glm::mat4(1));
+    }
+}
+
 const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 {
 	auto it = Animations.find(name);
@@ -39,66 +65,375 @@ const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
 	}
 }
 
-std::vector<glm::mat4> Skeleton::GetFrameBones(const Animation& animation, double time, bool noRootMotion /*= false*/)
-{
-	// HACK: Animation wrap-around
-	while (time < 0) {
-		time += animation.Duration;
-	}
-	while (time > animation.Duration) {
-		time -= animation.Duration;
-	}
-
-	int currentKeyframeIndex = GetKeyframe(animation, time);
-
-	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;
-}
-
-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)
+void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, AnimationOffset animationOffset, 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));
+
+            }
+            m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
+            m_BoneTransforms[bone->ID] = boneMatrix;
+        } else {
+            boneMatrix = offset * glm::inverse(bone->OffsetMatrix);
+            m_BoneLocalTransforms[bone->ID] = parentMatrix;
+            m_BoneTransforms[bone->ID] = boneMatrix;
+        }
+    } else {
+
+        glm::vec3 finalPosInterp;
+        glm::quat finalRotInterp;
+        glm::vec3 finalScaleInterp;
+        float totalWeight = 0;
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            totalWeight += jointTransform.Weight;
+        }
+
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            if (jointTransform.Weight == 1.0f) {
+                finalPosInterp = jointTransform.PositionInterp;
+                finalRotInterp = jointTransform.RotationInterp;
+                finalScaleInterp = jointTransform.ScaleInterp;
+                break;
+            } else {
+                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
+                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
+                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
+            }
+
+        }
+
+
+        if (offset != glm::mat4(1)) {
+            boneMatrix = parentMatrix * ((glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp)) + offset);
+        } else {
+            boneMatrix = parentMatrix * (glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp));
+        }
+
+        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
+        m_BoneTransforms[bone->ID] = boneMatrix;
+    }
+
+    for (auto &child : bone->Children) {
+        AccumulateBoneTransforms(noRootMotion, animations, animationOffset, child, boneMatrix);
+    }
+}
+
+void Skeleton::AccumulateBoneTransforms(bool noRootMotion, std::vector<AnimationData> animations, const Bone* bone, glm::mat4 parentMatrix)
+{
+    glm::mat4 boneMatrix;
+    std::vector<JointFrameTransform> JointTransforms;
+
+    for (const AnimationData animationData : animations) {
+        const Animation* animation = animationData.animation;
+        const float time = animationData.time;
+
+        JointFrameTransform jointTransform;
+        jointTransform.Weight = animationData.weight;;
+
+        if (animation->JointAnimations.find(bone->ID) != animation->JointAnimations.end()) {
+            std::vector<Animation::Keyframe> boneKeyFrames = animation->JointAnimations.at(bone->ID);
+
+            Animation::Keyframe currentFrame;
+            Animation::Keyframe nextFrame;
+
+            if (boneKeyFrames.size() > 1) { // 2+ keyframes for the current bone
+                for (int index = boneKeyFrames.size()-1; index >= 0; index--) { // find the bone keyframes that surrounds the current frame
+                    if (time >= boneKeyFrames.at(index).Time) {
+                        currentFrame = boneKeyFrames.at(index);
+                        nextFrame = boneKeyFrames.at((index + 1) % boneKeyFrames.size());
+                        break;
+                    }
+                }
+
+                float progress;
+
+                if (nextFrame.Index == 0) {
+                    nextFrame = currentFrame;
+                    progress = (time - currentFrame.Time) / (animation->Duration - currentFrame.Time);
+                } else {
+                    progress = (time - currentFrame.Time) / (nextFrame.Time - currentFrame.Time);
+
+                }
+
+                if (progress > 1.0f || progress < 0.0f) {
+                    progress = glm::clamp(progress, 0.0f, 1.0f);
+                }
+                Animation::Keyframe::BoneProperty currentBoneProperty = currentFrame.BoneProperties;
+                Animation::Keyframe::BoneProperty nextBoneProperty = nextFrame.BoneProperties;
+
+                jointTransform.PositionInterp = currentBoneProperty.Position * (1.f - progress) + nextBoneProperty.Position * progress;
+                jointTransform.RotationInterp = glm::slerp(currentBoneProperty.Rotation, nextBoneProperty.Rotation, progress);
+                jointTransform.ScaleInterp = currentBoneProperty.Scale * (1.f - progress) + nextBoneProperty.Scale * progress;
+
+                // Flag for no root motion
+                if (bone == RootBone && noRootMotion) {
+                    jointTransform.PositionInterp.x = 0;
+                    jointTransform.PositionInterp.z = 0;
+                }
+
+                JointTransforms.push_back(jointTransform);
+
+            } else { // 1 keyframes for the current bone
+                currentFrame = boneKeyFrames.at(0);
+                jointTransform.PositionInterp = currentFrame.BoneProperties.Position;
+                jointTransform.RotationInterp = currentFrame.BoneProperties.Rotation;
+                jointTransform.ScaleInterp = currentFrame.BoneProperties.Scale;
+                JointTransforms.push_back(jointTransform);
+
+            }
+        } else { // 0 keyframes for the current bone
+
+        }
+
+    }
+
+    if (JointTransforms.size() <= 0) {
+        if (bone->Parent) {
+            boneMatrix = parentMatrix * glm::inverse(bone->OffsetMatrix) * bone->Parent->OffsetMatrix;
+            m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
+            m_BoneTransforms[bone->ID] = boneMatrix;
+        } else {
+            boneMatrix = glm::inverse(bone->OffsetMatrix);
+            m_BoneLocalTransforms[bone->ID] = parentMatrix;
+            m_BoneTransforms[bone->ID] = boneMatrix;
+        }
+    } else if (JointTransforms.size() == 1) {
+        boneMatrix = parentMatrix *(glm::translate(JointTransforms.at(0).PositionInterp) * glm::toMat4(JointTransforms.at(0).RotationInterp) * glm::scale(JointTransforms.at(0).ScaleInterp));
+        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
+        m_BoneTransforms[bone->ID] = boneMatrix;
+    } else {
+
+        glm::vec3 finalPosInterp;
+        glm::quat finalRotInterp;
+        glm::vec3 finalScaleInterp;
+        float totalWeight = 0;
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            totalWeight += jointTransform.Weight;
+        }
+
+
+        for (JointFrameTransform jointTransform : JointTransforms) {
+            if (jointTransform.Weight == 1.0f) {
+                finalPosInterp = jointTransform.PositionInterp;
+                finalRotInterp = jointTransform.RotationInterp;
+                finalScaleInterp = jointTransform.ScaleInterp;
+                break;
+            } else {
+                finalPosInterp += jointTransform.PositionInterp * (jointTransform.Weight/totalWeight);
+                finalRotInterp *= glm::slerp(glm::quat(), jointTransform.RotationInterp, (jointTransform.Weight/totalWeight));
+                finalScaleInterp += jointTransform.ScaleInterp * (jointTransform.Weight/totalWeight);
+            }
+
+        }
+
+        boneMatrix = parentMatrix *(glm::translate(finalPosInterp) * glm::toMat4(finalRotInterp) * glm::scale(finalScaleInterp));
+
+        m_BoneLocalTransforms[bone->ID] = boneMatrix * bone->OffsetMatrix;
+        m_BoneTransforms[bone->ID] = boneMatrix;
+    }
+
+
+
+    for (auto &child : bone->Children) {
+        AccumulateBoneTransforms(noRootMotion, animations, child, boneMatrix);
+    }
+}
+
+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);
+
+            }
+
+            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;
+
+            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;
+    }
 }
 
 int Skeleton::GetBoneID(std::string name)
@@ -134,11 +469,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 +483,8 @@ int Skeleton::GetKeyframe(const Animation& animation, double time)
 			return (keyframe - 1) % animation.Keyframes.size();
 		}
 	}
+*/
+
 
 	return 0;
 }

src/Engine/Rendering/Texture.cpp

@@ -30,9 +30,10 @@ Texture::Texture(std::string path)
     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);
+	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/Sound/SoundManager.cpp

@@ -0,0 +1,374 @@
+#include "Sound/SoundManager.h"
+
+SoundManager::SoundManager(World* world, EventBroker* eventBroker)
+{
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_EventBroker = eventBroker;
+    m_World = world;
+    m_BGMVolumeChannel = config->Get<float>("Sound.BGMVolume", 1.f);
+    m_SFXVolumeChannel = config->Get<float>("Sound.SFXVolume", 1.f);
+
+    initOpenAL();
+    alSpeedOfSound(340.29f);
+    alDistanceModel(AL_LINEAR_DISTANCE);
+    alDopplerFactor(1);
+
+    EVENT_SUBSCRIBE_MEMBER(m_EPlaySoundOnEntity, &SoundManager::OnPlaySoundOnEntity);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlaySoundOnPosition, &SoundManager::OnPlaySoundOnPosition);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayBackgroundMusic, &SoundManager::OnPlayBackgroundMusic);
+    EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundManager::OnStopSound);
+    EVENT_SUBSCRIBE_MEMBER(m_EPauseSound, &SoundManager::OnPauseSound);
+    EVENT_SUBSCRIBE_MEMBER(m_EContinueSound, &SoundManager::OnContinueSound);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetBGMGain, &SoundManager::OnSetBGMGain);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetSFXGain, &SoundManager::OnSetSFXGain);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &SoundManager::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EResume, &SoundManager::OnResume);
+    EVENT_SUBSCRIBE_MEMBER(m_EComponentAttached, &SoundManager::OnComponentAttached);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundManager::OnPlayerSpawned);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayQueueOnEntity, &SoundManager::OnPlayQueueOnEntity);
+}
+
+SoundManager::~SoundManager()
+{
+    stopEmitters(); // Stopps emitters
+    deleteInactiveEmitters(); // Deletes stopped emitters
+    // Delete entities
+    std::unordered_map<EntityID, Source*>::iterator it;
+    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
+        m_World->DeleteEntity((*it).first);
+    }
+    m_Sources.clear();
+
+    alcDestroyContext(m_ALCcontext);
+    alcCloseDevice(m_ALCdevice);
+}
+
+void SoundManager::stopEmitters()
+{
+    std::unordered_map<EntityID, Source*>::iterator it;
+    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
+        if (getSourceState(it->second->ALsource) == AL_PLAYING) {
+            stopSound(it->second);
+        }
+    }
+}
+
+void SoundManager::Update(double dt)
+{
+    m_EventBroker->Process<SoundManager>();
+    deleteInactiveEmitters(); // can be optimized with "EEntityDeleted"
+    updateEmitters(dt);
+    updateListener(dt);
+
+    // Editor debug info
+    ImGui::SliderFloat("BGM", &m_BGMVolumeChannel, 0.0f, 1.0f, "%.3f", 1.0f);
+    ImGui::SliderFloat("SFX", &m_SFXVolumeChannel, 0.0f, 1.0f, "%.3f", 1.0f);
+}
+
+void SoundManager::deleteInactiveEmitters()
+{
+    std::unordered_map<EntityID, Source*>::iterator it;
+    for (it = m_Sources.begin(); it != m_Sources.end();) {
+        if (m_World->ValidEntity(it->first)
+            && m_World->HasComponent(it->first, "SoundEmitter")) {
+            if (getSourceState(it->second->ALsource) != AL_STOPPED) {
+                // Nothing to see here, move along
+                it++;
+                continue;
+            } else {
+                // Sound has been stopped / finished playing. 
+                alDeleteBuffers(1, &it->second->ALsource);
+                alDeleteSources(1, &it->second->ALsource);
+                m_World->DeleteEntity(it->first);
+                delete it->second;
+                it = m_Sources.erase(it);
+            }
+        } else {
+            // Entity / Component has been removed
+            stopSound(it->second);
+            alDeleteBuffers(1, &it->second->ALsource);
+            alDeleteSources(1, &it->second->ALsource);
+            delete it->second;
+            it = m_Sources.erase(it);
+        }
+    }
+}
+
+void SoundManager::updateEmitters(double dt)
+{
+    std::unordered_map<EntityID, Source*>::iterator it;
+    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
+        // Get previous pos
+        if (!m_World->ValidEntity(it->first)) {
+            return;
+        }
+        if (!m_World->HasComponent(it->first, "SoundEmitter"))
+            return;
+
+        glm::vec3 previousPos;
+        alGetSource3f(it->second->ALsource, AL_POSITION, &previousPos.x, &previousPos.y, &previousPos.z);
+        // Get next pos
+        if (!m_World->HasComponent(it->first, "Transform"))
+            return;
+        if (!m_World->ValidEntity(m_World->GetParent(it->first))) {
+            return;
+        }
+        glm::vec3 nextPos = Transform::AbsolutePosition(m_World, it->first);
+        // Calculate velocity
+        glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt;
+        setSourcePos(it->second->ALsource, nextPos);
+        setSourceVel(it->second->ALsource, velocity);
+
+        auto emitter = m_World->GetComponent(it->first, "SoundEmitter");
+        setSoundProperties(it->second, &emitter);
+
+        // Path changed
+        if (it->second->SoundResource->Path() != (std::string)emitter["FilePath"]) {
+            it->second->SoundResource = ResourceManager::Load<Sound>((std::string)emitter["FilePath"]);
+            if (it->second->SoundResource->Buffer() != 0) {
+                playSound(it->second);
+            }
+        }
+    }
+}
+
+void SoundManager::updateListener(double dt)
+{
+    // Should only be one listener.
+    auto listenerComponents = m_World->GetComponents("Listener");
+    if (listenerComponents == nullptr || !m_LocalPlayer.Valid()) {
+        return;
+    }
+    for (auto it = listenerComponents->begin(); it != listenerComponents->end(); it++) {
+        EntityWrapper listener(m_World, (*it).EntityID);
+        if (!listener.Valid()) {
+            break;
+        }
+        if (listener.IsChildOf(m_LocalPlayer) || listener == m_LocalPlayer) {
+            glm::vec3 previousPos;
+            alGetListener3f(AL_POSITION, &previousPos.x, &previousPos.y, &previousPos.z); // Get previous pos
+            glm::vec3 nextPos = Transform::AbsolutePosition(listener); // Get next (current) pos
+            glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt; // Calculate velocity
+            setListenerPos(nextPos);
+            setListenerVel(velocity);
+            setListenerOri(glm::eulerAngles(Transform::AbsoluteOrientation(listener)));
+            break;
+        }
+    }
+}
+
+Source* SoundManager::createSource(std::string filePath)
+{
+    ALuint alSource;
+    alGenSources((ALuint)1, &alSource);
+    alSourcef(alSource, AL_REFERENCE_DISTANCE, 1.0);
+    alSourcef(alSource, AL_MAX_DISTANCE, FLT_MAX);
+    Source* source = new Source();
+    source->ALsource = alSource;
+    source->SoundResource = ResourceManager::Load<Sound>(filePath);
+    return source;
+}
+
+void SoundManager::playSound(Source* source)
+{
+    alSourcei(source->ALsource, AL_BUFFER, source->SoundResource->Buffer());
+    alSourcePlay(source->ALsource);
+}
+
+void SoundManager::playQueue(QueuedBuffers qb)
+{
+    for (int i = 0; i < qb.second.size(); i++) {
+        alSourceQueueBuffers(qb.first, 1, &qb.second[i]);
+    }
+    alSourcePlay(qb.first);
+}
+
+void SoundManager::stopSound(Source* source)
+{
+    alSourceStop(source->ALsource);
+}
+
+bool SoundManager::OnPlaySoundOnEntity(const Events::PlaySoundOnEntity & e)
+{
+    Source* source = createSource(e.FilePath);
+    source->Type = SoundType::SFX;
+    EntityID child = m_World->CreateEntity(e.EmitterID);
+    m_World->AttachComponent(child, "Transform");
+    m_World->AttachComponent(child, "SoundEmitter");
+    m_Sources[child] = source;
+    playSound(source);
+    return false;
+}
+
+bool SoundManager::OnPlaySoundOnPosition(const Events::PlaySoundOnPosition & e)
+{
+    Source* source = createSource(e.FilePath);
+    auto emitterID = m_World->CreateEntity();
+    auto transform = m_World->AttachComponent(emitterID, "Transform");
+    (glm::vec3&)transform["Position"] = e.Position;
+    auto emitter = m_World->AttachComponent(emitterID, "SoundEmitter");
+    (float&)(double)emitter["Gain"] = e.Gain;
+    (float&)(double)emitter["Pitch"] = e.Pitch;
+    (bool&)emitter["Loop"] = e.Loop;
+    (float&)(double)emitter["MaxDistance"] = e.MaxDistance;
+    (float&)(double)emitter["RollOffFactor"] = e.RollOffFactor;
+    (float&)(double)emitter["ReferenceDistance"] = e.ReferenceDistance;
+    source->Type = SoundType::SFX;
+    m_Sources[emitterID] = source;
+    playSound(source);
+    return true;
+}
+
+bool SoundManager::OnPauseSound(const Events::PauseSound & e)
+{
+    alSourcePause(m_Sources[e.EmitterID]->ALsource);
+    return true;
+}
+
+bool SoundManager::OnStopSound(const Events::StopSound & e)
+{
+    alSourceStop(m_Sources[e.EmitterID]->ALsource);
+    return true;
+}
+
+bool SoundManager::OnContinueSound(const Events::ContinueSound & e)
+{
+    alSourcePlay(m_Sources[e.EmitterID]->ALsource);
+    return true;
+}
+
+bool SoundManager::OnPlayBackgroundMusic(const Events::PlayBackgroundMusic & e)
+{
+    auto listenerComponents = m_World->GetComponents("Listener");
+    for (auto it = listenerComponents->begin(); it != listenerComponents->end(); it++) {
+        if ((*it).EntityID != m_LocalPlayer.ID) {
+            break;
+        }
+        auto emitterChild = m_World->CreateEntity((*it).EntityID);
+        auto emitter = m_World->AttachComponent(emitterChild, "SoundEmitter");
+        (bool&)emitter["Loop"] = true;
+        (std::string&)emitter["FilePath"] = e.FilePath;
+        m_World->AttachComponent(emitterChild, "Transform");
+        Source* source = createSource(e.FilePath);
+        source->Type = SoundType::BGM;
+        setSoundProperties(source, &emitter);
+        m_Sources[emitterChild] = source;
+        playSound(source);
+    }
+    return true;
+}
+
+bool SoundManager::OnSetBGMGain(const Events::SetBGMGain & e)
+{
+    m_BGMVolumeChannel = e.Gain;
+    return true;
+}
+
+bool SoundManager::OnSetSFXGain(const Events::SetSFXGain & e)
+{
+    m_SFXVolumeChannel = e.Gain;
+    return true;
+}
+
+bool SoundManager::OnComponentAttached(const Events::ComponentAttached & e)
+{
+    if (e.Component.Info.Name == "SoundEmitter") {
+        auto component = m_World->GetComponent(e.Entity.ID, "SoundEmitter");
+        Source* source = createSource(component["FilePath"]);
+        m_Sources[e.Entity.ID] = source;
+    }
+    return false;
+}
+
+bool SoundManager::OnPause(const Events::Pause & e)
+{
+    for (auto it = m_Sources.begin(); it != m_Sources.end(); it++) {
+        alSourcePause(it->second->ALsource);
+    }
+    return false;
+}
+
+bool SoundManager::OnResume(const Events::Resume &e)
+{
+    for (auto it = m_Sources.begin(); it != m_Sources.end(); it++) {
+        alSourcePlay(it->second->ALsource);
+    }
+    return false;
+}
+
+
+bool SoundManager::OnPlayerSpawned(const Events::PlayerSpawned &e)
+{
+    if (e.PlayerID == -1) { // Local player
+        m_LocalPlayer = e.Player;
+        return true;
+    }
+    return false;
+}
+
+
+bool SoundManager::OnPlayQueueOnEntity(const Events::PlayQueueOnEntity &e)
+{
+    Source* source = createSource(*e.FilePaths.begin());
+    std::vector<ALuint> buffers;
+    buffers.push_back(source->SoundResource->Buffer());
+    source->Type = SoundType::BGM;
+    std::vector<std::string>::const_iterator it;
+    for (it = e.FilePaths.begin() + 1; it != e.FilePaths.end(); it++) {
+        buffers.push_back(ResourceManager::Load<Sound>(*it)->Buffer());
+    }
+    playQueue(QueuedBuffers(source->ALsource, buffers));
+    return true;
+}
+
+ALenum SoundManager::getSourceState(ALuint source)
+{
+    ALenum state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+    return state;
+}
+
+void SoundManager::setGain(Source * source, float gain)
+{
+    alSourcef(source->ALsource, AL_GAIN, gain);
+}
+
+void SoundManager::setSoundProperties(Source* source, ComponentWrapper* soundComponent)
+{
+    float gain = (source->Type == SoundType::SFX) ? m_SFXVolumeChannel : m_BGMVolumeChannel;
+    alSourcef(source->ALsource, AL_GAIN, (float)(double)(*soundComponent)["Gain"] * gain);
+    alSourcef(source->ALsource, AL_PITCH, (float)(double)(*soundComponent)["Pitch"]);
+    alSourcei(source->ALsource, AL_LOOPING, (int)(bool)(*soundComponent)["Loop"]); // YOLO
+    alSourcef(source->ALsource, AL_MAX_DISTANCE, (float)(double)(*soundComponent)["MaxDistance"]);
+    alSourcef(source->ALsource, AL_ROLLOFF_FACTOR, (float)(double)(*soundComponent)["RollOffFactor"]);
+    alSourcef(source->ALsource, AL_REFERENCE_DISTANCE, (float)(double)(*soundComponent)["ReferenceDistance"]);
+}
+
+void SoundManager::initOpenAL()
+{
+    // Initialize OpenAL
+    m_ALCdevice = alcOpenDevice(nullptr);
+    if (m_ALCdevice != nullptr) {
+        m_ALCcontext = alcCreateContext(m_ALCdevice, nullptr);
+        alcMakeContextCurrent(m_ALCcontext);
+    } else {
+        LOG_ERROR("OpenAL failed to initialize.");
+    }
+}
+
+void SoundManager::setListenerOri(glm::vec3 ori)
+{
+    // Calculate forward and up vector.
+    glm::vec3 forward = glm::vec3(0.0, 0.0, -1.0);
+    forward = glm::rotateX(forward, ori.x);
+    forward = glm::rotateY(forward, ori.y);
+    forward = glm::rotateZ(forward, ori.z);
+    glm::normalize(forward);
+    glm::vec3 up = glm::vec3(0.0, 1.0, 0.0);
+    up = glm::rotateX(up, ori.x);
+    up = glm::rotateY(up, ori.y);
+    up = glm::rotateZ(up, ori.z);
+    glm::normalize(up);
+    ALfloat lOri[6] = { forward.x, forward.y, forward.z, up.x, up.y, up.z };
+    alListenerfv(AL_ORIENTATION, lOri);
+}

src/Engine/Sound/SoundSystem.cpp

@@ -1,308 +0,0 @@
-#include "Sound/SoundSystem.h"
-
-SoundSystem::SoundSystem(World* world, EventBroker* eventBroker, bool editorMode)
-{
-    m_EventBroker = eventBroker;
-    m_World = world;
-    m_EditorEnabled = editorMode;
-
-    initOpenAL();
-
-    alSpeedOfSound(340.29f);
-    alDistanceModel(AL_LINEAR_DISTANCE);
-    alDopplerFactor(1);
-
-    EVENT_SUBSCRIBE_MEMBER(m_EPlaySoundOnEntity, &SoundSystem::OnPlaySoundOnEntity);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlaySoundOnPosition, &SoundSystem::OnPlaySoundOnPosition);
-    EVENT_SUBSCRIBE_MEMBER(m_EPlayBackgroundMusic, &SoundSystem::OnPlayBackgroundMusic);
-    EVENT_SUBSCRIBE_MEMBER(m_EStopSound, &SoundSystem::OnStopSound);
-    EVENT_SUBSCRIBE_MEMBER(m_EPauseSound, &SoundSystem::OnPauseSound);
-    EVENT_SUBSCRIBE_MEMBER(m_EContinueSound, &SoundSystem::OnContinueSound);
-    EVENT_SUBSCRIBE_MEMBER(m_ESetBGMGain, &SoundSystem::OnSetBGMGain);
-    EVENT_SUBSCRIBE_MEMBER(m_ESetSFXGain, &SoundSystem::OnSetSFXGain);
-}
-
-SoundSystem::~SoundSystem()
-{
-    stopEmitters(); // Stopps emitters
-    deleteInactiveEmitters(); // Deletes stopped emitters
-    // Delete entities
-    std::unordered_map<EntityID, Source*>::iterator it;
-    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
-        m_World->DeleteEntity((*it).first);
-    }
-    m_Sources.clear();
-
-    alcDestroyContext(m_ALCcontext);
-    alcCloseDevice(m_ALCdevice);
-}
-
-void SoundSystem::stopEmitters()
-{
-    std::unordered_map<EntityID, Source*>::iterator it;
-    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
-        if (getSourceState(it->second->ALsource) == AL_PLAYING) {
-            stopSound(it->second);
-        }
-    }
-}
-
-void SoundSystem::Update(double dt)
-{ 
-    m_EventBroker->Process<SoundSystem>();
-    addNewEmitters(dt); // can be optimized with "EEntityCreated"
-    deleteInactiveEmitters(); // can be optimized with "EEntityDeleted"
-    updateEmitters( dt);
-    updateListener( dt);
-}
-
-void SoundSystem::deleteInactiveEmitters()
-{
-    std::unordered_map<EntityID, Source*>::iterator it;
-    for (it = m_Sources.begin(); it != m_Sources.end();) {
-        if (m_World->ValidEntity(it->first) 
-            && m_World->HasComponent(it->first, "SoundEmitter")) {
-            if (getSourceState(it->second->ALsource) != AL_STOPPED) {
-                // Nothing to see here, move along
-                it++;
-                continue;
-            } else {
-                // Sound has been stopped / finished playing. 
-                alDeleteBuffers(1, &it->second->ALsource);
-                alDeleteSources(1, &it->second->ALsource);
-                m_World->DeleteEntity(it->first);
-                delete it->second;
-                it = m_Sources.erase(it);
-            }
-        } else {
-            // Entity / Component has been removed
-            stopSound((*it).second);
-            alDeleteBuffers(1, &it->second->ALsource);
-            alDeleteSources(1, &it->second->ALsource);
-            delete it->second;
-            it = m_Sources.erase(it);
-        }
-    }
-}
-
-void SoundSystem::addNewEmitters(double dt)
-{
-    auto emitterComponents = m_World->GetComponents("SoundEmitter");
-    if (emitterComponents == nullptr) {
-        return;
-    }
-    for (auto it = emitterComponents->begin(); it != emitterComponents->end(); it++) {
-        EntityID emitter = (*it).EntityID;
-        std::unordered_map<EntityID, Source*>::iterator source;
-        source = m_Sources.find(emitter);
-        if (source == m_Sources.end()) { // Did not exist, add it
-            Source* source = createSource((std::string)(*it)["FilePath"]);
-            m_Sources[emitter] = source;
-        }
-    }
-}
-
-void SoundSystem::updateEmitters(double dt)
-{
-    std::unordered_map<EntityID, Source*>::iterator it;
-    for (it = m_Sources.begin(); it != m_Sources.end(); it++) {
-        // Get previous pos
-        glm::vec3 previousPos;
-        alGetSource3f(it->second->ALsource, AL_POSITION, &previousPos.x, &previousPos.y, &previousPos.z);
-        // Get next pos
-        glm::vec3 nextPos = Transform::AbsolutePosition(m_World, it->first);
-        // Calculate velocity
-        glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt;
-        setSourcePos(it->second->ALsource, nextPos);
-        setSourceVel(it->second->ALsource, velocity);
-        float gain;
-        if (it->second->Type == SoundType::SFX) {
-            gain = m_SFXVolumeChannel;
-        } else if (it->second->Type == SoundType::BGM) {
-            gain = m_BGMVolumeChannel;
-        }
-        auto emitter = m_World->GetComponent(it->first, "SoundEmitter");
-        setSoundProperties(it->second->ALsource, &emitter);
-
-        // To make an emitter play when spawned in editor mode
-        if (m_EditorEnabled) {
-            // Path changed
-            if (it->second->SoundResource->Path() != (std::string)emitter["FilePath"]) {
-                it->second->SoundResource = ResourceManager::Load<Sound>((std::string)emitter["FilePath"]);
-                if (it->second->SoundResource->Buffer() != 0) {
-                    playSound(it->second);
-                }
-            }
-        }
-    }
-}
-
-void SoundSystem::updateListener(double dt)
-{
-    // Should only be one listener.
-    auto listenerComponents = m_World->GetComponents("Listener");
-    if (listenerComponents == nullptr) {
-        return;
-    }
-    for (auto it = listenerComponents->begin(); it != listenerComponents->end(); it++) {
-        EntityID listener = (*it).EntityID;
-        glm::vec3 previousPos;
-        alGetListener3f(AL_POSITION, &previousPos.x, &previousPos.y, &previousPos.z); // Get previous pos
-        glm::vec3 nextPos = Transform::AbsolutePosition(m_World, listener); // Get next (current) pos
-        glm::vec3 velocity = glm::vec3(nextPos - previousPos) / (float)dt; // Calculate velocity
-        setListenerPos(nextPos);
-        setListenerVel(velocity);
-        setListenerOri(glm::eulerAngles(Transform::AbsoluteOrientation(m_World, listener)));
-    }
-}
-
-Source* SoundSystem::createSource(std::string filePath)
-{
-    ALuint alSource;
-    alGenSources((ALuint)1, &alSource);
-    alSourcef(alSource, AL_REFERENCE_DISTANCE, 1.0);
-    alSourcef(alSource, AL_MAX_DISTANCE, FLT_MAX);
-    Source* source = new Source();
-    source->ALsource = alSource;
-    source->SoundResource = ResourceManager::Load<Sound>(filePath);
-    return source;
-}
-
-void SoundSystem::playSound(Source* source)
-{
-    alSourcei(source->ALsource, AL_BUFFER, source->SoundResource->Buffer());
-    alSourcePlay(source->ALsource);
-}
-
-void SoundSystem::stopSound(Source* source)
-{
-    alSourceStop(source->ALsource);
-}
-
-bool SoundSystem::OnPlaySoundOnEntity(const Events::PlaySoundOnEntity & e)
-{
-    Source* source = createSource(e.FilePath);
-    source->Type = SoundType::SFX;
-    m_Sources[e.EmitterID] = source;
-    playSound(source);
-    return false;
-}
-
-bool SoundSystem::OnPlaySoundOnPosition(const Events::PlaySoundOnPosition & e)
-{
-    Source* source = createSource(e.FilePath);
-    auto emitterID = m_World->CreateEntity();
-    auto transform = m_World->AttachComponent(emitterID, "Transform");
-    (glm::vec3&)transform["Position"] = e.Position;
-    auto emitter = m_World->AttachComponent(emitterID, "SoundEmitter");
-    (float&)(double)emitter["Gain"] = e.Gain;
-    (float&)(double)emitter["Pitch"] = e.Pitch;
-    (bool&)emitter["Loop"] = e.Loop;
-    (float&)(double)emitter["MaxDistance"] = e.MaxDistance;
-    (float&)(double)emitter["RollOffFactor"] = e.RollOffFactor;
-    (float&)(double)emitter["ReferenceDistance"] = e.ReferenceDistance;
-    auto model = m_World->AttachComponent(emitterID, "Model");
-    (std::string&)model["Resource"] = "Models/Core/UnitCube.mesh"; // 360NoScope UnitCube
-    source->Type = SoundType::SFX;
-    m_Sources[emitterID] = source;
-    playSound(source);
-    return true;
-}
-
-bool SoundSystem::OnPauseSound(const Events::PauseSound & e)
-{
-    alSourcePause(m_Sources[e.EmitterID]->ALsource);
-    return true;
-}
-
-bool SoundSystem::OnStopSound(const Events::StopSound & e)
-{
-    alSourceStop(m_Sources[e.EmitterID]->ALsource);
-    return true;
-}
-
-bool SoundSystem::OnContinueSound(const Events::ContinueSound & e)
-{
-    alSourcePlay(m_Sources[e.EmitterID]->ALsource);
-    return true;
-}
-
-bool SoundSystem::OnPlayBackgroundMusic(const Events::PlayBackgroundMusic & e)
-{
-    auto listenerComponents = m_World->GetComponents("Listener");
-    for (auto it = listenerComponents->begin(); it != listenerComponents->end(); it++) {
-        auto emitterChild = m_World->CreateEntity((*it).EntityID);
-        auto emitter = m_World->AttachComponent(emitterChild, "SoundEmitter");
-        (bool&)emitter["Loop"] = true;
-        (std::string&)emitter["FilePath"] = e.FilePath;
-        m_World->AttachComponent(emitterChild, "Transform");
-        Source* source = createSource(e.FilePath);
-        source->Type = SoundType::BGM;
-        m_Sources[emitterChild] = source;
-        playSound(source);
-    }
-    return true;
-}
-
-bool SoundSystem::OnSetBGMGain(const Events::SetBGMGain & e)
-{
-    m_BGMVolumeChannel = e.Gain;
-    return true;
-}
-
-bool SoundSystem::OnSetSFXGain(const Events::SetSFXGain & e)
-{
-    m_SFXVolumeChannel = e.Gain;
-    return true;
-}
-
-void SoundSystem::setListenerOri(glm::vec3 ori)
-{
-    // Calculate forward and up vector.
-    glm::vec3 forward = glm::vec3(0.0, 0.0, -1.0);
-    forward = glm::rotateX(forward, ori.x);
-    forward = glm::rotateY(forward, ori.y);
-    forward = glm::rotateZ(forward, ori.z);
-    glm::normalize(forward);
-    glm::vec3 up = glm::vec3(0.0, 1.0, 0.0);
-    up = glm::rotateX(up, ori.x);
-    up = glm::rotateY(up, ori.y);
-    up = glm::rotateZ(up, ori.z);
-    glm::normalize(up);
-    ALfloat lOri[6] = { forward.x, forward.y, forward.z, up.x, up.y, up.z };
-    alListenerfv(AL_ORIENTATION, lOri);
-}
-
-ALenum SoundSystem::getSourceState(ALuint source)
-{
-    ALenum state;
-    alGetSourcei(source, AL_SOURCE_STATE, &state);
-    return state;
-}
-
-void SoundSystem::setGain(Source * source, float gain)
-{
-    alSourcef(source->ALsource, AL_GAIN, gain);
-}
-
-void SoundSystem::setSoundProperties(ALuint source, ComponentWrapper* soundComponent)
-{
-    alSourcef(source, AL_GAIN, (float)(double)(*soundComponent)["Gain"]);
-    alSourcef(source, AL_PITCH, (float)(double)(*soundComponent)["Pitch"]);
-    alSourcei(source, AL_LOOPING, (int)(bool)(*soundComponent)["Loop"]); // YOLO
-    alSourcef(source, AL_MAX_DISTANCE, (float)(double)(*soundComponent)["MaxDistance"]);
-    alSourcef(source, AL_ROLLOFF_FACTOR, (float)(double)(*soundComponent)["RollOffFactor"]);
-    alSourcef(source, AL_REFERENCE_DISTANCE, (float)(double)(*soundComponent)["ReferenceDistance"]);
-}
-
-void SoundSystem::initOpenAL()
-{
-    // Initialize OpenAL
-    m_ALCdevice = alcOpenDevice(nullptr);
-    if (m_ALCdevice != nullptr) {
-        m_ALCcontext = alcCreateContext(m_ALCdevice, nullptr);
-        alcMakeContextCurrent(m_ALCcontext);
-    } else {
-        LOG_ERROR("OpenAL failed to initialize.");
-    }
-}

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(
@@ -22,13 +22,17 @@ file(GLOB SOURCE_FILES_Events
 )
 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"
     ${SOURCE_FILES_Systems}
     ${SOURCE_FILES_Events}
-
-    
+	${SOURCE_FILES_Network}
 )
 
 set(LIBRARIES

src/Game/Game.cpp

@@ -1,5 +1,6 @@
 #include "Game.h"
 #include "Collision/FillOctreeSystem.h"
+#include "Collision/FillFrustumOctreeSystem.h"
 #include "Collision/EntityAABB.h"
 #include "Collision/TriggerSystem.h"
 #include "Collision/CollisionSystem.h"
@@ -13,12 +14,17 @@
 #include "Game/Systems/CapturePointSystem.h"
 #include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/WeaponSystem.h"
-#include "Game/Systems/PlayerHUD.h"
+#include "Rendering/AnimationSystem.h"
+#include "Game/Systems/PlayerHUDSystem.h"
+#include "Rendering/BoneAttachmentSystem.h"
 #include "Game/Systems/LifetimeSystem.h"
-#include "../Engine/Rendering/AnimationSystem.h"
+#include "Rendering/AnimationSystem.h"
+#include "Network/MultiplayerSnapshotFilter.h"
 
 Game::Game(int argc, char* argv[])
 {
+    parseArgs(argc, argv);
+
     ResourceManager::RegisterType<ConfigFile>("ConfigFile");
     ResourceManager::RegisterType<Sound>("Sound");
     ResourceManager::RegisterType<Model>("Model");
@@ -73,25 +79,43 @@ Game::Game(int argc, char* argv[])
         fp.MergeEntities(m_World);
     }
 
+    // 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
-    m_OctreeCollision = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
-    m_OctreeTrigger = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
-    m_OctreeFrustrumCulling = new Octree<EntityAABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
+    // TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
+    AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
+    m_OctreeCollision = new Octree<EntityAABB>(boxContainingTheWorld, 4);
+    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<PickupSpawnSystem>(updateOrderLevel);
@@ -99,37 +123,35 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
-    m_SystemPipeline->AddSystem<PlayerHUD>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
-
+    m_SystemPipeline->AddSystem<PlayerHUDSystem>(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;
-    m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
+    m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
     ++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();
-    }
-
-    // Invoke sound system
-    m_SoundSystem = new SoundSystem(m_World, m_EventBroker, m_Config->Get<bool>("Debug.EditorEnabled", false));
-
     m_LastTime = glfwGetTime();
 }
 
 Game::~Game()
 {
     delete m_SystemPipeline;
-    delete m_SoundSystem;
     delete m_OctreeFrustrumCulling;
     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;
@@ -157,40 +179,59 @@ void Game::Tick()
     m_InputProxy->Process();
     m_EventBroker->Swap();
 
+    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);
-    m_SoundSystem->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/Network/MultiplayerSnapshotFilter.cpp

@@ -0,0 +1,33 @@
+#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)) {
+        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/CapturePointSystem.cpp

@@ -1,8 +1,8 @@
 #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)

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

@@ -1,7 +1,7 @@
 #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)

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/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);
 }

src/Game/Systems/PlayerHUDSystem.cpp

@@ -1,21 +1,6 @@
-#include "Game/Systems/PlayerHUD.h"
+#include "Game/Systems/PlayerHUDSystem.h"
 
-PlayerHUD::PlayerHUD(World* world, EventBroker* eventBrokerer)
-    :System(world, eventBrokerer)
-    , m_World(world)
-    , m_EventBroker(eventBrokerer)
-{
-    
-    
-}
-
-PlayerHUD::~PlayerHUD()
-{
-    
-
-}
-
-void PlayerHUD::Update(double dt)
+void PlayerHUDSystem::Update(double dt)
 {
     auto healthHUDs = m_World->GetComponents("HealthHUD");
     if (healthHUDs == nullptr) {

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,20 @@ 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"];
+                double time = (cameraOrientation.x + glm::half_pi<float>()) / glm::pi<float>();
+                cAnimationOffset["Time"] = time;
+            }
         }
 
         ComponentWrapper& cTransform = player["Transform"];
@@ -56,6 +69,12 @@ void PlayerMovementSystem::Update(double dt)
             } else {
                 wishSpeed = playerMovementSpeed;
             }
+            if (player.ID == m_LocalPlayer.ID) {
+                if (glm::length(wishDirection) == 0) {
+                    // If no key is pressed, reset the distance moved since last step.
+                    m_DistanceMoved = 0;
+                }
+            }
             glm::vec3& velocity = cPhysics["Velocity"];
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             ImGui::Text(isOnGround ? "On ground" : "In air");
@@ -100,6 +119,8 @@ void PlayerMovementSystem::Update(double dt)
                     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;
             }
@@ -117,24 +138,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";
                     }
                 }
             }
@@ -142,16 +213,19 @@ void PlayerMovementSystem::Update(double dt)
 
         controller->Reset();
     }
+    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"];
 
@@ -169,6 +243,7 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
         velocity.z *= multiplier;
     }
 
+    // Gravity
     if (cPhysics["Gravity"]) {
         velocity.y -= 9.82f * (float)dt;
     }
@@ -177,10 +252,37 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
     position += velocity * (float)dt;
 }
 
+void PlayerMovementSystem::playerStep(double dt)
+{
+    if (!m_LocalPlayer.Valid()) {
+        return;
+    }
+    // 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"];
+    // 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;
+    if (m_DistanceMoved > m_PlayerStepLength && grounded) {
+        // Player moved a step's distance
+        // Create footstep sound
+        Events::PlaySoundOnEntity e;
+        e.EmitterID = m_LocalPlayer.ID;
+        e.FilePath = m_LeftFoot ? "Audio/footstep/footstep2.wav" : "Audio/footstep/footstep3.wav";
+        m_LeftFoot = !m_LeftFoot;
+        m_EventBroker->Publish(e);
+        m_DistanceMoved = 0.f;
+    }
+}
+
 bool PlayerMovementSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 {
     // When a player spawns, create an input controller for them
     m_PlayerInputControllers[e.Player] = new FirstPersonInputController<PlayerMovementSystem>(m_EventBroker, e.PlayerID);
-
+    if (e.PlayerID == -1) {
+        // Keep track of the local player
+        m_LocalPlayer = e.Player;
+    }
     return true;
 }

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,7 +1,7 @@
 #include "Systems/PlayerSpawnSystem.h"
 
-PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker) 
-    : System(m_World, eventBroker)
+PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params) 
+    : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
@@ -71,6 +71,9 @@ 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)
+    if (!IsClient) {
+        return false;
+    }
 
     // Check if a player already exists
     if (m_PlayerEntities.count(e.PlayerID) != 0) {

src/Game/Systems/SoundSystem.cpp

@@ -0,0 +1,180 @@
+#include "Game/Systems/SoundSystem.h"
+
+SoundSystem::SoundSystem(SystemParams params)
+    : System(params)
+    , PureSystem("SoundEmitter")
+{
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_Announcer = ResourceManager::Load<ConfigFile>("Config.ini")->Get<std::string>("Sound.Announcer", "female");
+    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)
+{ }
+
+void SoundSystem::Update(double dt)
+{
+    // Temp for play test.
+    if (m_DrumsIsPlaying) {
+        m_DrumsIsPlaying = !drumTimer(dt);
+    }
+}
+
+bool SoundSystem::OnPlayerSpawned(const Events::PlayerSpawned &e)
+{
+    if (e.PlayerID == -1) { // Local player
+        m_World->AttachComponent(e.Player.ID, "Listener");
+        Events::PlaySoundOnEntity go;
+        go.EmitterID = LocalPlayer.ID;
+        go.FilePath = "Audio/announcer/" + m_Announcer + "/go.wav";
+        m_EventBroker->Publish(go);
+        // TEMP: starts bgm
+        {
+            Events::PlayBackgroundMusic ev;
+            ev.FilePath = "Audio/bgm/ambient.wav";
+            m_EventBroker->Publish(ev);
+        }
+    }
+    return true;
+}
+
+bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
+{
+    if (e.Command == "Jump" && e.Value > 0) {
+        if (e.PlayerID == -1) { // local player
+            playerJumps();
+            return true;
+        }
+    }
+    if (e.Command == "TakeDamage" && e.Value > 0) {
+        Events::PlayerDamage ev;
+        ev.Player = LocalPlayer;
+        ev.Damage = 1.0;
+        m_EventBroker->Publish(ev);
+    }
+
+    return false;
+}
+
+void SoundSystem::playerJumps()
+{
+    if (!LocalPlayer.Valid()) {
+        return;
+    }
+
+    bool grounded = (bool)m_World->GetComponent(LocalPlayer.ID, "Physics")["IsOnGround"];
+    if (grounded) {
+        Events::PlaySoundOnEntity e;
+        e.EmitterID = LocalPlayer.ID;
+        e.FilePath = "Audio/jump/jump1.wav";
+        m_EventBroker->Publish(e);
+    }
+}
+
+bool SoundSystem::drumTimer(double dt)
+{
+    m_DrumTimer += dt;
+    if (m_DrumTimer > 15) {
+        m_DrumTimer = 0.0;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool SoundSystem::OnCaptured(const Events::Captured & e)
+{
+    int homeTeam = (int)m_World->GetComponent(e.CapturePointID, "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 = LocalPlayer.ID;
+    m_EventBroker->Publish(ev);
+    // Temp for play test.
+    m_DrumsIsPlaying = false;
+    return false;
+}
+
+// Testing purposes atm...
+bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
+{
+    // Should check for only local players here...
+    std::uniform_int_distribution<int> dist(1, 12);
+    int rand = dist(generator);
+    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");
+    //     }
+    Events::PlayQueueOnEntity ev;
+    ev.Emitter = LocalPlayer;
+    ev.FilePaths = paths;
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/die/die2.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/pickup/pickup2.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
+{
+    // Temp for play test.
+    if (m_DrumsIsPlaying) {
+        return false;
+    }
+    if (m_World->HasComponent(e.Trigger.ID, "CapturePoint")) {
+        Events::PlaySoundOnEntity ev; // should be BGM
+        ev.EmitterID = LocalPlayer.ID;
+        ev.FilePath = "Audio/bgm/drumstest.wav";
+        m_EventBroker->Publish(ev);
+        // Temp for play test.
+        m_DrumsIsPlaying = true;
+    }
+    return false;
+}
+
+bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
+{
+    Events::PlaySoundOnEntity ev;
+    ev.EmitterID = LocalPlayer.ID;
+    ev.FilePath = "Audio/jump/jump2.wav";
+    m_EventBroker->Publish(ev);
+    return false;
+}
+
+bool SoundSystem::OnDashAbility(const Events::DashAbility &e)
+{
+    Events::PlaySoundOnEntity ev;
+    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);
 }
@@ -51,7 +51,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     // Set its position and orientation to that of the SpawnPoint
     spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
     // TODO: Quaternions, bitch
-    //spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint.World, spawnPoint.ID));
+    spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
 
     return spawnedEntity;
 }

src/Game/Systems/WeaponSystem.cpp

@@ -1,13 +1,15 @@
 #include "Systems/WeaponSystem.h"
 
-WeaponSystem::WeaponSystem(World* world, EventBroker* eventBroker, IRenderer* renderer)
-    : System(world, eventBroker)
-    , ImpureSystem()
+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_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
 }
 
 void WeaponSystem::Update(double dt)
@@ -15,90 +17,84 @@ void WeaponSystem::Update(double dt)
 
 }
 
-bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e)
+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_ActiveWeapons.at(entity)->Update(dt);
+}
+
+bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
+{
+    EntityWrapper player = e.Player;
     if (e.PlayerID == -1) {
-        m_LocalPlayer = e.Player;
+        player = LocalPlayer;
     }
-    return true;
-}
 
-bool WeaponSystem::OnInputCommand(const Events::InputCommand& e)
-{
-    // Only shoot client-side!
-    if (e.PlayerID != -1) {
+    // Make sure player is alive
+    if (!player.Valid()) {
         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;
+    // 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();
+            }
         }
-        m_EventBroker->Publish(eShoot);
     }
 
     return true;
 }
 
-bool WeaponSystem::OnShoot(Events::Shoot& eShoot) 
+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_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;
+}
+
+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) {
+    // Only run further picking code for the local player!
+    if (eShoot.Player != LocalPlayer) {
         return false;
     }
 
@@ -138,4 +134,4 @@ bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
     m_EventBroker->Publish(ePlayerDamage);
 
     return true;
-}
+}