Merge remote-tracking branch 'origin/Importer' into Animations

# Conflicts:
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/RenderingWorld.xml
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/PickingPass.cpp
#	src/Engine/Rendering/Skeleton.cpp

CMakeLists.txt

@@ -16,6 +16,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
 elseif(MSVC)
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 #set(BUILD_SHARED_LIBS FALSE)

include/Engine/Collision/CollidableOctreeSystem.h

@@ -9,9 +9,9 @@
 class CollidableOctreeSystem : public ImpureSystem, public PureSystem
 {
 public:
-    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree)
+    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree, const std::string& componentType)
         : System(world, eventBroker)
-        , PureSystem("Collidable")
+        , PureSystem(componentType)
         , m_Octree(octree)
     { }
 

include/Engine/Core/ComponentWrapper.h

@@ -81,7 +81,7 @@ class ComponentWrapperFactory
 {
 public:
     ComponentWrapperFactory() = default;
-    ComponentWrapperFactory(std::string componentTypeName, std::size_t allocation = 0)
+    ComponentWrapperFactory(std::string componentTypeName, unsigned int allocation = 0)
     {
         m_ComponentInfo.Name = componentTypeName;
         m_ComponentInfo.Meta->Allocation = allocation;

include/Engine/Core/EntityFile.h

@@ -143,7 +143,7 @@ private:
     ~EntityFile();
 
 public:
-    static std::size_t GetTypeStride(std::string typeName);
+    static unsigned int GetTypeStride(std::string typeName);
     static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
     static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
 

include/Engine/Core/Octree.h

@@ -149,7 +149,7 @@ template<typename T>
 template<typename Box>
 void Octree<T>::ObjectsInSameRegion(const Box& box, std::vector<T>& outObjects)
 {
-    //static_assert(std::is_base_of<AABB, Box>::value, "template argument type Box in Octree<T>::ObjectsInSameRegion must be a subclass of AABB.");
+    static_assert(std::is_base_of<AABB, Box>::value, "template argument type Box in Octree<T>::ObjectsInSameRegion must be a subclass of AABB.");
     falsifyObjectChecks();
     m_Root->ObjectsInSameRegion(box, outObjects);
 }

include/Engine/Core/ResourceManager.h

@@ -200,13 +200,16 @@ static T* ResourceManager::Load(const std::string& resourceName, Resource* paren
     }
 
     //If resource has already been cached and completely loaded.
-    it = m_ResourceCache.find(cacheKey);
-    if (it != m_ResourceCache.end()) {
-        if (it->second != nullptr) {
-            return static_cast<T*>(it->second);
-        } else {
-            //Don't return null on failure, exception instead.
-            throw Resource::FailedLoadingException();
+    {
+        boost::lock_guard<decltype(m_Mutex)> guard(m_Mutex);
+        it = m_ResourceCache.find(cacheKey);
+        if (it != m_ResourceCache.end()) {
+            if (it->second != nullptr) {
+                return static_cast<T*>(it->second);
+            } else {
+                //Don't return null on failure, exception instead.
+                throw Resource::FailedLoadingException();
+            }
         }
     }
 

include/Engine/Core/Util/FileWatcher.h

@@ -42,7 +42,7 @@ enum class FileWatcher::FileEventFlags
 };
 
 inline FileWatcher::FileEventFlags operator|(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<FileWatcher::FileEventFlags>(static_cast<int>(a) | static_cast<int>(b)); }
-inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return static_cast<int>(a)& static_cast<int>(b); }
+inline bool operator&(FileWatcher::FileEventFlags a, FileWatcher::FileEventFlags b) { return (static_cast<int>(a) & static_cast<int>(b)) != 0; }
 
 class FileWatcher::Worker
 {
@@ -54,7 +54,7 @@ public:
 private:
 	struct FileInfo
 	{
-		int Size;
+		std::size_t Size;
 		std::time_t Timestamp;
 	};
 

include/Engine/Editor/EditorCameraInputController.h

@@ -23,7 +23,7 @@ public:
         m_SpeedMultiplier = m_Config->Get<float>("Editor.CameraSpeed", 3.f);
     }
     
-    virtual const glm::vec3 Movement() const override { return m_Movement * m_SpeedMultiplier; }
+    virtual const glm::vec3 Movement() const override { return m_Movement * static_cast<float>(m_SpeedMultiplier); }
 
     void Enable() { m_Enabled = true; }
     void Disable() { m_Enabled = false; }
@@ -69,7 +69,7 @@ public:
 protected:
     ConfigFile* m_Config;
     bool m_Enabled = false;
-    float m_SpeedMultiplier = 1.f;
+    double m_SpeedMultiplier = 1.f;
 
     EventRelay<EventContext, Events::MousePress> m_EMousePress;
     bool OnMousePress(const Events::MousePress& e)
@@ -105,7 +105,7 @@ protected:
             return false;
         }
 
-        m_SpeedMultiplier += e.DeltaY * (0.1f * m_SpeedMultiplier);
+        m_SpeedMultiplier += e.DeltaY * (0.1 * m_SpeedMultiplier);
         m_Config->Set("Editor.CameraSpeed", m_SpeedMultiplier);
         m_Config->SaveToDisk();
         return true;

include/Engine/Editor/EditorGUI.h

@@ -7,7 +7,7 @@
 #include <nativefiledialog/nfd.h>
 #include <boost/filesystem.hpp>
 #include <boost/any.hpp>
-#include <boost/sort/spreadsort/string_sort.hpp>
+#include <boost/algorithm/string/replace.hpp>
 #include "../Common.h"
 #include "../GLM.h"
 #include <glm/gtx/common.hpp>
@@ -19,6 +19,8 @@
 #include "../Core/ResourceManager.h"
 #include "../Core/EPause.h"
 #include "../Core/EKeyDown.h"
+#include "../Core/ELockMouse.h"
+#include "../Core/EFileDropped.h"
 #include "../Rendering/Texture.h"
 
 class EditorGUI
@@ -33,6 +35,12 @@ public:
         Scale
     };
 
+    enum class WidgetSpace
+    {
+        Global,
+        Local
+    };
+
     void Draw();
 
     void SelectEntity(EntityWrapper entity);
@@ -74,6 +82,9 @@ public:
     // Called when the user selects a widget mode.
     typedef std::function<void(WidgetMode)> OnWidgetMode_t;
     void SetWidgetModeCallback(OnWidgetMode_t f) { m_OnWidgetMode = f; }
+    // Called when the user selects a widget space.
+    typedef std::function<void(WidgetSpace)> OnWidgetSpace_t;
+    void SetWidgetSpaceCallback(OnWidgetSpace_t f) { m_OnWidgetSpace = f; }
 
 private:
     World* m_World;
@@ -94,8 +105,12 @@ private:
     EntityWrapper m_CurrentlyDragging = EntityWrapper::Invalid;
     std::string m_LastErrorMessage;
     WidgetMode m_CurrentWidgetMode = WidgetMode::Translate;
+    WidgetSpace m_CurrentWidgetSpace = WidgetSpace::Global;
     std::set<std::string> m_ModalsToOpen;
     std::map<std::string, boost::any> m_ModalData;
+    std::string m_DroppedFile = "";
+    bool m_Paused = false;
+    bool m_MouseLocked = false;
 
     // Callbacks
     OnEntitySelectedCallback_t m_OnEntitySelected = nullptr;
@@ -108,10 +123,21 @@ private:
     OnComponentAttach_t m_OnComponentAttach = nullptr;
     OnComponentDelete_t m_OnComponentDelete = nullptr;
     OnWidgetMode_t m_OnWidgetMode = nullptr;
+    OnWidgetSpace_t m_OnWidgetSpace = nullptr;
 
     // Events
     EventRelay<EditorGUI, Events::KeyDown> m_EKeyDown;
     bool OnKeyDown(const Events::KeyDown& e);
+    EventRelay<EditorGUI, Events::FileDropped> m_EFileDropped;
+    bool OnFileDropped(const Events::FileDropped& e);
+    EventRelay<EditorGUI, Events::Pause> m_EPause;
+    bool OnPause(const Events::Pause& e);
+    EventRelay<EditorGUI, Events::Resume> m_EResume;
+    bool OnResume(const Events::Resume& e);
+    EventRelay<EditorGUI, Events::LockMouse> m_ELockMouse;
+    bool OnLockMouse(const Events::LockMouse& e);
+    EventRelay<EditorGUI, Events::UnlockMouse> m_EUnlockMouse;
+    bool OnUnlockMouse(const Events::UnlockMouse& e);
 
     // Utility functions
     boost::filesystem::path fileOpenDialog();
@@ -119,6 +145,8 @@ private:
     const std::string formatEntityName(EntityWrapper entity);
     GLuint tryLoadTexture(std::string filePath);
     void openModal(const std::string& modal);
+    void setWidgetMode(WidgetMode mode);
+    void toggleWidgetSpace();
     static bool compareCharArray(const char* c1, const char* c2);
 
     // Entity file handling methods

include/Engine/Editor/EditorSystem.h

@@ -41,6 +41,7 @@ private:
     double m_LastTime = 0.f;
     bool m_Enabled = true;
     EditorGUI::WidgetMode m_WidgetMode = EditorGUI::WidgetMode::Translate;
+    EditorGUI::WidgetSpace m_WidgetSpace = EditorGUI::WidgetSpace::Global;
     EntityWrapper m_Widget = EntityWrapper::Invalid;
     EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
 
@@ -57,6 +58,7 @@ private:
     void OnEntityChangeName(EntityWrapper entity, const std::string& name);
     void OnComponentAttach(EntityWrapper entity, const std::string& componentType);
     void OnComponentDelete(EntityWrapper entity, const std::string& componentType);
+    void OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace);
 
     // Events
     EventRelay<EditorSystem, Events::MousePress> m_EMousePress;

include/Engine/Input/FirstPersonInputController.h

@@ -4,6 +4,7 @@
 #include "../GLM.h"
 #include "../Core/InputController.h"
 #include "../Core/ELockMouse.h"
+#include "InputHandler.h"
 
 template <typename EventContext>
 class FirstPersonInputController : public InputController<EventContext>
@@ -15,20 +16,45 @@ public:
     virtual const glm::vec3 Rotation() const { return m_Rotation; }
     virtual bool Jumping() const { return m_Jumping; }
     virtual bool Crouching() const { return m_Crouching; }
-    
+    virtual bool DoubleJumping() const { return m_DoubleJumping; }
+    virtual void SetDoubleJumping(bool isDoubleJumping) {
+        m_DoubleJumping = isDoubleJumping;
+    }
+
     void LockMouse();
     void UnlockMouse();
     virtual bool OnCommand(const Events::InputCommand& e) override;
     virtual void Reset();
 
+    void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer);
+    virtual bool AssaultDashDoubleTapped() const { return m_AssaultDashDoubleTapped; }
+    virtual bool PlayerIsDashing() const { return m_PlayerIsDashing; }
+
 protected:
     const int m_PlayerID;
     bool m_MouseLocked = false;
     glm::vec3 m_Rotation;
     glm::vec3 m_Movement;
     bool m_Jumping = false;
+    bool m_DoubleJumping = false;
     bool m_Crouching = false;
-    
+    //assault dash membervariables - needed to calculate the doubletap- and dashlogic
+    double m_AssaultDashDoubleTapDeltaTime = 0.0;
+    double m_AssaultDashCoolDownTimer = 0.0;
+    //i will let m_AssaultDashDoubleTapSensitivityTimer stay hardcoded, its not really a gamevariable (more an inputvariable), 
+    //and its very unlikely that someone wants to change that value
+    const float m_AssaultDashDoubleTapSensitivityTimer = 0.25f;
+    std::string m_AssaultDashTapDirection = "";
+    std::string m_CurrentDirectionVector = "";
+    bool m_AssaultDashDoubleTapped = false;
+    bool m_PlayerIsDashing = false;
+    bool m_ShiftDashing = false;
+    bool m_ValidDoubleTap = false;
+
+    //specialabilitys
+    bool m_MovementKeyDown = false;
+    bool m_SpecialAbilityKeyDown = false;
+
     EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
     bool OnLockMouse(const Events::LockMouse& e);
     EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
@@ -36,7 +62,7 @@ protected:
 };
 
 template <typename EventContext>
-FirstPersonInputController<EventContext>::FirstPersonInputController(EventBroker* eventBroker, int playerID) 
+FirstPersonInputController<EventContext>::FirstPersonInputController(EventBroker* eventBroker, int playerID)
     : InputController(eventBroker)
     , m_PlayerID(playerID)
 {
@@ -99,6 +125,26 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
         }
     }
 
+    if (e.Command == "Forward" || e.Command == "Right") {
+        if (e.Value != 0) {
+            m_CurrentDirectionVector = e.Command == "Right" ? (e.Value > 0 ? "Right" : "Left") : (e.Value > 0 ? "Forward" : "Backward");
+        }
+        //if value = 0 then you have just released this key
+        if (e.Value != 0) {
+            m_MovementKeyDown = true;
+            //if you pressed the same key within m_AssaultDashDoubleTapSensitivityTimer then you have doubletapped it
+            if (m_AssaultDashDoubleTapDeltaTime < m_AssaultDashDoubleTapSensitivityTimer && m_AssaultDashTapDirection == m_CurrentDirectionVector) {
+                m_ValidDoubleTap = true;
+            }
+        } else {
+            //== 0
+            m_MovementKeyDown = false;
+            //you have just released the key, store what key it was and reset the doubletap-sensitivity-timer
+            m_AssaultDashTapDirection = m_CurrentDirectionVector;
+            m_AssaultDashDoubleTapDeltaTime = 0.f;
+        }
+    }
+
     if (e.Command == "Jump") {
         m_Jumping = e.Value > 0;
     }
@@ -107,21 +153,83 @@ bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputComm
         m_Crouching = e.Value > 0;
     }
 
+    if (e.Command == "SpecialAbility") {
+        if (e.Value > 0) {
+            m_SpecialAbilityKeyDown = true;
+        } else {
+            m_SpecialAbilityKeyDown = false;
+        }
+    }
+    if (m_SpecialAbilityKeyDown && m_MovementKeyDown) {
+        m_ShiftDashing = true;
+    } else {
+        m_ShiftDashing = false;
+    }
+
     return true;
 }
 
 template <typename EventContext>
 bool FirstPersonInputController<EventContext>::OnUnlockMouse(const Events::UnlockMouse& e)
 {
-    m_MouseLocked = false; 
+    m_MouseLocked = false;
     return true;
 }
 
 template <typename EventContext>
 bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMouse& e)
 {
-    m_MouseLocked = true; 
+    m_MouseLocked = true;
     return true;
 }
 
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer) {
+    m_AssaultDashDoubleTapDeltaTime += dt;
+    m_AssaultDashCoolDownTimer -= dt;
+    //cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)
+    if (m_AssaultDashCoolDownTimer > (assaultDashCoolDownMaxTimer - 0.25f)) {
+        m_PlayerIsDashing = true;
+    } else {
+        m_PlayerIsDashing = false;
+    }
+
+    //dashing with shift
+    if (m_ShiftDashing && m_AssaultDashCoolDownTimer <= 0.0f && !isJumping) {
+        //player is dashing with shift
+        //the wanted-direction is set in playermovement already so we dont need to check what direction we want to dash in!
+        m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
+        m_AssaultDashDoubleTapped = true;
+        m_AssaultDashDoubleTapDeltaTime = 0.f;
+        //moving to the side has priority
+        return;
+    }
+
+    //dashing with doubletap - check if doubletap to dash enabled
+    if (ResourceManager::Load<ConfigFile>("Input.ini")->Get<bool>("Keyboard.DoubleTapToDash", false)) {
+        return;
+    }
+
+    //reset the DoubleTapped state in case we recently doubleTapped (doubletap will only happen during 1 frame)
+    if (m_AssaultDashDoubleTapped) {
+        m_AssaultDashDoubleTapped = false;
+    }
+
+    //check if we have received a valid doubletap
+    if (!m_ValidDoubleTap) {
+        return;
+    }
+    m_ValidDoubleTap = false;
+
+    if (!(m_AssaultDashCoolDownTimer <= 0.0f && !isJumping)) {
+        //if we cant dash at the moment, then just reset the tap-sensitivity-timer
+        m_AssaultDashDoubleTapDeltaTime = 0.f;
+        return;
+    }
+    //ok, we have a valid tap, lets do it
+    m_AssaultDashDoubleTapped = true;
+    m_AssaultDashDoubleTapDeltaTime = 0.f;
+    m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
+}
+
 #endif

include/Engine/Network/Client.h

@@ -36,7 +36,7 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending message to server logic
-    int bytesRead = -1;
+    size_t bytesRead = 0;
     char readBuf[INPUTSIZE] = { 0 };
 
     // Packet loss logic
@@ -69,7 +69,7 @@ private:
 
     // Private member functions
     void readFromServer();
-    int  receive(char* data);
+    size_t  receive(char* data);
     void send(Packet& packet);
     void connect();
     void disconnect();

include/Engine/Network/Network.h

@@ -29,7 +29,7 @@ protected:
     unsigned int m_SaveDataIntervalMs = 1000;
     std::clock_t m_SaveDataTimer;
     unsigned int m_MaxConnections;
-    unsigned int m_TimeoutMs;
+    double m_TimeoutMs;
     void saveToFile();
     void updateNetworkData();
     void initialize();

include/Engine/Network/NetworkData.h

@@ -3,16 +3,16 @@
 #include <vector>
 
 struct NetworkData {
-    unsigned int TotalTime = 0;
-    unsigned int TotalDataReceived = 0;
-    unsigned int TotalDataSent = 0;
-    unsigned int AmountOfMessagesReceived = 0;
+    double TotalTime = 0;
+    size_t TotalDataReceived = 0;
+    size_t TotalDataSent = 0;
+    size_t AmountOfMessagesReceived = 0;
     unsigned int AmountOfMessagesSent = 0;
     // Interval based
-    unsigned int DataReceivedThisInterval = 0;
-    unsigned int DataSentThisInterval = 0;
+    size_t DataReceivedThisInterval = 0;
+    size_t DataSentThisInterval = 0;
     // pair: first=reveived, second=send 
-    std::vector<std::pair<unsigned int, unsigned int>> BandwidthBytes;
+    std::vector<std::pair<size_t, size_t>> BandwidthBytes;
 };
 
-#endif
+#endif

include/Engine/Network/Packet.h

@@ -13,7 +13,7 @@ public:
     // arg2: PacketID for identifying packet loss.
     Packet(MessageType type, unsigned int& packetID);
     // Used to create packet from already existing data buffer.
-    Packet(char* data, const int sizeOfPacket);
+    Packet(char* data, const size_t sizeOfPacket);
     Packet(MessageType type);
     ~Packet();
     void Init(MessageType type, unsigned int& packetID);
@@ -51,18 +51,18 @@ public:
     std::string ReadString();
     char* ReadData(int SizeOfData);
     void ChangePacketID(unsigned int& packetID);
-    int Size() { return m_Offset; };
+    size_t Size() { return m_Offset; };
     char* Data() { return m_Data; };
-    unsigned int DataReadSize() { return m_ReturnDataOffset; }
-    unsigned int MaxSize() { return m_MaxPacketSize; }
-    unsigned int HeaderSize() { return m_HeaderSize; }
+    size_t DataReadSize() { return m_ReturnDataOffset; }
+    size_t MaxSize() { return m_MaxPacketSize; }
+    size_t HeaderSize() { return m_HeaderSize; }
 
 private:
     char* m_Data;
-    unsigned int m_ReturnDataOffset = 0;
-    int m_Offset = 0;
-    unsigned int m_MaxPacketSize = 512;
-    unsigned int m_HeaderSize = 0;
+    size_t m_ReturnDataOffset = 0;
+    size_t m_Offset = 0;
+    size_t m_MaxPacketSize = 512;
+    size_t m_HeaderSize = 0;
     void resizeData();
 };
 

include/Engine/Network/Server.h

@@ -36,14 +36,14 @@ private:
     std::map<PlayerID, PlayerDefinition> m_ConnectedPlayers;
     // HACK: Fix INPUTSIZE
     char readBuffer[INPUTSIZE] = { 0 };
-    int bytesRead = 0;
+    size_t bytesRead = 0;
     // time for previouse message
     std::clock_t previousePingMessage = std::clock();
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
     // How often we send messages (milliseconds)
-    int pingIntervalMs;
-    int snapshotInterval;
+    float pingIntervalMs;
+    float snapshotInterval;
     int checkTimeOutInterval = 100;
     int m_NextPlayerID = 0;
 
@@ -59,7 +59,7 @@ private:
     PacketID m_PreviousPacketID = 0;
 
     // Private member functions
-    int  receive(char* data);
+    size_t receive(char* data);
     void readFromClients();
     void send(PlayerID player, Packet& packet);
     void send(Packet& packet);

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -7,6 +7,7 @@
 #include "ShaderProgram.h"
 //#include "Util/UnorderedMapVec2.h"
 #include "Texture.h"
+#include "imgui/imgui.h"
 
 class DrawColorCorrectionPass
 {
@@ -16,14 +17,13 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(GLuint sceneTexture, GLuint bloomTexture);
+    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure);
 private:
     const IRenderer* m_Renderer;
 
     ShaderProgram* m_ColorCorrectionProgram;
 
     Model* m_ScreenQuad;
-    GLfloat m_Exposure;
 };
 
 #endif 

include/Engine/Rendering/DrawFinalPass.h

@@ -35,8 +35,8 @@ private:
     void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
     void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
 
-    void BindExplosionTextures(std::shared_ptr<ExplosionEffectJob>& job);
-    void BindModelTextures(std::shared_ptr<ModelJob>& job);
+    void BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job);
+    void BindModelTextures(GLuint shaderHandle, std::shared_ptr<ModelJob>& job);
 
     Texture* m_WhiteTexture;
     Texture* m_BlackTexture;
@@ -53,6 +53,14 @@ private:
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapProgram;
+	ShaderProgram* m_ForwardPlusSplatMapProgram;
+
+
+	ShaderProgram* m_ForwardPlusSkinnedProgram;
+	ShaderProgram* m_ExplosionEffectSkinnedProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapSkinnedProgram;
+	ShaderProgram* m_ForwardPlusSplatMapSkinnedProgram;
 };
 
 #endif 

include/Engine/Rendering/ExplosionEffectJob.h

@@ -15,7 +15,7 @@
 
 struct ExplosionEffectJob : ModelJob
 {
-    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
+    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
         : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage)
     {
         ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];

include/Engine/Rendering/IRenderer.h

@@ -25,27 +25,23 @@ class IRenderer
 {
 public:
 	GLFWwindow* Window() const { return m_Window; }
-    //Returns screensize including window border and header
+    //Returns screen size including window border and header
 	Rectangle Resolution() const { return m_Resolution; }
-	void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
+	virtual void SetResolution(const Rectangle& resolution) { m_Resolution = resolution; }
 	bool Fullscreen() { return m_Fullscreen; }
-	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
+	virtual void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
-	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-    //Returns screensize excluding window border and header
-    Rectangle GetViewPortSize() const { return m_ViewPortWidth; }
-    void SetViewPortSize(const Rectangle& viewportWidth) { m_ViewPortWidth = viewportWidth; }
+	virtual void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
+    //Returns screen size excluding window border and header
+    Rectangle GetViewportSize() const { return m_ViewportSize; }
 	virtual void Initialize() = 0;
 	virtual void Update(double dt) = 0;
 	virtual void Draw(RenderFrame& rq) = 0;
     virtual PickData Pick(glm::vec2 screenCord) = 0;
 
-
-    World* m_World; //Temp world, untill viktor merge.
-
 protected:
 	Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
-    Rectangle m_ViewPortWidth = Rectangle::Rectangle(1280, 720);
+    Rectangle m_ViewportSize = Rectangle::Rectangle(1280, 720);
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
 	int m_GLVersion[2];

include/Engine/Rendering/Model.h

@@ -14,11 +14,11 @@ private:
 
 public:
 	~Model();
-    const std::vector<RawModel::MaterialGroup>& MaterialGroups() const { return m_RawModel->MaterialGroups; }
+    const std::vector<RawModel::MaterialProperties>& MaterialGroups() const { return m_RawModel->m_Materials; }
     const glm::mat4& Matrix() const { return m_RawModel->m_Matrix; }
     const RawModel::Vertex* Vertices() const { return m_RawModel->Vertices(); }
 	unsigned int NumberOfVertices() const { return m_RawModel->NumVertices(); }
-	bool isSkined() const { return m_RawModel->isSkined; }
+	bool isSkined() const { return m_RawModel->isSkined(); }
 	GLuint VAO;
 	GLuint ElementBuffer;
     RawModel* m_RawModel;

include/Engine/Rendering/ModelJob.h

@@ -14,39 +14,98 @@
 #include "../Core/World.h"
 #include "../Core/Transform.h"
 #include "Skeleton.h"
+#include "ShaderProgram.h"
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
         : RenderJob()
     {
         Model = model;
-        TextureID = (matGroup.Texture) ? matGroup.Texture->ResourceID : 0;
-        if (modelComponent["DiffuseTexture"]) {
-            DiffuseTexture = matGroup.Texture.get();
-        } else {
-            DiffuseTexture = nullptr;
-        }
-        if (modelComponent["NormalMap"]) {
-            NormalTexture = matGroup.NormalMap.get();
-        } else {
-            NormalTexture = nullptr;
-        }
-        if (modelComponent["SpecularMap"]) {
-            SpecularTexture = matGroup.SpecularMap.get();
-        } else {
-            SpecularTexture = nullptr;
-        }
-        if (modelComponent["GlowMap"]) {
-            IncandescenceTexture = matGroup.IncandescenceMap.get();
-        } else {
-            IncandescenceTexture = nullptr;
-        }
-        DiffuseColor = matGroup.DiffuseColor;
-        SpecularColor = matGroup.SpecularColor;
-        IncandescenceColor = matGroup.IncandescenceColor;
-        StartIndex = matGroup.StartIndex;
-        EndIndex = matGroup.EndIndex;
+		ModelID = model->ResourceID;
+		Type = matProp.type;
+		::RawModel::MaterialBasic* matGroup = matProp.material;
+		switch(matProp.type){
+		case ::RawModel::MaterialType::Basic:
+			if (Model->isSkined()) {
+				ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
+			}
+			else {
+				ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
+			}
+			TextureID = 0;
+			break;
+		case ::RawModel::MaterialType::SingleTextures:
+			{
+				if (Model->isSkined()) {
+					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSkinnedProgram")->ResourceID;
+				}
+				else {
+					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram")->ResourceID;
+				}
+				::RawModel::MaterialSingleTextures* singleTextures = static_cast<::RawModel::MaterialSingleTextures*>(matProp.material);
+				TextureID = (singleTextures->ColorMap.Texture) ? singleTextures->ColorMap.Texture->ResourceID : 0;
+				if (modelComponent["DiffuseTexture"]) {
+					DiffuseTexture.push_back(&singleTextures->ColorMap);
+				}
+
+				if (modelComponent["NormalMap"]) {
+					NormalTexture.push_back(&singleTextures->NormalMap);
+				}
+
+				if (modelComponent["SpecularMap"]) {
+					SpecularTexture.push_back(&singleTextures->SpecularMap);
+				}
+
+				if (modelComponent["GlowMap"]) {
+					IncandescenceTexture.push_back(&singleTextures->IncandescenceMap);
+				}
+			}
+			break;
+		case ::RawModel::MaterialType::SplatMapping:
+			{
+				if (Model->isSkined()) {
+					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapSkinnedProgram")->ResourceID;
+				}
+				else {
+					ShaderID = ResourceManager::Load<ShaderProgram>("#ForwardPlusSplatMapProgram")->ResourceID;
+				}
+				::RawModel::MaterialSplatMapping* SplatTextures = static_cast<::RawModel::MaterialSplatMapping*>(matProp.material);
+
+				SplatMap = &SplatTextures->SplatMap;
+
+				TextureID = (SplatTextures->ColorMaps[0].Texture) ? SplatTextures->ColorMaps[0].Texture->ResourceID : 0;
+				if (modelComponent["DiffuseTexture"]) {
+					for (auto& texture : SplatTextures->ColorMaps) {
+						DiffuseTexture.push_back(&texture);
+					}
+				}
+
+				if (modelComponent["NormalMap"]) {
+					for (auto& texture : SplatTextures->NormalMaps) {
+						NormalTexture.push_back(&texture);
+					}
+				}
+
+				if (modelComponent["SpecularMap"]) {
+					for (auto& texture : SplatTextures->SpecularMaps) {
+						SpecularTexture.push_back(&texture);
+					}
+				}
+
+				if (modelComponent["GlowMap"]) {
+					for (auto& texture : SplatTextures->IncandescenceMaps) {
+						IncandescenceTexture.push_back(&texture);
+					}
+				}
+			}
+			break;
+		}
+        DiffuseColor = matGroup->DiffuseColor;
+        SpecularColor = matGroup->SpecularColor;
+        IncandescenceColor = matGroup->IncandescenceColor;
+        StartIndex = matGroup->StartIndex;
+        EndIndex = matGroup->EndIndex;
         Matrix = matrix;
         Color = modelComponent["Color"];
         Entity = modelComponent.EntityID;
@@ -89,13 +148,16 @@ struct ModelJob : RenderJob
 
     unsigned int TextureID;
     unsigned int ShaderID;
+	unsigned int ModelID;
 
+	::RawModel::MaterialType Type;
     EntityID Entity;
     glm::mat4 Matrix;
-    const Texture* DiffuseTexture;
-    const Texture* NormalTexture;
-    const Texture* SpecularTexture;
-    const Texture* IncandescenceTexture;
+	const ::RawModel::TextureProperties* SplatMap;
+    std::vector<const ::RawModel::TextureProperties*> DiffuseTexture;
+	std::vector<const ::RawModel::TextureProperties*> NormalTexture;
+	std::vector<const ::RawModel::TextureProperties*> SpecularTexture;
+	std::vector<const ::RawModel::TextureProperties*> IncandescenceTexture;
     float Shininess = 0.f;
     glm::vec4 Color;
     const ::Model* Model = nullptr;
@@ -119,7 +181,7 @@ struct ModelJob : RenderJob
 
     void CalculateHash() override
     {
-        Hash = TextureID;
+        Hash = TextureID + ModelID << 10 + ShaderID << 20;
     }
 };
 

include/Engine/Rendering/PickingPass.h

@@ -40,6 +40,7 @@ private:
     const IRenderer* m_Renderer;
 
     ShaderProgram* m_PickingProgram;
+	ShaderProgram* m_PickingSkinnedProgram;
     Camera* m_Camera;
 
     struct PickingInfo

include/Engine/Rendering/RawModelCustom.h

@@ -46,8 +46,14 @@ public:
         glm::vec4 BoneIndices;
         glm::vec4 BoneWeights;
     };
+
+	struct TextureProperties {
+		std::string TexturePath;
+		glm::vec2 UVRepeat;
+		std::shared_ptr<::Texture> Texture;	
+	};
 	
-    struct MaterialGroup
+    struct MaterialBasic
     {
         float SpecularExponent;
         float ReflectionFactor;
@@ -57,60 +63,90 @@ public:
         unsigned int StartIndex;
         unsigned int EndIndex;
         //float Transparency;
-        std::string TexturePath;
-        std::shared_ptr<::Texture> Texture;
-        std::string NormalMapPath;
-        std::shared_ptr<::Texture> NormalMap;
-        std::string SpecularMapPath;
-        std::shared_ptr<::Texture> SpecularMap;
-        std::string IncandescenceMapPath;
-        std::shared_ptr<::Texture> IncandescenceMap;
     };
 
+	struct MaterialSplatMapping : public MaterialBasic
+	{
+		TextureProperties SplatMap;
+		std::vector<TextureProperties> ColorMaps;
+		std::vector<TextureProperties> NormalMaps;
+		std::vector<TextureProperties> SpecularMaps;
+		std::vector<TextureProperties> IncandescenceMaps;
+	};
+
+	struct MaterialSingleTextures : public MaterialBasic
+	{
+		TextureProperties ColorMap;
+		TextureProperties NormalMap;
+		TextureProperties SpecularMap;
+		TextureProperties IncandescenceMap;
+	};
+
+	enum class MaterialType { Basic = 1, SplatMapping, SingleTextures };
+
+	struct MaterialProperties {
+		MaterialType type;
+		MaterialBasic* material;
+	};
+
 	const Vertex*	Vertices() const {
-		if (isSkined) { 
+		if (hasSkin) { 
 			return m_SkinedVertices.data(); 
 		} else {
 			return m_Vertices.data();
 		}
 	};
 
+	unsigned int	VertexSize() const {
+		if (hasSkin) {
+			return sizeof(SkinedVertex);
+		}
+		else {
+			return sizeof(Vertex);
+		}
+	};
+
 	unsigned int	NumVertices() const {
-		if (isSkined) {
+		if (hasSkin) {
 			return m_SkinedVertices.size();
 		} else {
 			return m_Vertices.size();
 		}
 	};
 
-    std::vector<MaterialGroup> MaterialGroups;
-	bool isSkined;
+	bool isSkined() const { return hasSkin; };
+
+	std::vector<MaterialProperties> m_Materials;
 
     std::vector<unsigned int> m_Indices;
     Skeleton* m_Skeleton = nullptr;
     glm::mat4 m_Matrix;
 
 private:
-   
+   	bool hasSkin;
 	std::vector<Vertex> m_Vertices;
 	std::vector<SkinedVertex> m_SkinedVertices;
 
     void ReadMeshFile(std::string filePath);
-    void ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
-    void ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize);
+    void ReadMeshFileHeader(std::size_t& offset, char* fileData);
+    void ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
 
     void ReadMaterialFile(std::string filePath);
-    void ReadMaterials(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
+    void ReadMaterials(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadMaterialSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+	void ReadMaterialBasic(MaterialBasic* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+	void ReadMaterialSingleTexture(MaterialSingleTextures* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+	void ReadMaterialSplatMapping(MaterialSplatMapping* Material, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+	void ReadMaterialTextureProperties(TextureProperties& texture, std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
 
     void ReadAnimationFile(std::string filePath);
-    void ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize);
-    void ReadAnimationClips(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfClips);
-    void ReadAnimationClipSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int clipIndex);
-    void ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation);
+    void ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize);
+    void ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips);
+    void ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex);
+    void ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation);
     
     //void CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID);
 };

include/Engine/Rendering/RenderQueue.h

@@ -26,6 +26,7 @@ struct RenderScene
     std::list<std::shared_ptr<RenderJob>> DirectionalLightJobs;
     Rectangle Viewport;
     bool ClearDepth = false;
+    glm::vec4 AmbientColor;
 
 	void Clear()
 	{
@@ -40,6 +41,9 @@ struct RenderScene
 struct RenderFrame
 {
 public:
+    //TODO: Getters
+    GLfloat Gamma = 2.2f;
+    GLfloat Exposure = 1.f;
 
     void Add(RenderScene &scene)
     {

include/Engine/Rendering/RenderSystem.h

@@ -47,7 +47,6 @@ private:
     void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
     bool isChildOfACamera(EntityWrapper entity);
     bool isChildOfCurrentCamera(EntityWrapper entity);
-
 };
 
 #endif

include/Engine/Rendering/Util/GLError.h

@@ -9,7 +9,7 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
 	GLenum error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s, %i, %s", info, error, gluErrorString(error));
+		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s\nError code: %i, %s\n", info, error, gluErrorString(error));
 		return true;
 	}
 

include/Game/Game.h

@@ -51,6 +51,7 @@ private:
 	GUI::Frame* m_FrameStack;
     World* m_World;
     Octree<EntityAABB>* m_OctreeCollision;
+    Octree<EntityAABB>* m_OctreeTrigger;
     Octree<EntityAABB>* m_OctreeFrustrumCulling;
     SystemPipeline* m_SystemPipeline;
     RenderFrame* m_RenderFrame;

include/Game/Systems/InterpolationSystem.h

@@ -23,7 +23,7 @@ class InterpolationSystem : public PureSystem
         glm::vec3 Position;
         glm::vec3 Scale;
         glm::quat Orientation;
-        double interpolationTime;
+        float interpolationTime;
     };
 public:
     InterpolationSystem(World* world, EventBroker* eventBroker);

include/Game/Systems/PlayerMovementSystem.h

@@ -20,4 +20,5 @@ private:
 
     EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
+
 };

resources/DefaultInput.ini

@@ -15,10 +15,6 @@ Space=Jump
 LeftControl=Crouch
 LeftShift=Sprint
 F1=ToggleEditor
-1=EditorToolMove
-2=EditorToolRotate
-3=EditorToolScale
-X=EditorToggleTransformSpace
 C=ConnectToServer
 N=SwitchToServer
 M=SwitchToClient

resources/Schema/Components.xsd

@@ -11,6 +11,7 @@
 	<xs:include schemaLocation="Components/AABB.xsd"/>
 	<xs:include schemaLocation="Components/PointLight.xsd"/>
 	<xs:include schemaLocation="Components/DirectionalLight.xsd"/>
+	<xs:include schemaLocation="Components/SceneLight.xsd"/>
 	<xs:include schemaLocation="Components/Trigger.xsd"/>
 	<xs:include schemaLocation="Components/ExplosionEffect.xsd"/>
 	<xs:include schemaLocation="Components/Health.xsd"/>
@@ -31,4 +32,5 @@
 	<xs:include schemaLocation="Components/Lifetime.xsd"/>
 	<xs:include schemaLocation="Components/HiddenForLocalPlayer.xsd"/>
 	<xs:include schemaLocation="Components/AnimationOffset.xsd"/>
+	<xs:include schemaLocation="Components/DashAbility.xsd"/>
 </xs:schema>

resources/Schema/Components/CapturePoint.xsd

@@ -6,7 +6,7 @@
 
 	<xs:element name="CapturePoint">
 		<xs:annotation>
-			<xs:documentation>A Capture Point. Add a Team Component to specify who currently owns it</xs:documentation>
+			<xs:documentation>A Capture Point. Make sure to update the HomePoint,CapturePointNumber,Team for each</xs:documentation>
 		</xs:annotation>
 		<xs:complexType>
 			<xs:all>

resources/Schema/Components/DashAbility.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Dash xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="DashAbility.xsd">
+	<CoolDownMaxTimer>2.0</CoolDownMaxTimer>
+</Dash>

resources/Schema/Components/DashAbility.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="DashAbility">
+		<xs:annotation>
+			<xs:documentation>A dash component for one of the classes</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="CoolDownMaxTimer" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the cooldown on dash</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/SceneLight.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<SceneLight xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="SceneLight.xsd">
+	<AmbientColor R="0.2" G="0.2" B="0.2" A="1"/>
+	<Visible>true</Visible>
+	<Gamma>2.2</Gamma>
+	<Exposure>1</Exposure>
+</SceneLight>

resources/Schema/Components/SceneLight.xsd

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	<xs:element name="SceneLight">
+		<xs:annotation>
+			<xs:documentation>Some settings for the scene lighting</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="AmbientColor" type="t:Color" minOccurs="0">
+					<xs:annotation><xs:documentation>Color of the ambient light</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Visible" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Wether the ambient light should be applied or not</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Gamma" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>Gamma correction for the scene</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Exposure" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>The exposure of the camera</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/AnimatedArmy.xml

@@ -20,7 +20,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/dummyscene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="0" Y="-0" Z="0"/>
@@ -31,7 +31,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/animtest.</Resource>
+          <Resource>Models/Test/AnimTest.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="-0.0966923237" Y="1.2939688" Z="0.399702221"/>
@@ -42,7 +42,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/animTest.mesh</Resource>
+          <Resource>Models/Test/AnimTest.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="0" Y="1.31816244" Z="1.1888907"/>
@@ -53,7 +53,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/animTest.mesh</Resource>
+          <Resource>Models/Test/AnimTest.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="0.708824873" Y="1.30000007" Z="0"/>
@@ -64,7 +64,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/animTest.mesh</Resource>
+          <Resource>Models/Test/AnimTest.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="1.36948848" Y="1.20000005" Z="0"/>

resources/Schema/Entities/AssetPedistal.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="AssetBase" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Model>
+      <Resource>Models/Core/UnitCylinder.mesh</Resource>
+      <Color A="1" B="1.56862748" G="1.56862748" R="1.56862748"/>
+    </c:Model>
+    <c:Transform>
+      <Position X="0" Y="-0.231354833" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="Light">
+      <Components>
+        <c:PointLight/>
+        <c:Transform>
+          <Position X="0" Y="0.663784981" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="RotationOrigin">
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.5</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:Transform>
+          <Orientation X="0" Y="28.7916641" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="Asset">
+          <Components>
+            <c:Model>
+              <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="1" Z="0"/>
+              <Orientation X="0.524000049" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CapturePoint.xml

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

resources/Schema/Entities/CaptureTest.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="0.200000003" R="0"/>
         </c:Model>
         <c:Team>
@@ -61,7 +61,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team>
@@ -81,7 +81,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team>
@@ -102,7 +102,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -120,7 +120,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -138,7 +138,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CaptureTestState1.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -42,7 +42,7 @@
           <CaptureTimer>6.9158446328696002</CaptureTimer>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team>
@@ -63,7 +63,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team>
@@ -83,7 +83,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -104,7 +104,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -122,7 +122,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -140,7 +140,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CaptureTestState2.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="0.200000003" R="0"/>
         </c:Model>
         <c:Team>
@@ -61,7 +61,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team/>
@@ -79,7 +79,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team/>
@@ -98,7 +98,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -116,7 +116,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -134,7 +134,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CaptureTestState3.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="0.200000003" R="0"/>
         </c:Model>
         <c:Team>
@@ -61,7 +61,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team>
@@ -81,7 +81,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team>
@@ -101,7 +101,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -122,7 +122,7 @@
           <CapturePointNumber>4</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -140,7 +140,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -158,7 +158,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -176,7 +176,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>
@@ -194,7 +194,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CaptureTestState4.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="0.200000003" R="0"/>
         </c:Model>
         <c:Team>
@@ -61,7 +61,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team/>
@@ -79,7 +79,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
         </c:Model>
         <c:Team/>
         <c:Transform>
@@ -96,7 +96,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team/>
@@ -115,7 +115,7 @@
           <CapturePointNumber>4</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -133,7 +133,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -151,7 +151,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -169,7 +169,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>
@@ -187,7 +187,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CaptureTestState5.xml

@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform>
+      <Position X="0.340887427" Y="0" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:CapturePoint>
+          <HomePointForTeam>
+            <Red/>
+          </HomePointForTeam>
+        </c:CapturePoint>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+          <Color A="1" B="0" G="0.200000003" R="1"/>
+        </c:Model>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="6.60000038" Y="0" Z="0"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:CapturePoint>
+          <CapturePointNumber>1</CapturePointNumber>
+        </c:CapturePoint>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+          <Color A="1" B="1" G="1" R="0"/>
+        </c:Model>
+        <c:Team/>
+        <c:Transform>
+          <Position X="4.46673203" Y="0" Z="3.50259304"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:CapturePoint>
+          <CapturePointNumber>2</CapturePointNumber>
+        </c:CapturePoint>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+          <Color A="1" B="1" G="0.200000003" R="0"/>
+        </c:Model>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="3.00000024" Y="0" Z="0.113596022"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:CapturePoint>
+          <CapturePointNumber>3</CapturePointNumber>
+        </c:CapturePoint>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+          <Color A="1" B="1" G="0.200000003" R="0"/>
+        </c:Model>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="1.75382805" Y="0" Z="0.0895374417"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:CapturePoint>
+          <HomePointForTeam>
+            <Blue/>
+          </HomePointForTeam>
+          <CapturePointNumber>4</CapturePointNumber>
+        </c:CapturePoint>
+        <c:Model>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
+          <Color A="1" B="1" G="0.200000003" R="0"/>
+        </c:Model>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="0.56674248" Y="0" Z="0"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Health/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Player/>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="4.29100037" Y="-0.08556436" Z="1.29717529"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:AABB/>
+        <c:Health/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+        </c:Model>
+        <c:Player/>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="5.43557501" Y="0.888866663" Z="1.55849135"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.600000024" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CollisionTestLevel.xml

@@ -6,7 +6,7 @@
 			<Orientation X="0" Y="0" Z="0"/>
 		</c:Transform>
 		<c:Model>
-			<Resource>Models/DummyScene.mesh</Resource>
+			<Resource>Models/Test/DummyScene.mesh</Resource>
 		</c:Model>
 	</Components>
 	<Children>
@@ -28,7 +28,7 @@
 					<Scale X="2" Y="2" Z="2"/>
 				</c:Transform>
 				<c:Model>
-					<Resource>Models/RotationWidgetX.mesh</Resource>
+					<Resource>Models/Widgets/Rotate/RotationWidgetX.mesh</Resource>
 				</c:Model>
 				<c:Trigger>
 				</c:Trigger>

resources/Schema/Entities/EditorTestWorld.xml

@@ -2,7 +2,9 @@
 <Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:Transform/>
+    <c:Transform>
+      <Position X="0" Y="-1" Z="0"/>
+    </c:Transform>
   </Components>
 
   <Children>
@@ -18,7 +20,7 @@
       </Components>
       <Children/>
     </Entity>
-    <Entity>
+    <Entity name="Listener">
       <Components>
         <c:Camera/>
         <c:Listener/>
@@ -35,23 +37,32 @@
           <Intensity>0.80000001192092896</Intensity>
         </c:DirectionalLight>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Resource>Models/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
         </c:Model>
         <c:RaptorCopter>
-          <Speed>1.0499999523162842</Speed>
+          <Speed>1</Speed>
           <Axis X="0" Y="1" Z="0"/>
         </c:RaptorCopter>
         <c:Transform>
           <Position X="2.1529963" Y="6.59221172" Z="0.169116676"/>
-          <Orientation X="4.16300011" Y="1422.89319" Z="0"/>
+          <Orientation X="4.16300011" Y="7875.41211" Z="0"/>
         </c:Transform>
       </Components>
       <Children/>
     </Entity>
     <Entity name="AssaultTPose">
       <Components>
+        <c:ExplosionEffect>
+          <ColorByDistance>true</ColorByDistance>
+          <Velocity X="0" Y="0" Z="0.300000012"/>
+          <ExplosionOrigin X="0" Y="1.30000007" Z="0"/>
+          <TimeSinceDeath>5.0498686575577523</TimeSinceDeath>
+          <ExplosionDuration>5</ExplosionDuration>
+          <EndColor A="1" B="1" G="0" R="0"/>
+          <RandomnessScalar>3</RandomnessScalar>
+        </c:ExplosionEffect>
         <c:Model>
-          <Resource>Models/Assault.mesh</Resource>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="-1.68900967" Y="0.527161121" Z="-1.59648728"/>
@@ -62,11 +73,26 @@
         <Entity name="SecondaryWeapon">
           <Components>
             <c:Model>
-              <Resource>Models/SecondaryWeapon.mesh</Resource>
+              <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
+              <Transparent>true</Transparent>
             </c:Model>
             <c:Transform>
-              <Position X="-0.546139359" Y="0.853016734" Z="0.177482292"/>
-              <Orientation X="1.47266471" Y="0.524984181" Z="1.243698"/>
+              <Position X="-0.560000002" Y="0.754308224" Z="0.181485131"/>
+              <Orientation X="0.989000022" Y="0" Z="6.10900021"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="SecondaryWeaponRed">
+          <Components>
+            <c:Model>
+              <Resource>Models/Weapons/Red/DefenderGunRed.mesh</Resource>
+              <Transparent>true</Transparent>
+              <NormalMap>false</NormalMap>
+            </c:Model>
+            <c:Transform>
+              <Position X="0.515922487" Y="0.787437975" Z="0.132855967"/>
+              <Orientation X="0.989000022" Y="0" Z="0"/>
             </c:Transform>
           </Components>
           <Children/>
@@ -85,11 +111,11 @@
           <Components>
             <c:Animation>
               <Name>Run</Name>
-              <Time>0.62051775215976157</Time>
+              <Time>0.17818245776980568</Time>
               <Speed>1</Speed>
             </c:Animation>
             <c:Model>
-              <Resource>models/AssaultAnimated.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
             <c:Transform>
               <Position X="0.786919653" Y="0" Z="0"/>
@@ -101,11 +127,11 @@
           <Components>
             <c:Animation>
               <Name>Walk</Name>
-              <Time>0.28779680073140668</Time>
+              <Time>0.34546191187031372</Time>
               <Speed>1</Speed>
             </c:Animation>
             <c:Model>
-              <Resource>models/AssaultAnimated.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
             <c:Transform/>
           </Components>
@@ -131,7 +157,7 @@
     <Entity name="Log">
       <Components>
         <c:Model>
-          <Resource>Models/Log.mesh</Resource>
+          <Resource>Models/Props/TreeLog.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="-4" Y="0.698000014" Z="-1"/>
@@ -147,74 +173,10 @@
         </c:Transform>
       </Components>
       <Children>
-        <Entity name="NormalSphere">
-          <Components>
-            <c:Model>
-              <Resource>Models/NormalMapSphere.mesh</Resource>
-            </c:Model>
-            <c:Transform>
-              <Position X="1.82700014" Y="0" Z="-0.166000009"/>
-            </c:Transform>
-          </Components>
-          <Children/>
-        </Entity>
-        <Entity name="SpecularSphere">
-          <Components>
-            <c:Model>
-              <Resource>Models/SpecularMapSphere.mesh</Resource>
-            </c:Model>
-            <c:Transform>
-              <Position X="-1.06487739" Y="0" Z="1.52336037"/>
-            </c:Transform>
-          </Components>
-          <Children>
-            <Entity name="Rotationpoint">
-              <Components>
-                <c:RaptorCopter>
-                  <Speed>1</Speed>
-                  <Axis X="0.699999988" Y="1" Z="0.300000012"/>
-                </c:RaptorCopter>
-                <c:Transform>
-                  <Orientation X="404.200684" Y="577.428955" Z="173.228897"/>
-                </c:Transform>
-              </Components>
-              <Children>
-                <Entity name="PointLight">
-                  <Components>
-                    <c:Model>
-                      <Resource>Models/Core/UnitSphere.mesh</Resource>
-                      <Color A="1" B="0" G="3.92156863" R="3.92156863"/>
-                    </c:Model>
-                    <c:PointLight>
-                      <Radius>3</Radius>
-                      <Intensity>1.1399998664855957</Intensity>
-                    </c:PointLight>
-                    <c:Transform>
-                      <Position X="0.600000024" Y="0.5" Z="0"/>
-                      <Scale X="0.100000001" Y="0.100000001" Z="0.100000001"/>
-                    </c:Transform>
-                  </Components>
-                  <Children/>
-                </Entity>
-              </Children>
-            </Entity>
-          </Children>
-        </Entity>
-        <Entity name="GlowMap">
-          <Components>
-            <c:Model>
-              <Resource>Models/IncandescenceMapSphere.mesh</Resource>
-            </c:Model>
-            <c:Transform>
-              <Position X="-1.10000002" Y="0" Z="-1.80000007"/>
-            </c:Transform>
-          </Components>
-          <Children/>
-        </Entity>
         <Entity name="CombinedSpheres">
           <Components>
             <c:Model>
-              <Resource>models/NormSpecIncdMapSphere.mesh</Resource>
+              <Resource>Models/Test/NormSpecIncdMapSphere.mesh</Resource>
             </c:Model>
             <c:Transform/>
           </Components>
@@ -227,7 +189,7 @@
               <Axis X="1" Y="1" Z="1"/>
             </c:RaptorCopter>
             <c:Transform>
-              <Orientation X="53.9495354" Y="53.9495354" Z="53.9495354"/>
+              <Orientation X="6484.80273" Y="6484.80273" Z="6484.80273"/>
             </c:Transform>
           </Components>
           <Children>
@@ -284,8 +246,94 @@
             </Entity>
           </Children>
         </Entity>
+        <Entity name="SphereRotationOrigin">
+          <Components>
+            <c:RaptorCopter>
+              <Speed>1</Speed>
+              <Axis X="0" Y="1" Z="0"/>
+            </c:RaptorCopter>
+            <c:Transform>
+              <Orientation X="0" Y="6281.02246" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="NormalSphere">
+              <Components>
+                <c:Model>
+                  <Resource>Models/Test/NormalMapSphere.mesh</Resource>
+                </c:Model>
+                <c:Transform>
+                  <Position X="1.82700014" Y="0" Z="-0.166000009"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+            <Entity name="SpecularSphere">
+              <Components>
+                <c:Model>
+                  <Resource>Models/Test/SpecularMapSphere.mesh</Resource>
+                </c:Model>
+                <c:Transform>
+                  <Position X="-1.06487739" Y="0" Z="1.52336037"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="Rotationpoint">
+                  <Components>
+                    <c:RaptorCopter>
+                      <Speed>1</Speed>
+                      <Axis X="0.699999988" Y="1" Z="0.300000012"/>
+                    </c:RaptorCopter>
+                    <c:Transform>
+                      <Orientation X="4905.44824" Y="7008.50781" Z="2103.03223"/>
+                    </c:Transform>
+                  </Components>
+                  <Children>
+                    <Entity name="PointLight">
+                      <Components>
+                        <c:Model>
+                          <Resource>Models/Core/UnitSphere.mesh</Resource>
+                          <Color A="1" B="0" G="3.92156863" R="3.92156863"/>
+                        </c:Model>
+                        <c:PointLight>
+                          <Radius>3</Radius>
+                          <Intensity>1.1399998664855957</Intensity>
+                        </c:PointLight>
+                        <c:Transform>
+                          <Position X="0.600000024" Y="0.5" Z="0"/>
+                          <Scale X="0.100000001" Y="0.100000001" Z="0.100000001"/>
+                        </c:Transform>
+                      </Components>
+                      <Children/>
+                    </Entity>
+                  </Children>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="GlowMap">
+              <Components>
+                <c:Model>
+                  <Resource>Models/Test/IncandescenceMapSphere.mesh</Resource>
+                </c:Model>
+                <c:Transform>
+                  <Position X="-1.10000002" Y="0" Z="-1.80000007"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
+          </Children>
+        </Entity>
       </Children>
     </Entity>
+    <Entity name="SceneColors">
+      <Components>
+        <c:SceneLight>
+          <Gamma>1.3999999761581421</Gamma>
+        </c:SceneLight>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/EditorWidgetRotate.xml

@@ -18,7 +18,7 @@
           <Axis X="1" Y="0" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/RotationWidgetX.mesh</Resource>
+          <Resource>Models/Widgets/Rotate/RotationWidgetX.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -33,7 +33,7 @@
           <Axis X="0" Y="1" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/RotationWidgetY.mesh</Resource>
+          <Resource>Models/Widgets/Rotate/RotationWidgetY.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -48,7 +48,7 @@
           <Axis X="0" Y="0" Z="1"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/RotationWidgetZ.mesh</Resource>
+          <Resource>Models/Widgets/Rotate/RotationWidgetZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>

resources/Schema/Entities/EditorWidgetScale.xml

@@ -3,7 +3,7 @@
 
   <Components>
     <c:Model>
-      <Resource>Models/ScaleWidgetOrigin.mesh</Resource>
+      <Resource>Models/Widgets/Scale/ScalingWidgetOrigin.mesh</Resource>
     </c:Model>
     <c:Transform/>
     <c:UniformScale>
@@ -20,7 +20,7 @@
           </Type>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/ScaleWidgetX.mesh</Resource>
+          <Resource>Models/Widgets/Scale/ScalingWidgetX.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -34,7 +34,7 @@
           </Type>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/ScaleWidgetY.mesh</Resource>
+          <Resource>Models/Widgets/Scale/ScalingWidgetY.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -48,7 +48,7 @@
           </Type>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/ScaleWidgetZ.mesh</Resource>
+          <Resource>Models/Widgets/Scale/ScalingWidgetZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>

resources/Schema/Entities/EditorWidgetTranslate.xml

@@ -3,7 +3,7 @@
 
   <Components>
     <c:Model>
-      <Resource>Models/TranslationWidgetOrigin.mesh</Resource>
+      <Resource>Models/Widgets/Translate/TranslationWidgetOrigin.mesh</Resource>
     </c:Model>
     <c:Transform/>
     <c:UniformScale>
@@ -18,7 +18,7 @@
           <Axis X="1" Y="0" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/TranslationWidgetX.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetX.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -30,7 +30,7 @@
           <Axis X="0" Y="1" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/TranslationWidgetY.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetY.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -42,7 +42,7 @@
           <Axis X="0" Y="0" Z="1"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/TranslationWidgetZ.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -54,7 +54,7 @@
           <Axis X="0" Y="1" Z="1"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/WidgetPlaneX.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetPlaneX.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -66,7 +66,7 @@
           <Axis X="1" Y="0" Z="1"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/WidgetPlaneY.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetPlaneY.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -78,21 +78,12 @@
           <Axis X="1" Y="1" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/WidgetPlaneZ.mesh</Resource>
+          <Resource>Models/Widgets/Translate/TranslationWidgetPlaneZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
       <Children/>
     </Entity>
-    <Entity name="Light">
-      <Components>
-        <c:PointLight/>
-        <c:Transform>
-          <Position X="0.400000006" Y="0.400000006" Z="0.400000006"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/GameMap.xml

@@ -9,7 +9,7 @@
     <Entity name="Scenemesh">
       <Components>
         <c:Model>
-          <Resource>Models\MapVersion1.mesh</Resource>
+          <Resource>Models/LevelBase/MapVersion1.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -21,7 +21,7 @@
           <Intensity>2</Intensity>
         </c:DirectionalLight>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Resource>Models/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
           <Visible>false</Visible>
         </c:Model>
         <c:Transform>

resources/Schema/Entities/Model.xml

@@ -19,7 +19,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>models/animTest.mesh</Resource>
+          <Resource>Models/Test/AnimTest.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>

resources/Schema/Entities/MovementTest.xml

@@ -42,7 +42,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Assault.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
               <Color A="1" B="0" G="0" R="1"/>
             </c:Model>
             <c:Transform>
@@ -55,7 +55,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Assault.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
               <Color A="1" B="0.0117647061" G="0" R="1"/>
             </c:Model>
             <c:Transform>
@@ -70,7 +70,7 @@
       <Components>
         <c:DirectionalLight/>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Resource>sModels/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="-6.00145912" Y="1.42697716" Z="3.04144025"/>
@@ -153,7 +153,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Assault.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
               <Color A="1" B="1" G="0.254901975" R="0"/>
             </c:Model>
             <c:Transform>
@@ -166,7 +166,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Assault.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
               <Color A="1" B="1" G="0.254901975" R="0"/>
             </c:Model>
             <c:Transform>
@@ -228,7 +228,7 @@
             <Entity name="CameraModel">
               <Components>
                 <c:Model>
-                  <Resource>Models/Camera.mesh</Resource>
+                  <Resource>Models/Widgets/Camera.mesh</Resource>
                 </c:Model>
                 <c:Transform>
                   <Position X="0" Y="0.0331346765" Z="-0.0792061687"/>
@@ -243,7 +243,7 @@
           <Components>
             <c:Camera/>
             <c:Model>
-              <Resource>Models/Camera.mesh</Resource>
+              <Resource>Models/Widgets/Camera.mesh</Resource>
               <Visible>false</Visible>
             </c:Model>
             <c:Transform>
@@ -256,7 +256,7 @@
         <Entity name="PlayerModel">
           <Components>
             <c:Model>
-              <Resource>Models/AssaultHeadless.mesh</Resource>
+              <Resource>Models/Characters/Assault/AssaultHeadless.mesh</Resource>
               <Color A="1" B="0" G="0" R="1"/>
             </c:Model>
             <c:Transform>

resources/Schema/Entities/Player.xml

@@ -2,12 +2,12 @@
 <Entity name="Player" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:Health/>
     <c:AABB>
       <Origin X="0" Y="0.772000015" Z="0"/>
       <Size X="1" Y="1.60000002" Z="1"/>
     </c:AABB>
     <c:Collidable/>
+    <c:Health/>
     <c:Physics>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
@@ -20,7 +20,7 @@
       </Team>
     </c:Team>
     <c:Transform>
-      <Position X="8.60201447e-23" Y="0" Z="3.9201616e-23"/>
+      <Position X="9.56501799e-22" Y="-0.471999973" Z="4.35902473e-22"/>
     </c:Transform>
   </Components>
 
@@ -50,7 +50,7 @@
         <Entity name="CameraModel">
           <Components>
             <c:Model>
-              <Resource>Models/Camera.mesh</Resource>
+              <Resource>Models/Widgets/Camera.mesh</Resource>
               <Visible>false</Visible>
             </c:Model>
             <c:Transform>
@@ -89,7 +89,7 @@
             <Entity name="Crosshair">
               <Components>
                 <c:Model>
-                  <Resource>Models/CrosshairQuad.mesh</Resource>
+                  <Resource>Models/Weapons/CrosshairQuad.mesh</Resource>
                 </c:Model>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.200000003"/>
@@ -101,12 +101,19 @@
             </Entity>
             <Entity name="Weapon">
               <Components>
+                <c:ExplosionEffect>
+                  <ColorByDistance>true</ColorByDistance>
+                  <Velocity X="0.800000012" Y="0.0379999988" Z="0"/>
+                  <ExplosionDuration>3.7999999523162842</ExplosionDuration>
+                  <EndColor A="0" B="23.5294113" G="11.7647057" R="0"/>
+                  <Randomness>true</Randomness>
+                </c:ExplosionEffect>
                 <c:Model>
-                  <Resource>Models/AssaultWeapon.mesh</Resource>
+                  <Resource>Models/Weapons/Red/AssaultWeaponRed.mesh</Resource>
                 </c:Model>
                 <c:Transform>
                   <Position X="0.180000007" Y="-0.183000013" Z="0"/>
-                  <Orientation X="0" Y="4.64700031" Z="0"/>
+                  <Orientation X="0" Y="3.08300018" Z="0"/>
                 </c:Transform>
               </Components>
               <Children/>
@@ -127,7 +134,7 @@
       <Components>
         <c:Camera/>
         <c:Model>
-          <Resource>Models/Camera.mesh</Resource>
+          <Resource>Models/Widgets/Camera.mesh</Resource>
           <Visible>false</Visible>
         </c:Model>
         <c:Transform>
@@ -141,12 +148,12 @@
       <Components>
         <c:Animation>
           <Name>Hold Pos</Name>
-          <Time>0.73515426169631848</Time>
+          <Time>0.73506627647571587</Time>
           <Speed>1</Speed>
         </c:Animation>
         <c:HiddenForLocalPlayer/>
         <c:Model>
-          <Resource>Models/AssaultAnimated.mesh</Resource>
+          <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
           <Color A="1" B="0" G="0" R="1"/>
         </c:Model>
         <c:Transform/>

resources/Schema/Entities/RayBlue.xml

@@ -6,8 +6,9 @@
       <Lifetime>0.25</Lifetime>
     </c:Lifetime>
     <c:Model>
-      <Resource>Models/CylinderBullet.mesh</Resource>
-      <Color A="1" B="39.2156868" G="7.84313726" R="0"/>
+      <Resource>Models/Weapons/CylinderBullet.mesh</Resource>
+      <Color A="0.156862751" B="39.2156868" G="7.84313726" R="0"/>
+      <Transparent>true</Transparent>
     </c:Model>
     <c:Transform>
       <Scale X="0.0109999999" Y="0.0289999992" Z="100"/>

resources/Schema/Entities/RayRed.xml

@@ -6,8 +6,9 @@
       <Lifetime>0.25</Lifetime>
     </c:Lifetime>
     <c:Model>
-      <Resource>Models/CylinderBullet.mesh</Resource>
-      <Color A="1" B="0" G="0.525490224" R="39.2156868"/>
+      <Resource>Models/Weapons/CylinderBullet.mesh</Resource>
+      <Color A="0.156862751" B="0" G="0.525490224" R="39.2156868"/>
+      <Transparent>true</Transparent>
     </c:Model>
     <c:Transform>
       <Scale X="0.0110000009" Y="0.029000001" Z="100"/>

resources/Schema/Entities/RenderingWorld.xml

@@ -20,7 +20,7 @@
         <Entity name="Model">
           <Components>
             <c:Model>
-              <Resource>Models/Assault.obj</Resource>
+              <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
               <Color A="1" B="3.92156863" G="3.92156863" R="3.92156863"/>
             </c:Model>
             <c:Transform>
@@ -35,7 +35,7 @@
               <FOV>80</FOV>
             </c:Camera>
             <c:Model>
-              <Resource>Models/Camera.mesh</Resource>
+              <Resource>Models/Widgets/Camera.mesh</Resource>
             </c:Model>
             <c:Transform>
               <Position X="0" Y="1.39121652" Z="-0.043014247"/>
@@ -133,7 +133,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Assault.mesh</Resource>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
           <Color A="1" B="3.92156863" G="1" R="1"/>
         </c:Model>
         <c:Transform>
@@ -309,7 +309,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/AssaultAnimated.mesh</Resource>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
           <Color A="1" B="1" G="1" R="3.92156863"/>
         </c:Model>
         <c:Transform>
@@ -325,7 +325,7 @@
           <Intensity>0.10000000149011612</Intensity>
         </c:DirectionalLight>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+          <Resource>Models/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
           <Color A="1" B="0" G="3.92156863" R="3.92156863"/>
         </c:Model>
         <c:Transform>

resources/Schema/Entities/ShootEventTest.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.mesh</Resource>
+          <Resource>Models/Test/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="0.200000003" R="0"/>
         </c:Model>
         <c:Team>
@@ -61,7 +61,7 @@
           <CapturePointNumber>1</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="1" G="1" R="0"/>
         </c:Model>
         <c:Team/>
@@ -79,7 +79,7 @@
           <CapturePointNumber>2</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
         </c:Model>
         <c:Team/>
         <c:Transform>
@@ -96,7 +96,7 @@
           <CapturePointNumber>3</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="1" R="1"/>
         </c:Model>
         <c:Team/>
@@ -115,7 +115,7 @@
           <CapturePointNumber>4</CapturePointNumber>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.mesh</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
           <Color A="1" B="0" G="0.200000003" R="1"/>
         </c:Model>
         <c:Team>
@@ -133,7 +133,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -151,7 +151,7 @@
         <c:Health/>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.482352942" G="0.490196079" R="1"/>
         </c:Model>
         <c:Player/>
@@ -171,7 +171,7 @@
         </c:Health>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="0" R="2.25"/>
         </c:Model>
         <c:Player/>
@@ -191,7 +191,7 @@
         </c:Health>
         <c:AABB/>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="0" R="4.5"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/SoundEmitter.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="SoundEmitter" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:SoundEmitter/>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity name="SoundEmitterText">
+      <Components>
+        <c:Text>
+          <Content>SoundEmitter</Content>
+          <Resource>Fonts/DroidSans.ttf,64</Resource>
+        </c:Text>
+        <c:Transform>
+          <Scale X="0.5" Y="0.5" Z="0.5"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/SpawnPointClusterWithModels.xml

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="SpawnerRedTeam" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:PlayerSpawn/>
+    <c:Spawner>
+      <EntityFile>Schema/Entities/Player.xml</EntityFile>
+    </c:Spawner>
+    <c:Team>
+      <Team>
+        <Red/>
+      </Team>
+    </c:Team>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity name="SpawnPointRedTeam">
+      <Components>
+        <c:SpawnPoint/>
+        <c:Model>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="SpawnPointRedTeam">
+      <Components>
+        <c:SpawnPoint/>
+        <c:Model>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-1" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="SpawnPointRedTeam">
+      <Components>
+        <c:SpawnPoint/>
+        <c:Model>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="SpawnPointRedTeam">
+      <Components>
+        <c:SpawnPoint/>
+        <c:Model>
+          <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0" Z="-1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/SpawnerWithPlayerModel.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="SpawnPointRedTeam" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:SpawnPoint/>
+    <c:Model>
+      <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
+    </c:Model>
+    <c:Transform>
+      <Position X="1.31625879" Y="0" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/SplatMapTesWorld.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity>
+      <Components>
+        <c:SceneLight/>
+        <c:Model>
+          <Resource>Models/Test/SplatMapTest.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/Test.xml

@@ -6,7 +6,7 @@
 			<Orientation X="0" Y="0" Z="0"/>
 		</c:Transform>
 		<c:Model>
-			<Resource>Models/DummyScene.mesh</Resource>
+			<Resource>Models/Test/DummyScene.mesh</Resource>
 		</c:Model>
 	</Components>
 	<Children>
@@ -36,7 +36,7 @@
 							<ExponentialAccelaration>0</ExponentialAccelaration>
 						</c:ExplosionEffect>
 				<c:Model>
-					<Resource>Models/Camera.mesh</Resource>
+					<Resource>Models/Widgets/Camera.mesh</Resource>
 				</c:Model>
 			</Components>
 		</Entity>

resources/Schema/Types/Entity.xsd

@@ -31,6 +31,7 @@
 							<xs:element ref="c:PlayerSpawn" minOccurs="0"/>
 							<xs:element ref="c:Team" minOccurs="0"/>
 							<xs:element ref="c:DirectionalLight" minOccurs="0"/>
+							<xs:element ref="c:SceneLight" minOccurs="0"/>
 							<xs:element ref="c:UniformScale" minOccurs="0"/>
 							<xs:element ref="c:EditorWidget" minOccurs="0"/>
 							<xs:element ref="c:Lifetime" minOccurs="0"/>

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -3,6 +3,7 @@
 layout (binding = 0) uniform sampler2D SceneTexture;
 layout (binding = 1) uniform sampler2D BloomTexture;
 uniform float Exposure;
+uniform float Gamma;
 
 in VertexData{
 	vec2 TextureCoordinate;
@@ -12,7 +13,6 @@ out vec4 fragmentColor;
 
 void main()
 {
-	const float gamma = 2.2;
 	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
 	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
 	hdrColor += bloomColor;
@@ -21,7 +21,7 @@ void main()
 	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
 
 	//gamme correction
-	result = pow(result, vec3(1.0 / gamma));
+	result = pow(result, vec3(1.0 / Gamma));
 
 	fragmentColor = vec4(result, 1.0);
 	//fragmentColor = hdrColor;

resources/Shaders/ExplosionEffect.geom.glsl

@@ -17,15 +17,21 @@ uniform bool ExponentialAccelaration;
 in VertexData{
 	vec3 Position;
 	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
 }Input[];
 
 out VertexData{
 	vec3 Position;
 	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
 }Output;
 
 layout(triangles) in;
@@ -114,12 +120,17 @@ void main()
 		{
 			// calculate the max distance (s) the triangle will move
 			float s = (randomVelocity.x * ExplosionDuration) + (0.5 * a * pow(ExplosionDuration, 2));
+			float te = (length(triangleCenter2ExplosionRadius) / s);
 			
-			Output.ExplosionColor = EndColor * (length(triangleCenter2ExplosionRadius) / s);
+			Output.ExplosionColor = EndColor;
+			Output.ExplosionPercentageElapsed = te;
+
 		}
 		else
 		{
-			Output.ExplosionColor = EndColor * timePercetage;
+			Output.ExplosionColor = EndColor;
+			Output.ExplosionPercentageElapsed = timePercetage;
+
 		}
 		
 		// for every vertex on the triangle...
@@ -132,6 +143,8 @@ void main()
 			Output.Normal = Input[i].Normal;
 			Output.Position = Input[i].Position;
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
+			Output.Tangent = Input[i].Tangent;
+			Output.BiTangent = Input[i].BiTangent;
 			
 			// convert to model space for the gravity to always be in -y
 			vec4 ExplodedPositionInModelSpace = M * vec4(ExplodedPosition, 1.0);
@@ -154,11 +167,14 @@ void main()
 		// if explosion color should be affected by distance instead of time...
 		if (ColorByDistance == true)
 		{
-			Output.ExplosionColor = vec4(0.0);
+			Output.ExplosionColor = EndColor;
+			Output.ExplosionPercentageElapsed = 0.0;
 		}
 		else
 		{
-			Output.ExplosionColor = EndColor * timePercetage;
+			Output.ExplosionColor = EndColor;
+			Output.ExplosionPercentageElapsed = timePercetage;
+
 		}
 		
 		// for every vertex on the triangle...
@@ -168,7 +184,9 @@ void main()
 			Output.Normal = Input[i].Normal;
 			Output.Position = Input[i].Position;
 			Output.TextureCoordinate = Input[i].TextureCoordinate;
-			
+			Output.Tangent = Input[i].Tangent;
+			Output.BiTangent = Input[i].BiTangent;
+
 			// no change in position, pass through vertex
 			gl_Position = gl_in[i].gl_Position;
 			EmitVertex();

resources/Shaders/ForwardPlus.frag.glsl

@@ -7,13 +7,18 @@ uniform vec4 Color;
 uniform vec4 DiffuseColor;
 uniform vec2 ScreenDimensions;
 uniform vec4 FillColor;
+uniform vec4 AmbientColor;
 uniform float FillPercentage;
+
+uniform vec2 DiffuseUVRepeat;
+uniform vec2 NormalUVRepeat;
+uniform vec2 SpecularUVRepeat;
+uniform vec2 GlowUVRepeat;
 layout (binding = 0) uniform sampler2D DiffuseTexture;
 layout (binding = 1) uniform sampler2D NormalMapTexture;
 layout (binding = 2) uniform sampler2D SpecularMapTexture;
 layout (binding = 3) uniform sampler2D GlowMapTexture;
 
-
 #define TILE_SIZE 16
 
 struct LightSource {
@@ -55,13 +60,12 @@ in VertexData{
 	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
 }Input;
 
 out vec4 sceneColor;
 out vec4 bloomColor;
 
-vec4 scene_ambient = vec4(0.3,0.3,0.3,1);
-
 struct LightResult {
 	vec4 Diffuse;
 	vec4 Specular;
@@ -115,11 +119,12 @@ vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textu
 
 void main()
 {
-	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
-	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate);
-	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);
+	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat);
 	vec4 position = V * M * vec4(Input.Position, 1.0); 
-	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate, NormalMapTexture);
+	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
+	normal = normalize(normal);
 	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
 	vec4 viewVec = normalize(-position); 
 
@@ -128,7 +133,7 @@ void main()
 	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
 
 	LightResult totalLighting;
-	totalLighting.Diffuse = scene_ambient;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb, 1.0);
 	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
 
 	int start = int(LightGrids.Data[currentTile].Start);
@@ -150,8 +155,9 @@ void main()
 		totalLighting.Specular += light_result.Specular;
 	}
 
-	
-	vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
 	
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
@@ -160,7 +166,7 @@ void main()
 		color_result += FillColor;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
-	color_result += glowTexel;
+	color_result += glowTexel*3;
 
 	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
 

resources/Shaders/ForwardPlus.vert.glsl

@@ -3,15 +3,12 @@
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
-uniform mat4 Bones[100];
 
 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
 layout(location = 2) in vec3 Tangent;
 layout(location = 3) in vec3 BiTangent;
 layout(location = 4) in vec2 TextureCoords;
-layout(location = 5) in vec4 BoneIndices;
-layout(location = 6) in vec4 BoneWeights;
 
 out VertexData{
 	vec3 Position;
@@ -20,26 +17,18 @@ out VertexData{
 	vec3 BiTangent;
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
 }Output;
 
 void main()
 {
-
-
-	mat4 boneTransform = mat4(1);
-	if(BoneWeights[0] > 0.0f){
-	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
-				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
-				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
-				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
-	}
-
-	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
+	gl_Position = P*V*M * vec4(Position, 1.0);
 	
-	Output.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;
 	Output.Normal = vec3(M * vec4(Normal, 0.0));
 	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
  	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
-	Output.ExplosionColor = vec4(0.0);
+	Output.ExplosionColor = vec4(1.0);
+	Output.ExplosionPercentageElapsed = 0.0;
 }

resources/Shaders/ForwardPlusSkinned.vert.glsl

@@ -0,0 +1,46 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+out VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Output;
+
+void main()
+{
+	mat4 boneTransform = mat4(1);
+
+	if(BoneWeights[0] > 0.0f){ 
+	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
+				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
+				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
+				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
+	}
+
+	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
+	
+	Output.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	Output.TextureCoordinate = TextureCoords;
+	Output.Normal = vec3(M * vec4(Normal, 0.0));
+	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
+ 	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
+	Output.ExplosionColor = vec4(1.0);
+	Output.ExplosionPercentageElapsed = 0.0;
+}

resources/Shaders/ForwardPlusSplatMap.frag.glsl

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

resources/Shaders/Picking.vert.glsl

@@ -3,15 +3,12 @@
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
-uniform mat4 Bones[100];
 
 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
 layout(location = 2) in vec3 Tangent;
 layout(location = 3) in vec3 BiTangent;
 layout(location = 4) in vec2 TextureCoords;
-layout(location = 5) in vec4 BoneIndices;
-layout(location = 6) in vec4 BoneWeights;
 
 out VertexData{
 	vec3 Position;
@@ -19,14 +16,6 @@ out VertexData{
 
 void main()
 {
-	mat4 boneTransform = mat4(1);
-	if(BoneWeights[0] > 0.0f){
-	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
-				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
-				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
-				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
-	}
-
-	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
-	Output.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+	gl_Position = P*V*M * vec4(Position, 1.0);
+	Output.Position = Position, 1.0;
 }

resources/Shaders/PickingSkinned.vert.glsl

@@ -0,0 +1,32 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{
+	mat4 boneTransform = mat4(1);
+	if(BoneWeights[0] > 0.0f){
+	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
+				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
+				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
+				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
+	}
+
+	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
+	Output.Position = (boneTransform * vec4(Position, 1.0)).xyz;
+}

src/Engine/Collision/TriggerSystem.cpp

@@ -76,18 +76,18 @@ bool TriggerSystem::throwLeaveIfWasInTrigger(std::unordered_set<EntityWrapper>&
 
 bool TriggerSystem::OnTouch(const Events::TriggerTouch &event)
 {
-    LOG_INFO("Player entity %i touched trigger entity %i.", event.Entity, event.Trigger);
+    LOG_INFO("Player entity %i touched trigger entity %i.", event.Entity.ID, event.Trigger.ID);
     return true;
 }
 
 bool TriggerSystem::OnEnter(const Events::TriggerEnter &event)
 {
-    LOG_INFO("Player entity %i entered trigger entity %i.", event.Entity, event.Trigger);
+    LOG_INFO("Player entity %i entered trigger entity %i.", event.Entity.ID, event.Trigger.ID);
     return true;
 }
 
 bool TriggerSystem::OnLeave(const Events::TriggerLeave &event)
 {
-    LOG_INFO("Player entity %i left trigger entity %i.", event.Entity, event.Trigger);
+    LOG_INFO("Player entity %i left trigger entity %i.", event.Entity.ID, event.Trigger.ID);
     return true;
 }

src/Engine/Core/EntityFile.cpp

@@ -40,9 +40,9 @@ void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
     reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
 }
 
-std::size_t EntityFile::GetTypeStride(std::string typeName)
+unsigned int EntityFile::GetTypeStride(std::string typeName)
 {
-    std::map<std::string, size_t> typeStrides{
+    std::map<std::string, unsigned int> typeStrides{
         { "bool", sizeof(bool) },
         { "int", sizeof(int) },
         { "float", sizeof(float) },

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -114,7 +114,7 @@ void EntityFilePreprocessor::parseComponentInfo()
             std::string baseType = XS::ToString(elementDeclaration->getTypeDefinition()->getBaseType()->getName());
 
             std::string effectiveType = type;
-            size_t stride = EntityFile::GetTypeStride(type);
+            unsigned int stride = EntityFile::GetTypeStride(type);
             if (stride == 0) {
                 stride = EntityFile::GetTypeStride(baseType);
                 if (stride == 0) {

src/Engine/Core/InputManager.cpp

@@ -218,7 +218,7 @@ void InputManager::PublishGamepadAxisIfChanged(int gamepadID, Gamepad::Axis axis
 void InputManager::PublishGamepadButtonIfChanged(int gamepadID, Gamepad::Button button)
 {
 	bool currentState = m_CurrentGamepadButtonState[gamepadID][static_cast<int>(button)];
-	float lastState = m_LastGamepadButtonState[gamepadID][static_cast<int>(button)];
+	bool lastState = m_LastGamepadButtonState[gamepadID][static_cast<int>(button)];
 	if (currentState != lastState) {
 		if (currentState == true) {
 			Events::GamepadButtonDown e;

src/Engine/Core/World.cpp

@@ -96,6 +96,13 @@ EntityID World::GetParent(EntityID entity)
 
 void World::SetParent(EntityID entity, EntityID parent)
 {
+    // Don't allow an entity to be a child to itself!
+    if (entity == parent) {
+        // HACK: We purposely don't check the whole hierarchy of children here, since it would be way too slow.
+        // This might result in infinite loops if an entity somehow ends up as a child.
+        return;
+    }
+
     EntityID lastParent = m_EntityParents.at(entity);
     auto parentChildren = m_EntityChildren.equal_range(lastParent);
     for (auto it = parentChildren.first; it != parentChildren.second; it++) {

src/Engine/Editor/EditorGUI.cpp

@@ -6,6 +6,11 @@ EditorGUI::EditorGUI(World* world, EventBroker* eventBroker)
     , m_EventBroker(eventBroker)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &EditorGUI::OnKeyDown);
+    EVENT_SUBSCRIBE_MEMBER(m_EFileDropped, &EditorGUI::OnFileDropped);
+    EVENT_SUBSCRIBE_MEMBER(m_EPause, &EditorGUI::OnPause);
+    EVENT_SUBSCRIBE_MEMBER(m_EResume, &EditorGUI::OnResume);
+    EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &EditorGUI::OnLockMouse);
+    EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &EditorGUI::OnUnlockMouse);
 }
 
 void EditorGUI::Draw()
@@ -37,39 +42,60 @@ void EditorGUI::drawTools()
         return;
     }
 
+    // Widget modes
     createWidgetToolButton(WidgetMode::Translate);
     if (ImGui::IsItemHovered()) {
-        ImGui::SetTooltip("Translate");
+        ImGui::SetTooltip("Translate (W)");
     }
     ImGui::SameLine();
     createWidgetToolButton(WidgetMode::Rotate);
     if (ImGui::IsItemHovered()) {
-        ImGui::SetTooltip("Rotate");
+        ImGui::SetTooltip("Rotate (E)");
     }
     ImGui::SameLine();
     createWidgetToolButton(WidgetMode::Scale);
     if (ImGui::IsItemHovered()) {
-        ImGui::SetTooltip("Scale");
+        ImGui::SetTooltip("Scale (R)");
     }
+
+    ImGui::SameLine();
+    ImGui::ItemSize(ImVec2(5, 0));
+
+    // Widget space
+    ImGui::SameLine();
+    GLuint spaceTexture = 0;
+    if (m_CurrentWidgetSpace == WidgetSpace::Global) {
+        spaceTexture = tryLoadTexture("Textures/Icons/Global.png");
+    } else if (m_CurrentWidgetSpace == WidgetSpace::Local) {
+        spaceTexture = tryLoadTexture("Textures/Icons/Local.png");
+    }
+    if (ImGui::ImageButton(reinterpret_cast<void*>(spaceTexture), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1))) {
+        toggleWidgetSpace();
+    }
+    if (ImGui::IsItemHovered()) {
+        if (m_CurrentWidgetSpace == WidgetSpace::Global) {
+            ImGui::SetTooltip("Widget space: Global (X)");
+        } else if (m_CurrentWidgetSpace == WidgetSpace::Local) {
+            ImGui::SetTooltip("Widget space: Local (X)");
+        }
+    }
+
     ImGui::SameLine();
     ImGui::ItemSize(ImVec2(5, 0));
 
     // Play button
     ImGui::SameLine();
-    static bool paused = false;
-    if (ImGui::ImageButton((void*)tryLoadTexture("Textures/Icons/Play.png"), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (!paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
+    if (ImGui::ImageButton(reinterpret_cast<void*>(tryLoadTexture("Textures/Icons/Play.png")), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (!m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
         Events::Resume e;
         e.World = m_World;
         m_EventBroker->Publish(e);
-        paused = false;
     }
     // Pause button
     ImGui::SameLine();
-    if (ImGui::ImageButton((void*)tryLoadTexture("Textures/Icons/Pause.png"), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
+    if (ImGui::ImageButton(reinterpret_cast<void*>(tryLoadTexture("Textures/Icons/Pause.png")), ImVec2(24, 24), ImVec2(0, 1), ImVec2(1, 0), -1, ImVec4(0, 0, 0, 0), (m_Paused) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1))) {
         Events::Pause e;
         e.World = m_World;
         m_EventBroker->Publish(e);
-        paused = true;
     }
 
     ImGui::End();
@@ -168,10 +194,7 @@ bool EditorGUI::drawEntityNode(EntityWrapper entity)
             ImGui::Text(formatEntityName(entity).c_str());
             ImGui::End();
         }
-    }/* else if (m_CurrentlyDragging == entity) {
-        LOG_DEBUG("Stopped dragging %i", entity.ID);
-        m_CurrentlyDragging = EntityWrapper::Invalid;
-    }*/
+    }
     // Entity context menu
     std::string contextMenuUniqueID = std::string("EntityContextMenu") + std::to_string(entity.ID);
     if (hovered && ImGui::IsMouseClicked(1)) {
@@ -239,7 +262,7 @@ void EditorGUI::drawComponents(EntityWrapper entity)
     // Draw combo box
     ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth() - 10.f);
     int selectedItem = -1;
-    if (ImGui::Combo("", &selectedItem, componentTypes.data(), componentTypes.size(), componentTypes.size())) {
+    if (ImGui::Combo("", &selectedItem, componentTypes.data(), static_cast<int>(componentTypes.size()), static_cast<int>(componentTypes.size()))) {
         if (selectedItem != -1) {
             if (m_OnComponentAttach != nullptr) {
                 std::string chosenComponentType(componentTypes.at(selectedItem));
@@ -436,18 +459,31 @@ bool EditorGUI::drawComponentField_bool(ComponentWrapper &c, const ComponentInfo
 
 bool EditorGUI::drawComponentField_string(ComponentWrapper &c, const ComponentInfo::Field_t &field)
 {
+    bool result = false;
+
     auto& val = c.Field<std::string>(field.Name);
+
     char tempString[1024]; // Let's just hope this is an sufficiently large buffer for strings :)
     tempString[1023] = '\0'; // Null terminator just in case the string is larger than the buffer
     // Copy the string into the buffer, taking the null terminator into account
     memcpy(tempString, val.c_str(), std::min(val.length() + 1, sizeof(tempString) - 1));
     if (ImGui::InputText("", tempString, sizeof(tempString))) {
         val = std::string(tempString);
-        return true;
-    } else {
-        return false;
+        result = true;
     }
-    // TODO: Handle drag and drop of files
+
+    // Handle file drag and drop
+    if (ImGui::IsItemHovered() && !m_DroppedFile.empty()) {
+        // Unset potential input focus or our newly set value will be overwritten!
+        if (ImGui::IsItemActive()) {
+            ImGui::SetActiveID(0, nullptr);
+        }
+        // Set the actual dropped value
+        val = m_DroppedFile;
+        m_DroppedFile = "";
+    }
+    
+    return result;
 }
 
 void EditorGUI::drawModals()
@@ -529,7 +565,7 @@ void EditorGUI::createWidgetToolButton(WidgetMode mode)
         break;
     }
     if (ImGui::ImageButton(
-            (void*)texture, 
+            reinterpret_cast<void*>(texture),
             ImVec2(24, 24), 
             ImVec2(0, 1), 
             ImVec2(1, 0), 
@@ -538,10 +574,7 @@ void EditorGUI::createWidgetToolButton(WidgetMode mode)
             (m_CurrentWidgetMode == mode) ? ImVec4(0, 1, 0, 1) : ImVec4(1, 1, 1, 1)
         )
     ) {
-        if (m_OnWidgetMode != nullptr) {
-            m_OnWidgetMode(mode);
-        }
-        m_CurrentWidgetMode = mode;
+        setWidgetMode(mode);
     }
 }
 
@@ -571,6 +604,61 @@ bool EditorGUI::OnKeyDown(const Events::KeyDown& e)
         }
     }
 
+    if (!m_MouseLocked) {
+        if (e.KeyCode == GLFW_KEY_W) {
+            setWidgetMode(WidgetMode::Translate);
+        }
+        if (e.KeyCode == GLFW_KEY_E) {
+            setWidgetMode(WidgetMode::Rotate);
+        }
+        if (e.KeyCode == GLFW_KEY_R) {
+            setWidgetMode(WidgetMode::Scale);
+        }
+
+        if (e.KeyCode == GLFW_KEY_X) {
+            toggleWidgetSpace();
+        }
+    }
+
+    return true;
+}
+
+bool EditorGUI::OnFileDropped(const Events::FileDropped& e)
+{
+    // Make a best effort to make the path relative to the working directory of the executable
+    m_DroppedFile = boost::filesystem::path(e.Path).lexically_relative(boost::filesystem::current_path()).string();
+    // Compensate for Windows retardedness
+    std::replace(m_DroppedFile.begin(), m_DroppedFile.end(), '\\', '/');
+    // Special case for when people drop from the asset folder instead of from the symlink to the asset folders in bin
+    boost::algorithm::replace_first(m_DroppedFile, "../assets/", "");
+    return true;
+}
+
+bool EditorGUI::OnPause(const Events::Pause& e)
+{
+    if (e.World == m_World) {
+        m_Paused = true;
+    }
+    return true;
+}
+
+bool EditorGUI::OnResume(const Events::Resume& e)
+{
+    if (e.World == m_World) {
+        m_Paused = false;
+    }
+    return true;
+}
+
+bool EditorGUI::OnLockMouse(const Events::LockMouse& e)
+{
+    m_MouseLocked = true;
+    return true;
+}
+
+bool EditorGUI::OnUnlockMouse(const Events::UnlockMouse& e)
+{
+    m_MouseLocked = false;
     return true;
 }
 
@@ -645,6 +733,27 @@ void EditorGUI::openModal(const std::string& modal)
     m_ModalsToOpen.insert(modal);
 }
 
+void EditorGUI::setWidgetMode(WidgetMode mode)
+{
+    if (m_OnWidgetMode != nullptr) {
+        m_OnWidgetMode(mode);
+    }
+    m_CurrentWidgetMode = mode;
+}
+
+void EditorGUI::toggleWidgetSpace()
+{
+    if (m_CurrentWidgetSpace == WidgetSpace::Global) {
+        m_CurrentWidgetSpace = WidgetSpace::Local;
+    } else if (m_CurrentWidgetSpace == WidgetSpace::Local) {
+        m_CurrentWidgetSpace = WidgetSpace::Global;
+    }
+
+    if (m_OnWidgetSpace != nullptr) {
+        m_OnWidgetSpace(m_CurrentWidgetSpace);
+    }
+}
+
 bool EditorGUI::compareCharArray(const char* c1, const char* c2)
 {
     return strcmp(c1, c2) < 0;
@@ -737,7 +846,7 @@ void EditorGUI::entityDelete(EntityWrapper entity)
 
 void EditorGUI::entityChangeParent(EntityWrapper entity, EntityWrapper parent)
 {
-    if (entity == parent) {
+    if (entity == parent || parent.IsChildOf(entity)) {
         return;
     }
 

src/Engine/Editor/EditorRenderSystem.cpp

@@ -23,6 +23,12 @@ void EditorRenderSystem::Update(double dt)
     scene.Camera = m_EditorCamera;
     scene.Viewport = Rectangle(1920, 1080);
 
+    auto cSceneLight = m_World->GetComponents("SceneLight");
+    if (cSceneLight != nullptr) {
+        //these are hardcoded since they want special light treatment and a component just for widgets is stupid.
+        scene.AmbientColor = glm::vec4(0.8, 0.8, 0.8, 1.0);
+    }
+
     auto models = m_World->GetComponents("Model");
     if (models != nullptr) {
         for (auto& cModel : *models) {
@@ -49,7 +55,7 @@ void EditorRenderSystem::Update(double dt)
             glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
                 std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f);
-                if(cModel["Transparent"]) {
+                if (cModel["Transparent"]) {
                     scene.TransparentObjects.push_back(modelJob);
                 } else {
                     scene.OpaqueObjects.push_back(modelJob);
@@ -80,9 +86,9 @@ bool EditorRenderSystem::OnSetCamera(Events::SetCamera& e)
 {
     ComponentWrapper cTransform = e.CameraEntity["Transform"];
     ComponentWrapper cCamera = e.CameraEntity["Camera"];
-    m_EditorCamera->SetFOV((double)cCamera["FOV"]);
-    m_EditorCamera->SetNearClip((double)cCamera["NearClip"]);
-    m_EditorCamera->SetFarClip((double)cCamera["FarClip"]);
+    m_EditorCamera->SetFOV(static_cast<float>((double)cCamera["FOV"]));
+    m_EditorCamera->SetNearClip(static_cast<float>((double)cCamera["NearClip"]));
+    m_EditorCamera->SetFarClip(static_cast<float>((double)cCamera["FarClip"]));
     m_EditorCamera->SetPosition(cTransform["Position"]);
     m_EditorCamera->SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
     m_CurrentCamera = e.CameraEntity;

src/Engine/Editor/EditorSystem.cpp

@@ -31,6 +31,7 @@ EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* re
     m_EditorGUI->SetComponentAttachCallback(std::bind(&EditorSystem::OnComponentAttach, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentDeleteCallback(std::bind(&EditorSystem::OnComponentDelete, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetWidgetModeCallback(std::bind(&EditorSystem::setWidgetMode, this, std::placeholders::_1));
+    m_EditorGUI->SetWidgetSpaceCallback(std::bind(&EditorSystem::OnWidgetSpace, this, std::placeholders::_1));
 
     EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorSystem::OnMousePress);
     EVENT_SUBSCRIBE_MEMBER(m_EWidgetDelta, &EditorSystem::OnWidgetDelta);
@@ -65,7 +66,12 @@ void EditorSystem::Update(double dt)
         m_EditorStats->Draw(actualDelta);
 
         if (m_CurrentSelection.Valid() && m_Widget.Valid()) {
-            (glm::vec3&)m_Widget["Transform"]["Position"] = Transform::AbsolutePosition(m_CurrentSelection.World, m_CurrentSelection.ID);
+            (glm::vec3&)m_Widget["Transform"]["Position"] = Transform::AbsolutePosition(m_CurrentSelection);
+            if (m_WidgetSpace == EditorGUI::WidgetSpace::Local) {
+                (glm::vec3&)m_Widget["Transform"]["Orientation"] = Transform::AbsoluteOrientationEuler(m_CurrentSelection);
+            } else {
+                (glm::vec3&)m_Widget["Transform"]["Orientation"] = glm::vec3(0, 0, 0);
+            }
         }
 
         m_EditorWorldSystemPipeline->Update(actualDelta);
@@ -82,11 +88,22 @@ void EditorSystem::Update(double dt)
 void EditorSystem::Enable()
 {
     m_EditorCameraInputController->Enable();
+
     m_EventBroker->Publish(Events::UnlockMouse());
-    Events::SetCamera e;
-    e.CameraEntity = m_EditorCamera;
-    m_EventBroker->Publish(e);
-    (glm::vec3&)m_EditorCamera["Transform"]["Position"] = Transform::AbsolutePosition(m_ActualCamera);
+
+    // Enable editor camera
+    Events::SetCamera eSetCamera;
+    eSetCamera.CameraEntity = m_EditorCamera;
+    m_EventBroker->Publish(eSetCamera);
+    if (m_ActualCamera.Valid()) {
+        (glm::vec3&)m_EditorCamera["Transform"]["Position"] = Transform::AbsolutePosition(m_ActualCamera);
+    }
+
+    // Pause the world we're editing
+    Events::Pause ePause;
+    ePause.World = m_World;
+    m_EventBroker->Publish(ePause);
+
     m_Enabled = true;
 }
 
@@ -154,6 +171,11 @@ void EditorSystem::OnComponentDelete(EntityWrapper entity, const std::string& co
     }
 }
 
+void EditorSystem::OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace)
+{
+    m_WidgetSpace = widgetSpace;
+}
+
 bool EditorSystem::OnMousePress(const Events::MousePress& e)
 {
     ImGuiIO& io = ImGui::GetIO();
@@ -170,12 +192,18 @@ bool EditorSystem::OnMousePress(const Events::MousePress& e)
 bool EditorSystem::OnWidgetDelta(const Events::WidgetDelta& e)
 {
     if (m_CurrentSelection.Valid()) {
-        glm::quat parentOrientation;
-        EntityWrapper parent = m_CurrentSelection.Parent();
-        if (parent.Valid()) {
-            parentOrientation = glm::inverse(Transform::AbsoluteOrientation(parent.World, parent.ID));
+        if (m_WidgetSpace == EditorGUI::WidgetSpace::Global) {
+            glm::quat parentOrientation;
+            EntityWrapper parent = m_CurrentSelection.Parent();
+            if (parent.Valid()) {
+                parentOrientation = glm::inverse(Transform::AbsoluteOrientation(parent));
+            }
+            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation;
+        } else if (m_WidgetSpace == EditorGUI::WidgetSpace::Local) {
+            glm::quat selectionOri = glm::quat((glm::vec3)m_CurrentSelection["Transform"]["Orientation"]);
+            glm::vec3 localTranslation = selectionOri * e.Translation;
+            (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += localTranslation;
         }
-        (glm::vec3&)m_CurrentSelection["Transform"]["Position"] += parentOrientation * e.Translation;
         m_EditorGUI->SetDirty(m_CurrentSelection);
     }
     return true;

src/Engine/Editor/EditorWidgetSystem.cpp

@@ -23,14 +23,18 @@ void EditorWidgetSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
     
     Events::WidgetDelta e;
 
-    EntityWrapper moveEntity = entity.Parent();
-    if (!moveEntity.Valid()) {
-        moveEntity = entity;
+    // Widget axes should have a common parent
+    EntityWrapper widgetBase = entity.Parent();
+    if (!widgetBase.Valid()) {
+        widgetBase = entity;
     }
+    glm::vec3 widgetBasePos = widgetBase["Transform"]["Position"];
+    glm::quat widgetBaseOri = glm::quat((glm::vec3)widgetBase["Transform"]["Orientation"]);
 
     auto camera = m_PickData.Camera;
-    glm::vec3 axis = cEditorWidget["Axis"];
-    glm::vec2 axisScreen = camera->WorldToScreen(axis, m_Renderer->GetViewPortSize()) - camera->WorldToScreen(glm::vec3(0, 0, 0), m_Renderer->GetViewPortSize());
+    glm::vec3 axis = (glm::vec3)cEditorWidget["Axis"];
+    glm::vec3 axisOriented = widgetBaseOri * axis;
+    glm::vec2 axisScreen = camera->WorldToScreen(widgetBasePos + axisOriented, m_Renderer->GetViewportSize()) - camera->WorldToScreen(widgetBasePos, m_Renderer->GetViewportSize());
     float dot = glm::dot(m_MouseDelta, glm::normalize(axisScreen)) / glm::length(axisScreen);
     glm::vec3 worldMovement = dot * axis;
 

src/Engine/Input/MouseInputHandler.cpp

@@ -98,7 +98,7 @@ bool MouseInputHandler::OnMouseMove(const Events::MouseMove& e)
             Events::InputCommand ic;
             ic.PlayerID = -1;
             std::tie(ic.Command, ic.Value) = it->second;
-            ic.Value *= e.DeltaX;
+            ic.Value *= static_cast<float>(e.DeltaX);
             m_InputProxy->Publish(ic);
         }
     }
@@ -109,7 +109,7 @@ bool MouseInputHandler::OnMouseMove(const Events::MouseMove& e)
             Events::InputCommand ic;
             ic.PlayerID = -1;
             std::tie(ic.Command, ic.Value) = it->second;
-            ic.Value *= e.DeltaY;
+            ic.Value *= static_cast<float>(e.DeltaY);
             m_InputProxy->Publish(ic);
         }
     }

src/Engine/Network/Client.cpp

@@ -258,11 +258,11 @@ void Client::parseSnapshot(Packet& packet)
     }
 }
 
-int Client::receive(char* data)
+size_t Client::receive(char* data)
 {
     boost::system::error_code error;
 
-    int bytesReceived = m_Socket.receive_from(boost
+    size_t bytesReceived = m_Socket.receive_from(boost
         ::asio::buffer((void*)data, INPUTSIZE),
         m_ReceiverEndpoint,
         0, error);
@@ -390,7 +390,7 @@ void Client::identifyPacketLoss()
 bool Client::hasServerTimedOut()
 {
     // Time in ms
-    float timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
+    double timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
     if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");

src/Engine/Network/Network.cpp

@@ -26,10 +26,10 @@ void Network::saveToFile()
     outfile << "Total messages received," + std::to_string(m_NetworkData.AmountOfMessagesReceived) + "\n";
     outfile << "Total messages sent," + std::to_string(m_NetworkData.AmountOfMessagesSent) + "\n";
 
-    float messagesReceivedPerSec = (float)m_NetworkData.AmountOfMessagesReceived / (m_NetworkData.TotalTime / 1000);
-    float messagesSentPerSec = (float)m_NetworkData.AmountOfMessagesSent / (m_NetworkData.TotalTime / 1000);
-    float dataReceivedPerSec = (float)m_NetworkData.TotalDataReceived / (m_NetworkData.TotalTime / 1000);
-    float dataSentPerSec = (float)m_NetworkData.TotalDataSent / (m_NetworkData.TotalTime / 1000);
+    double messagesReceivedPerSec = m_NetworkData.AmountOfMessagesReceived / (m_NetworkData.TotalTime / 1000);
+    double messagesSentPerSec = m_NetworkData.AmountOfMessagesSent / (m_NetworkData.TotalTime / 1000);
+    double dataReceivedPerSec = m_NetworkData.TotalDataReceived / (m_NetworkData.TotalTime / 1000);
+    double dataSentPerSec = m_NetworkData.TotalDataSent / (m_NetworkData.TotalTime / 1000);
     outfile << "Avarage messages received / s: " + std::to_string(messagesReceivedPerSec) + "\n";
     outfile << "Avarage messages sents / s: " + std::to_string(messagesSentPerSec) + "\n";
     outfile << "Avarage data received B/s: " + std::to_string(dataReceivedPerSec) + "\n";
@@ -52,7 +52,7 @@ void Network::updateNetworkData()
     if (m_SaveDataIntervalMs < (1000 * (currentTime - m_SaveDataTimer) / (double)CLOCKS_PER_SEC)) {
         // Set values
         m_NetworkData.TotalTime += (1000 * (currentTime - m_SaveDataTimer) / (double)CLOCKS_PER_SEC);
-        m_NetworkData.BandwidthBytes.push_back(std::pair<unsigned int, unsigned int>(m_NetworkData.DataReceivedThisInterval, m_NetworkData.DataSentThisInterval));
+        m_NetworkData.BandwidthBytes.push_back(std::pair<size_t, size_t>(m_NetworkData.DataReceivedThisInterval, m_NetworkData.DataSentThisInterval));
         // Reset interval stuff
         m_SaveDataTimer = std::clock();
         m_NetworkData.DataSentThisInterval = 0;

src/Engine/Network/Packet.cpp

@@ -7,7 +7,7 @@ Packet::Packet(MessageType type, unsigned int& packetID)
 }
 
 // Create message
-Packet::Packet(char* data, const int sizeOfPacket)
+Packet::Packet(char* data, const size_t sizeOfPacket)
 {
     // Resize message
     m_MaxPacketSize = sizeOfPacket;
@@ -45,7 +45,7 @@ void Packet::Init(MessageType type, unsigned int & packetID)
 void Packet::WriteString(const std::string& str)
 {
     // Message, add one extra byte for null terminator
-    int sizeOfString = str.size() + 1;
+    size_t sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
         //LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size. New size is %i bytes\n", m_MaxPacketSize*2);
         resizeData();
@@ -82,7 +82,7 @@ char * Packet::ReadData(int SizeOfData)
         //LOG_WARNING("packet ReadData(): Oh no! You are trying to remove things outside my memory kingdom");
         return nullptr;
     }
-    unsigned int oldReturnDataOffset = m_ReturnDataOffset;
+    size_t oldReturnDataOffset = m_ReturnDataOffset;
     m_ReturnDataOffset += SizeOfData;
     return (m_Data + oldReturnDataOffset);
 }

src/Engine/Network/Server.cpp

@@ -4,7 +4,7 @@ Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::a
 {
     Network::initialize();
     ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
-    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05);
+    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05f);
     pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
 
 }
@@ -43,7 +43,7 @@ void Server::readFromClients()
             bytesRead = receive(readBuffer);
             Packet packet(readBuffer, bytesRead);
             parseMessageType(packet);
-        } catch (const std::exception& err) {
+        } catch (const std::exception&) {
             //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
         }
     }
@@ -103,9 +103,9 @@ void Server::parseMessageType(Packet& packet)
     }
 }
 
-int Server::receive(char * data)
+size_t Server::receive(char * data)
 {
-    unsigned int length = m_Socket.receive_from(
+    size_t length = m_Socket.receive_from(
         boost::asio::buffer((void*)data
             , INPUTSIZE)
         , m_ReceiverEndpoint, 0);
@@ -121,7 +121,7 @@ int Server::receive(char * data)
 void Server::send(PlayerID player, Packet& packet)
 {
     try {
-        int bytesSent = m_Socket.send_to(
+        size_t bytesSent = m_Socket.send_to(
             boost::asio::buffer(packet.Data(), packet.Size()),
             m_ConnectedPlayers[player].Endpoint,
             0);
@@ -131,7 +131,7 @@ void Server::send(PlayerID player, Packet& packet)
             m_NetworkData.DataSentThisInterval += packet.Size();
             m_NetworkData.AmountOfMessagesSent++;
         }
-    } catch (const boost::system::system_error& e) {
+    } catch (const boost::system::system_error&) {
         // TODO: Clean up invalid endpoints out of m_ConnectedPlayers later
         m_ConnectedPlayers[player].Endpoint = boost::asio::ip::udp::endpoint();
     }
@@ -231,12 +231,12 @@ void Server::sendPing()
 
 void Server::checkForTimeOuts()
 {
-    int startPing = 1000 * m_StartPingTime
+    double startPing = 1000 * m_StartPingTime
         / static_cast<double>(CLOCKS_PER_SEC);
 
     for (int i = 0; i < m_ConnectedPlayers.size(); i++) {
         if (m_ConnectedPlayers[i].Endpoint.address() != boost::asio::ip::address()) {
-            int stopPing = 1000 * m_ConnectedPlayers[i].StopTime /
+            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);

src/Engine/Rendering/DrawBloomPass.cpp

@@ -34,12 +34,12 @@ void DrawBloomPass::InitializeShaderPrograms()
 
 void DrawBloomPass::InitializeBuffers()
 {
-    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
     m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
     m_GaussianFrameBuffer_horiz.Generate();
 
-    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
     m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
     m_GaussianFrameBuffer_vert.Generate();
@@ -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

@@ -5,7 +5,8 @@ DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
     m_Renderer = renderer;
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
-    m_Exposure = 0.4; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+
+    //m_Exposure = 0.4; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
 
     InitializeShaderPrograms();
 }
@@ -19,7 +20,7 @@ void DrawColorCorrectionPass::InitializeShaderPrograms()
     m_ColorCorrectionProgram->Link();
 }
 
-void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
+void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure)
 {
     //glBindFramebuffer(GL_FRAMEBUFFER, 0);
     GLERROR("DrawScreenQuadPass::Draw: Pre");
@@ -27,7 +28,8 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
     DrawScreenQuadPassState state = DrawScreenQuadPassState();
     m_ColorCorrectionProgram->Bind();
     glClear(GL_COLOR_BUFFER_BIT);
-    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure);
+    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), exposure);
+    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Gamma"), gamma);
 
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, sceneTexture);
@@ -36,6 +38,6 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
 
     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

@@ -21,11 +21,11 @@ void DrawFinalPass::InitializeFrameBuffers()
 {
     glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 
-    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
 
     m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
@@ -44,6 +44,7 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ForwardPlusProgram->BindFragDataLocation(0, "sceneColor");
     m_ForwardPlusProgram->BindFragDataLocation(1, "bloomColor");
     m_ForwardPlusProgram->Link();
+    GLERROR("Creating forward+ program");
 
     m_ExplosionEffectProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectProgram");
     m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
@@ -53,11 +54,68 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ExplosionEffectProgram->BindFragDataLocation(0, "sceneColor");
     m_ExplosionEffectProgram->BindFragDataLocation(1, "bloomColor");
     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");
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
 {
-    GLERROR("DrawFinalPass::Draw: Pre");
+    GLERROR("Pre");
 
     DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
     if (scene.ClearDepth) {
@@ -65,12 +123,12 @@ void DrawFinalPass::Draw(RenderScene& scene)
     }
 
     DrawModelRenderQueues(scene.OpaqueObjects, scene);
-    GLERROR("DrawFinalPass::Draw: OpaqueObjects");
+    GLERROR("OpaqueObjects");
     DrawModelRenderQueues(scene.TransparentObjects, scene);
-    GLERROR("DrawFinalPass::Draw: TransparentObjects");
+    GLERROR("TransparentObjects");
 
-    GLERROR("DrawFinalPass::Draw: END");
     delete state;
+    GLERROR("END");
 }
 
 
@@ -111,7 +169,21 @@ void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm:
 void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& job, RenderScene& scene)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
-    GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
+    GLERROR("forwardHandle");
+	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());
@@ -121,53 +193,132 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if(explosionEffectJob) {
-            //Bind program
-            m_ExplosionEffectProgram->Bind();
+			switch (explosionEffectJob->Type) {
+				case RawModel::MaterialType::Basic:
+				case RawModel::MaterialType::SingleTextures:
+				{
+					if (explosionEffectJob->Model->isSkined()) {
+						m_ExplosionEffectSkinnedProgram->Bind();
+						GLERROR("Bind ExplosionEffectSkinned program");
+						//bind uniforms
+						BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
+						//bind textures
+						BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+						if (explosionEffectJob->Animation != nullptr) {
+							std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
+							glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "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->isSkined()) {
+						m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+						GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+						//bind uniforms
+						BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
+						//bind textures
+						BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
+						GLERROR("asdasd");
+						if (explosionEffectJob->Animation != nullptr) {
+							std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
+							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 (explosionEffectJob->Skeleton != nullptr) {
-                std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
-                glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-
-            }
-
-
-            //bind textures
-            BindExplosionTextures(explosionEffectJob);
             //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);
+			GLERROR("explosion effect end");
         } else {
             auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
             if (modelJob) {
                 //bind forward program
-                m_ForwardPlusProgram->Bind();
-
-                //bind uniforms
-                BindModelUniforms(forwardHandle, modelJob, scene);
-
-                //bind textures
-                BindModelTextures(modelJob);
-
-                if (modelJob->Skeleton != nullptr) {
-                    std::vector<glm::mat4> frameBones;
-                    if(modelJob->AnimationOffset.animation != nullptr) {
-                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                    } else {
-                        frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                    }
-                    glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                }
+				//TODO: JOHAN/TOBIAS: Bind shader based on ModelJob->ShaderID;
+				switch (modelJob->Type) {
+					case RawModel::MaterialType::Basic:
+					case RawModel::MaterialType::SingleTextures:
+					{
+						if (modelJob->Model->isSkined()) {
+							m_ForwardPlusSkinnedProgram->Bind();
+							GLERROR("Bind ForwardPlusSkinnedProgram");
+							//bind uniforms
+							BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
+							//bind textures
+							BindModelTextures(forwardSkinnedHandle, modelJob);
+							if (modelJob->Animation != nullptr) {
+								std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+								glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "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->isSkined()) {
+							m_ForwardPlusSplatMapSkinnedProgram->Bind();
+							GLERROR("Bind SplatMap program");
+							//bind uniforms
+							BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
+							//bind textures
+							BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
+							GLERROR("asdasd");
+							if (modelJob->Animation != nullptr) {
+								std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+								glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+							}
+						} 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)));
-                GLERROR("DrawFinalPass::Model: END");
+                if(GLERROR("models end")) {
+                    continue;
+                }
             }
         }
     }
@@ -176,83 +327,314 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
-    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()));
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
-
+	GLERROR("Bind 1 uniform");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
-    glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
+	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);
-    glUniform1f(glGetUniformLocation(shaderHandle, "RandomnessScalar"), job->RandomnessScalar);
-    glUniform2fv(glGetUniformLocation(shaderHandle, "Velocity"), 1, glm::value_ptr(job->Velocity));
-    glUniform1i(glGetUniformLocation(shaderHandle, "ColorByDistance"), job->ColorByDistance);
-    glUniform1i(glGetUniformLocation(shaderHandle, "ExponentialAccelaration"), job->ExponentialAccelaration);
-    glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(job->DiffuseColor));
+	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, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	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");
 
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
-    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);
+	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
+	glUniform2f(Location_ScreenDimensions, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	GLERROR("Bind 5 uniform");
+
+	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");
 }
 
-
-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);
-    }
-    glActiveTexture(GL_TEXTURE1);
-    if (job->IncandescenceTexture != nullptr) {
-        glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture->m_Texture);
-    } else {
-        glBindTexture(GL_TEXTURE_2D, m_BlackTexture->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.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.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.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/FrameBuffer.cpp

@@ -54,13 +54,6 @@ void FrameBuffer::Generate()
         case GL_RENDERBUFFER:
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
-            if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 ||
-                (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 ||
-                (*it)->m_Attachment != GL_DEPTH_ATTACHMENT ||
-                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta
-            {
-                LOG_ERROR("RenderBuffer Attachment not valid.");
-            }
             break;
         }
         

src/Engine/Rendering/ImGuiRenderPass.cpp

@@ -134,8 +134,8 @@ bool ImGuiRenderPass::OnMouseRelease(const Events::MouseRelease& e)
 bool ImGuiRenderPass::OnMouseMove(const Events::MouseMove& e)
 {
     ImGuiIO& io = ImGui::GetIO();
-    io.MousePos.x = e.X;
-    io.MousePos.y = e.Y;
+    io.MousePos.x = static_cast<float>(e.X);
+    io.MousePos.y = static_cast<float>(e.Y);
     return true;
 }
 
@@ -271,7 +271,7 @@ bool ImGuiRenderPass::createFontsTexture()
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
     // Store our identifier
-    io.Fonts->TexID = (void*)g_FontTexture;
+    io.Fonts->TexID = reinterpret_cast<void*>(g_FontTexture);
 
     // Restore state
     glBindTexture(GL_TEXTURE_2D, last_texture);
@@ -291,7 +291,7 @@ void ImGuiRenderPass::newFrame()
     io.DisplaySize = ImVec2((float)w, (float)h);
     io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
 
-    io.DeltaTime = g_DeltaTime;
+    io.DeltaTime = static_cast<float>(g_DeltaTime);
 
     io.KeyCtrl = glfwGetKey(g_Window, GLFW_KEY_LEFT_CONTROL) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_CONTROL);
     io.KeyShift = glfwGetKey(g_Window, GLFW_KEY_LEFT_SHIFT) || glfwGetKey(g_Window, GLFW_KEY_RIGHT_SHIFT);

src/Engine/Rendering/LightCullingPass.cpp

@@ -25,8 +25,8 @@ void LightCullingPass::GenerateNewFrustum(RenderScene& scene)
 
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glUniformMatrix4fv(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "P"), 1, false, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
-    glDispatchCompute((int)(m_Renderer->GetViewPortSize().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->GetViewPortSize().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
+    glUniform2f(glGetUniformLocation(m_CalculateFrustumProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glDispatchCompute((int)(m_Renderer->GetViewportSize().Width/(TILE_SIZE*TILE_SIZE) + 1), (int)(m_Renderer->GetViewportSize().Height/(TILE_SIZE*TILE_SIZE) + 1), 1);
 
     GLERROR("CalculateFrustum Error: End");
 }
@@ -40,7 +40,7 @@ void LightCullingPass::OnResolutionChange()
 
 void LightCullingPass::SetSSBOSizes()
 {
-    m_NumberOfTiles = (int)(m_Renderer->GetViewPortSize().Width/TILE_SIZE) * (int)(m_Renderer->GetViewPortSize().Height/TILE_SIZE);
+    m_NumberOfTiles = (int)(m_Renderer->GetViewportSize().Width/TILE_SIZE) * (int)(m_Renderer->GetViewportSize().Height/TILE_SIZE);
 
     m_Frustums = new Frustum[m_NumberOfTiles];
     m_LightGrid = new LightGrid[m_NumberOfTiles];
@@ -67,14 +67,14 @@ void LightCullingPass::CullLights(RenderScene& scene)
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
     m_LightCullProgram->Bind();
-    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
+    glUniform2f(glGetUniformLocation(m_LightCullProgram->GetHandle(), "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glUniformMatrix4fv(glGetUniformLocation(m_LightCullProgram->GetHandle(), "V"), 1, false, glm::value_ptr(scene.Camera->ViewMatrix()));
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_FrustumSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightGridSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_LightOffsetSSBO);
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightIndexSSBO);
-    glDispatchCompute(glm::ceil(m_Renderer->GetViewPortSize().Width/ TILE_SIZE), glm::ceil(m_Renderer->GetViewPortSize().Height / TILE_SIZE), 1);
+    glDispatchCompute(glm::ceil(m_Renderer->GetViewportSize().Width/ TILE_SIZE), glm::ceil(m_Renderer->GetViewportSize().Height / TILE_SIZE), 1);
 
     GLERROR("CullLights Error: End");
 }

src/Engine/Rendering/Model.cpp

@@ -5,19 +5,69 @@ 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
@@ -25,11 +75,7 @@ Model::Model(std::string fileName)
     glGenBuffers(1, &buffer);
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
 
-	if (m_RawModel->isSkined) {
-		glBufferData(GL_ARRAY_BUFFER, m_RawModel->NumVertices() * sizeof(RawModel::SkinedVertex), m_RawModel->Vertices(), GL_STATIC_DRAW);
-	} else {
-		glBufferData(GL_ARRAY_BUFFER, m_RawModel->NumVertices() * sizeof(RawModel::Vertex), m_RawModel->Vertices(), 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);
@@ -41,7 +87,7 @@ Model::Model(std::string fileName)
 
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
 	std::vector<int> structSizes;
-	if (m_RawModel->isSkined) {
+	if (m_RawModel->isSkined()) {
 		structSizes = { 3, 3, 3, 3, 2, 4, 4 };
 	} else {
 		structSizes = { 3, 3, 3, 3, 2 };
@@ -60,7 +106,7 @@ 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++;
-		if (m_RawModel->isSkined) {
+		if (m_RawModel->isSkined()) {
 			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++;
 		}
@@ -72,7 +118,7 @@ Model::Model(std::string fileName)
     glEnableVertexAttribArray(2);
     glEnableVertexAttribArray(3);
     glEnableVertexAttribArray(4);
-	if (m_RawModel->isSkined) {
+	if (m_RawModel->isSkined()) {
 		glEnableVertexAttribArray(5);
 		glEnableVertexAttribArray(6);
 	}

src/Engine/Rendering/PNG.cpp

@@ -71,12 +71,12 @@ PNG::PNG(std::string path)
 		png_read_update_info(png_ptr, info_ptr);
 	}
 	
-	unsigned int row_bytes = png_get_rowbytes(png_ptr, info_ptr);
+	std::size_t row_bytes = png_get_rowbytes(png_ptr, info_ptr);
 	this->Data = new unsigned char[height * row_bytes];
 	png_bytep* row_pointers = new png_bytep[height];
 
 	// Point each row to the continuous data array
-	for (int i = 0; i < height; ++i) {
+	for (unsigned int i = 0; i < height; ++i) {
 		// Invert Y for OpenGL
 		row_pointers[height - 1 - i] = this->Data + i * row_bytes;
 	}

src/Engine/Rendering/PickingPass.cpp

@@ -18,14 +18,14 @@ PickingPass::~PickingPass()
 void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
-        glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
+        glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
 }
 
 void PickingPass::InitializeFrameBuffers()
 {
     glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
@@ -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) {
@@ -60,38 +69,78 @@ void PickingPass::Draw(RenderScene& scene)
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
-            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+			if (modelJob->Model->isSkined())
+			{
+				m_PickingSkinnedProgram->Bind();
+				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];
-            } 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] += 5;
-                } else {
-                        m_ColorCounter[0] += 50;
-                }
-            }
+				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_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])));
+				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 = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-            }
+				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(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+					}
+				}
+			} else {
+				m_PickingProgram->Bind();
+				int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+
+				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];
+				}
+				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_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])));
+			}
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -118,9 +167,9 @@ void PickingPass::Draw(RenderScene& scene)
                 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] += 5;
+                    m_ColorCounter[1] += 1;
                 } else {
-                    m_ColorCounter[0] += 50;
+                    m_ColorCounter[0] += 1;
                 }
             }
 
@@ -132,9 +181,11 @@ void PickingPass::Draw(RenderScene& scene)
             glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
             if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-                std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                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]));
+                }
             }
 
             glBindVertexArray(modelJob->Model->VAO);

src/Engine/Rendering/RawModelCustom.cpp

@@ -11,7 +11,6 @@ RawModelCustom::RawModelCustom(std::string fileName)
     ReadMeshFile(fileName);
     ReadMaterialFile(fileName);
     ReadAnimationFile(fileName);
-    int k = 0;
 }
 
 void RawModelCustom::ReadMeshFile(std::string filePath)
@@ -23,49 +22,49 @@ void RawModelCustom::ReadMeshFile(std::string filePath)
     if (!in.is_open()) {
         throw Resource::FailedLoadingException("Open mesh file failed");
     }
-    unsigned int fileByteSize = in.tellg();
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
-        ReadMeshFileHeader(offset, fileData, fileByteSize);
+        ReadMeshFileHeader(offset, fileData);
         ReadMesh(offset, fileData, fileByteSize);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
-void RawModelCustom::ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMeshFileHeader(std::size_t& offset, char* fileData)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-    isSkined = true;//*(unsigned int*)(fileData + offset);
-	//offset += sizeof(bool);
-	if (isSkined) {
-		m_SkinedVertices.resize(*(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(*(unsigned int*)(fileData + offset));
+		m_Vertices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
 	}
     offset += sizeof(unsigned int);
-    m_Indices.resize(*(unsigned int*)(fileData + offset));
+    m_Indices.resize(static_cast<std::size_t>(*(unsigned int*)(fileData + offset)));
     offset += sizeof(unsigned int);
 #else
 #endif
 }
 
-void RawModelCustom::ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadMesh(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
     ReadVertices(offset, fileData, fileByteSize);
     ReadIndices(offset, fileData, fileByteSize);
 }
 
-void RawModelCustom::ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadVertices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
-	if (isSkined) {
+	if (hasSkin) {
 		if (offset + m_SkinedVertices.size() * sizeof(SkinedVertex) > fileByteSize) {
 			throw Resource::FailedLoadingException("Reading skined vertices failed");
 		}
@@ -82,7 +81,7 @@ void RawModelCustom::ReadVertices(unsigned int& offset, char* fileData, unsigned
 #endif
 }
 
-void RawModelCustom::ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadIndices(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     if (offset + m_Indices.size() * sizeof(unsigned int) > fileByteSize) {
@@ -105,113 +104,181 @@ void RawModelCustom::ReadMaterialFile(std::string filePath)
     if (!in.is_open()) {
         throw Resource::FailedLoadingException("Open material file failed");
     }
-    unsigned int fileByteSize = in.tellg();
+
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
         ReadMaterials(offset, fileData, fileByteSize);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
-void RawModelCustom::ReadMaterials(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+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 (int i = 0; i < *numMaterials; i++) {
+    for (unsigned int i = 0; i < *numMaterials; i++) {
         ReadMaterialSingle(offset, fileData, fileByteSize);
     }
 #else
 #endif
 }
 
-void RawModelCustom::ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+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)
@@ -223,16 +290,19 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
     if (!in.is_open()) {
         //throw Resource::FailedLoadingException("Open animation file failed");
         return;
-    }
+	} else if (hasSkin) {
+		throw Resource::FailedLoadingException("Open animation file for a skinned mesh failed, unknown stuff will happen");
+		return;
+	}
 
-    unsigned int fileByteSize = in.tellg();
+    unsigned int fileByteSize = static_cast<unsigned int>(in.tellg());
     in.seekg(0, std::ios_base::beg);
 
     fileData = new char[fileByteSize];
     in.read(fileData, fileByteSize);
     in.close();
 
-    unsigned int offset = 0;
+    std::size_t offset = 0;
     if (fileByteSize > 0) {
         m_Skeleton = new Skeleton();
 
@@ -247,10 +317,10 @@ void RawModelCustom::ReadAnimationFile(std::string filePath)
         ReadAnimationBindPoses(offset, fileData, fileByteSize);
         ReadAnimationClips(offset, fileData, fileByteSize, numAnimations);
     }
-    delete fileData;
+    delete[] fileData;
 }
 
-void RawModelCustom::ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadAnimationBindPoses(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     unsigned int* numBones = (unsigned int*)(fileData + offset);
@@ -263,7 +333,7 @@ void RawModelCustom::ReadAnimationBindPoses(unsigned int &offset, char* fileData
 #endif
 }
 
-void RawModelCustom::ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+void RawModelCustom::ReadAnimationJoint(std::size_t& offset, char* fileData, const unsigned int& fileByteSize)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     if (offset + sizeof(unsigned int) > fileByteSize) {
@@ -305,14 +375,14 @@ void RawModelCustom::ReadAnimationJoint(unsigned int &offset, char* fileData, un
 #endif
 }
 
-void RawModelCustom::ReadAnimationClips(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int numberOfClips)
+void RawModelCustom::ReadAnimationClips(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int numberOfClips)
 {
     for (unsigned int i = 0; i < numberOfClips; i++) {
         ReadAnimationClipSingle(offset, fileData, fileByteSize, i);
     }
 }
 
-void RawModelCustom::ReadAnimationClipSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int clipIndex)
+void RawModelCustom::ReadAnimationClipSingle(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, unsigned int clipIndex)
 {
 #ifdef BOOST_LITTLE_ENDIAN
     Skeleton::Animation newAnimation;
@@ -368,7 +438,7 @@ void RawModelCustom::ReadAnimationClipSingle(unsigned int &offset, char* fileDat
 #endif
 }
 
-void RawModelCustom::ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation)
+void RawModelCustom::ReadAnimationKeyFrame(std::size_t& offset, char* fileData, const unsigned int& fileByteSize, std::vector<Skeleton::Animation::Keyframe>& animation)
 {
     Skeleton::Animation::Keyframe newKeyFrame;
 
@@ -412,6 +482,9 @@ RawModelCustom::~RawModelCustom()
     if (m_Skeleton != nullptr) {
         delete m_Skeleton;
     }
+	for (auto material : m_Materials) {
+		delete material.material;
+	}
 }
 
 #endif

src/Engine/Rendering/RenderSystem.cpp

@@ -113,6 +113,7 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
                 if (cModel["Transparent"]) {
                     transparentJobs.push_back(explosionEffectJob);
                 } else {
+					explosionEffectJob->CalculateHash();
                     opaqueJobs.push_back(explosionEffectJob);
                 }
             } else {
@@ -132,6 +133,7 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
                 if (cModel["Transparent"]) {
                     transparentJobs.push_back(modelJob);
                 } else {
+					modelJob->CalculateHash();
                     opaqueJobs.push_back(modelJob);
                 }
             }
@@ -196,7 +198,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) {
@@ -240,11 +242,19 @@ void RenderSystem::Update(double dt)
         m_Camera->SetOrientation(Transform::AbsoluteOrientation(m_CurrentCamera));
     }
 
-
     RenderScene scene;
     scene.Camera = m_Camera;
     scene.Viewport = Rectangle(1280, 720);
+
+    auto cSceneLight = m_World->GetComponents("SceneLight");
+    if (cSceneLight != nullptr && cSceneLight->begin() != cSceneLight->end()) {
+        m_RenderFrame->Gamma = (double)(*cSceneLight->begin())["Gamma"];
+        m_RenderFrame->Exposure = (double)(*cSceneLight->begin())["Exposure"];
+        scene.AmbientColor = (glm::vec4)(*cSceneLight->begin())["AmbientColor"];
+    }
+
     fillModels(scene.OpaqueObjects, scene.TransparentObjects);
+	scene.OpaqueObjects.sort();
     fillPointLights(scene.PointLightJobs, m_World);
     fillDirectionalLights(scene.DirectionalLightJobs, m_World);
     fillText(scene.TextJobs, m_World);