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

# Conflicts:
#	include/Engine/Rendering/RenderSystem.h
#	resources/Schema/Entities/RenderingWorld.xml
#	resources/Shaders/ForwardPlus.frag.glsl
#	src/Engine/Rendering/RenderSystem.cpp

.gitignore

@@ -4,3 +4,11 @@ bin/
 lib/
 # Because apparently nobody has any self control
 *.orig
+
+*.suo
+*.sdf
+tools/MayaExporter/MayaExporter/x64/Debug/
+tools/MayaExporter/x64/Debug/
+
+tools/MayaExporter/MayaExporter/Debug/
+tools/MayaExporter/MayaExporter/GeneratedFiles/

include/Engine/Collision/Collision.h

@@ -10,7 +10,8 @@
 
 #include "../Core/Ray.h"
 #include "../Core/AABB.h"
-#include "../Rendering/RawModel.h"
+#include "Rendering/RawModelCustom.h"
+//#include "Rendering/RawModelAssimp.h"
 #include "../Core/Transform.h"
 #include "../Core/Entity.h"
 #include "../Core/EntityWrapper.h"

include/Engine/Core/EPlayerSpawned.h

@@ -0,0 +1,19 @@
+#ifndef EPlayerSpawned_h__
+#define EPlayerSpawned_h__
+
+#include "Core/Event.h"
+#include "Core/EntityWrapper.h"
+
+namespace Events
+{
+
+struct PlayerSpawned : Event
+{
+    int PlayerID;
+    EntityWrapper Player;
+    EntityWrapper Spawner;
+};
+
+}
+
+#endif

include/Engine/Core/EntityWrapper.h

@@ -25,6 +25,8 @@ struct EntityWrapper
 
     bool HasComponent(const std::string& componentName);
     EntityWrapper Parent();
+    EntityWrapper FirstChildByName(const std::string& name);
+    bool IsChildOf(EntityWrapper potentialParent);
     bool Valid();
 
     ComponentWrapper operator[](const char* componentName);

include/Engine/Core/Octree.h

@@ -111,7 +111,7 @@ struct Child
     std::vector<ContainedObject>& m_StaticObjectsRef;
     std::vector<ContainedObject>& m_DynamicObjectsRef;
 
-    inline bool hasChildren() const;
+    bool hasChildren() const;
     int childIndexContainingPoint(const glm::vec3& point) const;
     std::vector<int> childIndicesContainingBox(const AABB& box) const;
 };

include/Engine/Core/ResourceManager.h

@@ -32,10 +32,10 @@ public:
     };
     struct FailedLoadingException : public std::exception
     {
-        virtual const char* what() const throw()
-        {
-            return "Resource is failed to load.";
-        }
+        FailedLoadingException(char const* const _Message)
+            : std::exception(_Message)
+        { }
+        FailedLoadingException() :std::exception("Resource failed to load.") { };
     };
 
 	// Pretend that this is a pure virtual function that you have to implement

include/Engine/Core/Transform.h

@@ -3,13 +3,18 @@
 
 #include "../GLM.h"
 #include "World.h"
+#include "EntityWrapper.h"
 
 namespace Transform
 {
 
+glm::vec3 AbsolutePosition(EntityWrapper entity);
 glm::vec3 AbsolutePosition(World* world, EntityID entity);
+glm::quat AbsoluteOrientation(EntityWrapper entity);
 glm::quat AbsoluteOrientation(World* world, EntityID entity);
+glm::vec3 AbsoluteScale(EntityWrapper entity);
 glm::vec3 AbsoluteScale(World* world, EntityID entity);
+glm::mat4 ModelMatrix(EntityWrapper entity);
 glm::mat4 ModelMatrix(EntityID entity, World* world);
 
 }

include/Engine/Editor/EditorCameraInputController.h

@@ -0,0 +1,115 @@
+#ifndef EditorCameraInputController_h__
+#define EditorCameraInputController_h__
+
+#include <imgui/imgui.h>
+#include "../Input/FirstPersonInputController.h"
+#include "../Core/EMousePress.h"
+#include "../Core/EMouseRelease.h"
+#include "../Core/EMouseScroll.h"
+#include "../Core/ConfigFile.h"
+
+template <typename EventContext>
+class EditorCameraInputController : public FirstPersonInputController<EventContext>
+{
+public:
+    EditorCameraInputController(EventBroker* eventBroker, unsigned int playerID)
+        : FirstPersonInputController(eventBroker, playerID)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorCameraInputController::OnMousePress);
+        EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &EditorCameraInputController::OnMouseRelease);
+        EVENT_SUBSCRIBE_MEMBER(m_EMouseScroll, &EditorCameraInputController::OnMouseScroll);
+
+        m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
+        m_SpeedMultiplier = m_Config->Get<float>("Editor.CameraSpeed", 3.f);
+    }
+    
+    virtual const glm::vec3 Movement() const override { return m_Movement * m_SpeedMultiplier; }
+
+    void Enable() { m_Enabled = true; }
+    void Disable() { m_Enabled = false; }
+
+    virtual bool OnCommand(const Events::InputCommand& e) override
+    {
+        if (glm::abs(e.Value) > 0 && !m_MouseLocked) {
+            return false;
+        }
+
+        ImGuiIO& io = ImGui::GetIO();
+        if (glm::abs(e.Value) > 0 && (io.WantCaptureKeyboard || io.WantCaptureMouse)) {
+            return false;
+        }
+
+        if (e.Command == "Jump") {
+            if (e.Value > 0) {
+                m_Movement.y = glm::max(e.Value, 1.f);
+            } else {
+                m_Movement.y = 0.f;
+            }
+        }
+
+        if (e.Command == "Crouch") {
+            if (e.Value > 0) {
+                m_Movement.y = glm::min(-e.Value, -1.f);
+            } else {
+                m_Movement.y = 0.f;
+            }
+        }
+
+        if (e.Command == "Sprint") {
+            if (e.Value > 0) {
+                m_SpeedMultiplier *= 2.f;
+            } else {
+                m_SpeedMultiplier /= 2.f;
+            }
+        }
+
+        return FirstPersonInputController::OnCommand(e);
+    }
+
+protected:
+    ConfigFile* m_Config;
+    bool m_Enabled = false;
+    float m_SpeedMultiplier = 1.f;
+
+    EventRelay<EventContext, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e)
+    {
+        if (!m_Enabled) {
+            return false;
+        }
+
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            ImGuiIO& io = ImGui::GetIO();
+            if (!io.WantCaptureMouse) {
+                LockMouse();
+            }
+        }
+        return true;
+    }
+    EventRelay<EventContext, Events::MouseRelease> m_EMouseRelease;
+    bool OnMouseRelease(const Events::MouseRelease& e)
+    {
+        if (!m_Enabled) {
+            return false;
+        }
+
+        if (e.Button == GLFW_MOUSE_BUTTON_2) {
+            UnlockMouse();
+        }
+        return true;
+    }
+    EventRelay<EventContext, Events::MouseScroll> m_EMouseScroll;
+    bool OnMouseScroll(const Events::MouseScroll& e)
+    {
+        if (!m_Enabled) {
+            return false;
+        }
+
+        m_SpeedMultiplier += e.DeltaY * (0.1f * m_SpeedMultiplier);
+        m_Config->Set("Editor.CameraSpeed", m_SpeedMultiplier);
+        m_Config->SaveToDisk();
+        return true;
+    }
+};
+
+#endif

include/Engine/Editor/EditorSystem.h

@@ -1,7 +1,6 @@
 #include "../Core/System.h"
 #include "../Rendering/IRenderer.h"
 #include "../Rendering/Camera.h"
-#include "../Rendering/DebugCameraInputController.h"
 #include "../Rendering/ESetCamera.h"
 #include "../Core/World.h"
 #include "../Core/SystemPipeline.h"
@@ -10,8 +9,10 @@
 #include "../Core/EntityFileParser.h"
 #include "../Core/EntityFileWriter.h"
 #include "../Core/EMousePress.h"
+#include "../Input/EInputCommand.h"
 #include "EditorGUI.h"
 #include "EditorStats.h"
+#include "EditorCameraInputController.h"
 
 class EditorSystem : public ImpureSystem
 {
@@ -21,18 +22,24 @@ public:
 
     void Update(double dt);
 
+    void Enable();
+    void Disable();
+
 private:
     IRenderer* m_Renderer;
     RenderFrame* m_RenderFrame;
     World* m_EditorWorld;
     SystemPipeline* m_EditorWorldSystemPipeline;
-    Camera* m_EditorCamera;
-    EntityWrapper m_Camera = EntityWrapper::Invalid;
-    DebugCameraInputController<EditorSystem>* m_DebugCameraInputController;
+    //Camera* m_EditorCamera;
+    EntityWrapper m_EditorCamera = EntityWrapper::Invalid;
+    EntityWrapper m_ActualCamera = EntityWrapper::Invalid;
+    EditorCameraInputController<EditorSystem>* m_EditorCameraInputController;
     EditorGUI* m_EditorGUI;
     EditorStats* m_EditorStats;
 
     // State
+    double m_LastTime = 0.f;
+    bool m_Enabled = true;
     EditorGUI::WidgetMode m_WidgetMode = EditorGUI::WidgetMode::Translate;
     EntityWrapper m_Widget = EntityWrapper::Invalid;
     EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
@@ -56,4 +63,8 @@ private:
     bool OnMousePress(const Events::MousePress& e);
     EventRelay<EditorSystem, Events::WidgetDelta> m_EWidgetDelta;
     bool OnWidgetDelta(const Events::WidgetDelta& e);
+    EventRelay<EditorSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
+    EventRelay<EditorSystem, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera& e);
 };

include/Engine/Input/EInputCommand.h

@@ -9,7 +9,7 @@ namespace Events
 struct InputCommand : Event
 {
 	/** Numerical ID of the player. */
-	unsigned int PlayerID;
+	int PlayerID;
 	/** The command that was sent. */
 	std::string Command;
 	/** The value of the command. */

include/Engine/Input/FirstPersonInputController.h

@@ -9,62 +9,119 @@ template <typename EventContext>
 class FirstPersonInputController : public InputController<EventContext>
 {
 public:
-    FirstPersonInputController(EventBroker* eventBroker, unsigned int playerID)
+    FirstPersonInputController(EventBroker* eventBroker, int playerID);
+
+    virtual const glm::vec3 Movement() const { return m_Movement; }
+    virtual const glm::vec3 Rotation() const { return m_Rotation; }
+    virtual bool Jumping() const { return m_Jumping; }
+    virtual bool Crouching() const { return m_Crouching; }
+    
+    void LockMouse();
+    void UnlockMouse();
+    virtual bool OnCommand(const Events::InputCommand& e) override;
+    virtual void Reset();
+
+protected:
+    const int m_PlayerID;
+    bool m_MouseLocked = false;
+    glm::vec3 m_Rotation;
+    glm::vec3 m_Movement;
+    bool m_Jumping = false;
+    bool m_Crouching = false;
+    
+    EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
+    bool OnLockMouse(const Events::LockMouse& e);
+    EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
+    bool OnUnlockMouse(const Events::UnlockMouse& e);
+};
+
+template <typename EventContext>
+FirstPersonInputController<EventContext>::FirstPersonInputController(EventBroker* eventBroker, int playerID) 
     : InputController(eventBroker)
     , m_PlayerID(playerID)
-    {
+{
     EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &FirstPersonInputController::OnLockMouse);
     EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &FirstPersonInputController::OnUnlockMouse);
-    }
+}
 
-    const glm::quat Orientation() const { return m_Orientation; }
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::Reset()
+{
+    m_Rotation = glm::vec3(0.f, 0.f, 0.f);
+    m_Jumping = false;
+}
 
-    void LockMouse()
-    {
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::LockMouse()
+{
     Events::LockMouse e;
     m_EventBroker->Publish(e);
     m_MouseLocked = true;
-    }
+}
 
-    void UnlockMouse()
-    {
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::UnlockMouse()
+{
     Events::UnlockMouse e;
     m_EventBroker->Publish(e);
     m_MouseLocked = false;
-    }
+}
 
-    virtual bool OnCommand(const Events::InputCommand& e) override
-    {
+template <typename EventContext>
+bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputCommand& e)
+{
     if (m_PlayerID != e.PlayerID) {
         return false;
     }
 
-        if (m_MouseLocked) {
     if (e.Command == "Pitch") {
         float val = glm::radians(e.Value);
-                m_Orientation = m_Orientation * glm::angleAxis<float>(-val, glm::vec3(1, 0, 0));
-                return true;
+        m_Rotation.x += -val;
+        //m_Rotation.x = glm::clamp(m_Rotation.x, -glm::half_pi<float>(), glm::half_pi<float>());
     }
 
     if (e.Command == "Yaw") {
         float val = glm::radians(e.Value);
-                m_Orientation = glm::angleAxis<float>(-val, glm::vec3(0, 1, 0)) * m_Orientation;
+        m_Rotation.y += -val;
+    }
+
+    if (e.Command == "Forward" || e.Command == "Right") {
+        if (e.Command == "Forward") {
+            float val = glm::clamp(e.Value, -1.f, 1.f);
+            m_Movement.z = -val;
+        }
+        if (e.Command == "Right") {
+            float val = glm::clamp(e.Value, -1.f, 1.f);
+            m_Movement.x = val;
+        }
+        if (glm::length2(m_Movement) > 0) {
+            m_Movement = glm::normalize(m_Movement);
+        }
+    }
+
+    if (e.Command == "Jump") {
+        m_Jumping = e.Value > 0;
+    }
+
+    if (e.Command == "Crouch") {
+        m_Crouching = e.Value > 0;
+    }
+
     return true;
-            }
-        }
+}
 
-        return false;
-    }
+template <typename EventContext>
+bool FirstPersonInputController<EventContext>::OnUnlockMouse(const Events::UnlockMouse& e)
+{
+    m_MouseLocked = false; 
+    return true;
+}
 
-protected:
-    const unsigned int m_PlayerID;
-    glm::quat m_Orientation;
-    bool m_MouseLocked = false;
-    
-    EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
-    bool OnLockMouse(const Events::LockMouse& e) { m_MouseLocked = true; return true; }
-    EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
-    bool OnUnlockMouse(const Events::UnlockMouse& e) { m_MouseLocked = false; return true; }
-};
+template <typename EventContext>
+bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMouse& e)
+{
+    m_MouseLocked = true; 
+    return true;
+}
 
 #endif

include/Engine/Network/Client.h

@@ -20,6 +20,7 @@
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
 #include "Network/EInterpolate.h"
+#include "Core/EPlayerSpawned.h"
 
 class Client : public Network
 {
@@ -39,14 +40,14 @@ private:
     char readBuf[INPUTSIZE] = { 0 };
 
     // Packet loss logic
-    unsigned int m_PacketID = 0;
-    unsigned int m_PreviousPacketID = 0;
-    unsigned int m_SendPacketID = 0;
+    PacketID m_PacketID = 0;
+    PacketID m_PreviousPacketID = 0;
+    PacketID m_SendPacketID = 0;
 
     // Game logic
     World* m_World;
     std::string m_PlayerName;
-    int m_PlayerID = -1;
+    PlayerID m_PlayerID = -1;
     EntityID m_ServerEntityID = std::numeric_limits<EntityID>::max();
     bool m_IsConnected = false;
     // Server Client Lookup map
@@ -57,25 +58,27 @@ private:
     std::unordered_map<EntityID, EntityID> m_ClientIDToServerID;
 
     // Network logic
-    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
+    PlayerDefinition m_PlayerDefinitions[8];
     SnapshotDefinitions m_NextSnapshot;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
+    std::clock_t m_TimeSinceSentInputs;
+    unsigned int m_SendInputIntervalMs;
     std::vector<Events::InputCommand> m_InputCommandBuffer;
 
     // Private member functions
     void readFromServer();
-    int  receive(char* data, size_t length);
+    int  receive(char* data);
     void send(Packet& packet);
     void connect();
     void disconnect();
-    void ping();
     void parseMessageType(Packet& packet);
     void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
     void parseConnect(Packet& packet);
     void parsePlayerConnected(Packet& packet);
     void parsePing();
-    void parseServerPing();
+    void parseKick();
+    void parsePlayersSpawned(Packet& packet);
     void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();

include/Engine/Network/EPlayerDisconnected.h

@@ -0,0 +1,18 @@
+#ifndef Events_PlayerDisconnected
+#define Events_PlayerDisconnected
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace Events
+{
+
+struct PlayerDisconnected : public Event
+{
+    unsigned int PlayerID;
+    EntityID Entity;
+};
+
+}
+
+#endif

include/Engine/Network/MessageType.h

@@ -7,14 +7,15 @@ enum class MessageType
 {
     Connect,
     Disconnect,
-	ClientPing,
-	ServerPing,
+    Ping,
     Message,
     Snapshot,
     OnInputCommand,
     OnPlayerDamage,
     PlayerConnected,
-    BecomePlayer
+    BecomePlayer,
+    Kick,
+    OnPlayerSpawned
 };
 
 #endif

include/Engine/Network/Network.h

@@ -1,13 +1,21 @@
 #ifndef Network_h__
 #define Network_h__
 
+#include <ctime>
+
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Network/Packet.h"
+#include "Network/NetworkData.h"
+#include "Core/ResourceManager.h"
+#include "Core/ConfigFile.h"
+#include <fstream>
+#include <iostream>
 
-#define MAXCONNECTIONS 8
 #define INPUTSIZE 4097
-#define TIMEOUTMS 15000
+typedef unsigned int PlayerID;
+typedef unsigned int PacketID;
+typedef unsigned int UserID;
 
 class Network
 {
@@ -15,6 +23,17 @@ public:
     virtual ~Network() { };
     virtual void Start(World* m_world, EventBroker *eventBroker) = 0;
     virtual void Update() = 0;
+protected:
+    // For Debug 
+    bool isReadingData = false;
+    NetworkData m_NetworkData;
+    unsigned int m_SaveDataIntervalMs = 1000;
+    std::clock_t m_SaveDataTimer;
+    unsigned int m_MaxConnections;
+    unsigned int m_TimeoutMs;
+    void saveToFile();
+    void updateNetworkData();
+    void initialize();
 };
 
 #endif

include/Engine/Network/NetworkData.h

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

include/Engine/Network/Packet.h

@@ -55,12 +55,14 @@ public:
     char* Data() { return m_Data; };
     unsigned int DataReadSize() { return m_ReturnDataOffset; }
     unsigned int MaxSize() { return m_MaxPacketSize; }
+    unsigned int 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;
     void resizeData();
 };
 

include/Engine/Network/Server.h

@@ -14,6 +14,8 @@
 #include "../Network/Network.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
+#include "Network/EPlayerDisconnected.h"
+#include "Core/EPlayerSpawned.h"
 
 class Server : public Network
 {
@@ -29,7 +31,7 @@ private:
     boost::asio::ip::udp::socket m_Socket;
 
     // Sending messages to client logic
-    PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
+    PlayerDefinition m_PlayerDefinitions[8]; // 
     std::vector<PlayerDefinition> m_ConnectedUsers;
     char readBuffer[INPUTSIZE] = { 0 };
     int bytesRead = 0;
@@ -38,8 +40,8 @@ private:
     std::clock_t previousSnapshotMessage = std::clock();
     std::clock_t timOutTimer = std::clock();
     // How often we send messages (milliseconds)
-    int intervalMs = 1000;
-    int snapshotInterval = 50;
+    int pingIntervalMs;
+    int snapshotInterval;
     int checkTimeOutInterval = 100;
 
     //Timers
@@ -50,32 +52,36 @@ private:
     EventBroker* m_EventBroker;
     
     // Packet loss logic
-    unsigned int m_PacketID = 0;
-    unsigned int m_PreviousPacketID = 0;
+    PacketID m_PacketID = 0;
+    PacketID m_PreviousPacketID = 0;
 
     // Private member functions
-    int  receive(char* data, size_t length);
+    int  receive(char* data);
     void readFromClients();
-    void send(Packet& packet, int playerID);
+    void send(Packet& packet, UserID user);
+    void send(PlayerID player, Packet& packet);
     void send(Packet& packet);
     void broadcast(Packet& packet);
     void sendSnapshot();
     void sendPing();
     void checkForTimeOuts();
-    void disconnect(int i);
+    void disconnect(UserID user);
     void parseMessageType(Packet& packet);
     void parseOnInputCommand(Packet& packet);
     void parseOnPlayerDamage(Packet& packet);
     void parseConnect(Packet& packet);
     void parseDisconnect();
     void parseClientPing();
-    void parseServerPing();
+    void parsePing();
     void identifyPacketLoss();
     void createPlayer();
-    int GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
+    void kick(PlayerID player);
+    PlayerID GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint);
     // Debug event
     EventRelay<Server, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
+    EventRelay<Server, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(const Events::PlayerSpawned& e);
 };
 
 #endif

include/Engine/Rendering/DebugCameraInputController.h

@@ -1,84 +0,0 @@
-#ifndef DebugCameraInputController_h__
-#define DebugCameraInputController_h__
-
-#include <imgui/imgui.h>
-#include "../Input/FirstPersonInputController.h"
-#include "../Core/EMousePress.h"
-#include "../Core/EMouseRelease.h"
-
-template <typename EventContext>
-class DebugCameraInputController : public FirstPersonInputController<EventContext>
-{
-public:
-    DebugCameraInputController(EventBroker* eventBroker, unsigned int playerID)
-        : FirstPersonInputController(eventBroker, playerID)
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &DebugCameraInputController::OnMousePress);
-        EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &DebugCameraInputController::OnMouseRelease);
-    }
-
-    void SetPosition(const glm::vec3 position) { m_Position = position; }
-    void SetOrientation(const glm::quat orientation) { m_Orientation = orientation; }
-
-    const glm::vec3 Position() const { return m_Position; }
-    void SetBaseSpeed(float speed) { m_BaseSpeed = speed; }
-
-    virtual bool OnCommand(const Events::InputCommand& e) override
-    {
-        ImGuiIO& io = ImGui::GetIO();
-
-        if (!io.WantCaptureKeyboard) {
-            if (e.Command == "Right") {
-                float value = std::max(-1.f, std::min(e.Value, 1.f));
-                m_Velocity.x = value;
-            }
-            if (e.Command == "Forward") {
-                float value = std::max(-1.f, std::min(e.Value, 1.f));
-                m_Velocity.z = -value;
-            }
-            if (e.Command == "Sprint") {
-                if (e.Value > 0.f) {
-                    m_Speed = m_BaseSpeed * 2.f * (e.Value);
-                } else {
-                    m_Speed = m_BaseSpeed;
-                }
-            }
-        }
-
-        return FirstPersonInputController::OnCommand(e);
-    }
-
-    void Update(double dt)
-    {
-        if (glm::length2(m_Velocity) > 0) {
-            m_Position += m_Orientation * (glm::normalize(m_Velocity) * m_Speed * (float)dt);
-        }
-    }
-
-protected:
-    glm::vec3 m_Position = glm::vec3(0, 0, 0);
-    glm::vec3 m_Velocity = glm::vec3(0, 0, 0);
-    float m_BaseSpeed = 2.0f;
-    float m_Speed = m_BaseSpeed;
-    EventRelay<EventContext, Events::MousePress> m_EMousePress;
-    bool OnMousePress(const Events::MousePress& e)
-    {
-        if (e.Button == GLFW_MOUSE_BUTTON_2) {
-            ImGuiIO& io = ImGui::GetIO();
-            if (!io.WantCaptureMouse) {
-                LockMouse();
-            }
-        }
-        return true;
-    }
-    EventRelay<EventContext, Events::MouseRelease> m_EMouseRelease;
-    bool OnMouseRelease(const Events::MouseRelease& e)
-    {
-        if (e.Button == GLFW_MOUSE_BUTTON_2) {
-            UnlockMouse();
-        }
-        return true;
-    }
-};
-
-#endif

include/Engine/Rendering/Model.h

@@ -1,7 +1,8 @@
 #ifndef Model_h__
 #define Model_h__
 
-#include "RawModel.h"
+#include "Rendering/RawModelCustom.h"
+//#include "Rendering/RawModelAssimp.h"
 #include "../OpenGL.h"
 
 class Model : public ThreadUnsafeResource
@@ -19,12 +20,11 @@ public:
 
 	GLuint VAO;
 	GLuint ElementBuffer;
+    RawModel* m_RawModel;
 
 private:
-    RawModel* m_RawModel;
+    
 	GLuint VertexBuffer;
-	GLuint DiffuseVertexColorBuffer;
-	GLuint SpecularVertexColorBuffer;
 	GLuint NormalBuffer;
 	GLuint TangentNormalsBuffer;
 	GLuint BiTangentNormalsBuffer;

include/Engine/Rendering/ModelJob.h

@@ -24,6 +24,10 @@ struct ModelJob : RenderJob
         DiffuseTexture = matGroup.Texture.get();
         NormalTexture = matGroup.NormalMap.get();
         SpecularTexture = matGroup.SpecularMap.get();
+        IncandescenceTexture = matGroup.IncandescenceMap.get();
+        DiffuseColor = matGroup.DiffuseColor;
+        SpecularColor = matGroup.SpecularColor;
+        IncandescenceColor = matGroup.IncandescenceColor;
         StartIndex = matGroup.StartIndex;
         EndIndex = matGroup.EndIndex;
         Matrix = matrix;
@@ -47,9 +51,13 @@ struct ModelJob : RenderJob
     const Texture* DiffuseTexture;
     const Texture* NormalTexture;
     const Texture* SpecularTexture;
+    const Texture* IncandescenceTexture;
     float Shininess = 0.f;
     glm::vec4 Color;
     const ::Model* Model = nullptr;
+    glm::vec4 DiffuseColor;
+    glm::vec4 SpecularColor;
+    glm::vec4 IncandescenceColor;
     unsigned int StartIndex = 0;
     unsigned int EndIndex = 0;
     World* World;

include/Engine/Rendering/RawModelAssimp.h

@@ -1,5 +1,7 @@
-#ifndef RawModel_h__
-#define RawModel_h__
+#ifndef RawModelAssimp_h__
+#define RawModelAssimp_h__
+
+#ifdef USING_ASSIMP_AS_IMPORTER
 
 #include <fstream>
 #include <iostream>
@@ -18,29 +20,27 @@
 #include "Texture.h"
 #include "Skeleton.h"
 
-class RawModel : public Resource
+#define RawModel RawModelAssimp
+
+class RawModelAssimp : public Resource
 {
 	friend class ResourceManager;
 
 protected:
-	RawModel(std::string fileName);
+    RawModelAssimp(std::string fileName);
 
 public:
-	~RawModel();
+	~RawModelAssimp();
 
 	struct Vertex
 	{
 		glm::vec3 Position;
 		glm::vec3 Normal;
 		glm::vec3 Tangent;
-		glm::vec3 BiTangent;
+		glm::vec3 BiNormal;
 		glm::vec2 TextureCoords;
-		glm::vec4 DiffuseVertexColor;
-		glm::vec4 SpecularVertexColor;
-		glm::vec4 BoneIndices1;
-		glm::vec4 BoneIndices2;
-		glm::vec4 BoneWeights1;
-		glm::vec4 BoneWeights2;
+		glm::vec4 BoneIndices;
+		glm::vec4 BoneWeights;
 	};
 
 	struct MaterialGroup
@@ -68,8 +68,6 @@ private:
 	std::vector<glm::ivec2> BoneIndices;
 	std::vector<glm::vec2> BoneWeights;
 	std::vector<glm::vec3> Normals;
-	std::vector<glm::vec4> DiffuseVertexColor;
-	std::vector<glm::vec4> SpecularVertexColor;
 	std::vector<glm::vec3> TangentNormals;
 	std::vector<glm::vec3> BiTangentNormals;
 	std::vector<glm::vec2> TextureCoords;
@@ -78,3 +76,4 @@ private:
 };
 
 #endif
+#endif

include/Engine/Rendering/RawModelCustom.h

@@ -0,0 +1,102 @@
+#ifndef RawModelCustom_h__
+#define RawModelCustom_h__
+
+#ifndef USING_ASSIMP_AS_IMPORTER
+
+#define RawModel RawModelCustom
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <cstdlib>
+#include <stack>
+
+#include <boost/filesystem/path.hpp>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ResourceManager.h"
+#include "Texture.h"
+#include "Skeleton.h"
+
+#include "boost\endian\buffers.hpp"
+
+
+
+class RawModelCustom : public Resource
+{
+    friend class ResourceManager;
+
+protected:
+    RawModelCustom(std::string fileName);
+
+public:
+    ~RawModelCustom();
+    
+    struct Vertex
+    {
+        glm::vec3 Position;
+        glm::vec3 Normal;
+        glm::vec3 Tangent;
+        glm::vec3 BiNormal;
+        glm::vec2 TextureCoords;
+        glm::vec4 BoneIndices;
+        glm::vec4 BoneWeights;
+    };
+
+    struct MaterialGroup
+    {
+        float SpecularExponent;
+        float ReflectionFactor;
+        glm::vec4 DiffuseColor{ 1.0f, 1.0f, 1.0f, 1.0f };
+        glm::vec4 SpecularColor{ 1.0f, 1.0f, 1.0f, 1.0f };
+        glm::vec4 IncandescenceColor{ 1.0f, 1.0f, 1.0f, 1.0f };
+        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;
+    };
+
+    std::vector<MaterialGroup> MaterialGroups;
+
+    std::vector<Vertex> m_Vertices;
+    std::vector<unsigned int> m_Indices;
+    Skeleton* m_Skeleton = nullptr;
+    glm::mat4 m_Matrix;
+
+private:
+   
+
+    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 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 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, unsigned int numberOfJoints, Skeleton::Animation& animation);
+    
+    //void CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID);
+};
+
+#else
+
+#include "RawModelAssimp.h"
+
+#endif
+#endif

include/Engine/Rendering/RenderSystem.h

@@ -15,7 +15,7 @@
 #include "Renderer.h"
 #include "PointLightJob.h"
 #include "../Core/Transform.h"
-#include "DebugCameraInputController.h"
+#include "../Core/EPlayerSpawned.h"
 
 class RenderSystem : public ImpureSystem
 {
@@ -29,8 +29,9 @@ private:
     const IRenderer* m_Renderer;
     RenderFrame* m_RenderFrame;
     Camera* m_Camera;
-    EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
     World* m_World;
+    EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
+    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
     EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
     bool OnSetCamera(Events::SetCamera &event);
@@ -42,6 +43,9 @@ private:
 
     void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs);
     void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs);
+
+    EventRelay<RenderSystem, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };
 
 #endif

include/Engine/Rendering/Skeleton.h

@@ -4,6 +4,7 @@
 #include <sstream>
 #include "Common.h"
 #include "../GLM.h"
+#include <glm/gtx/matrix_decompose.hpp>
 
 //struct Bone
 //{
@@ -38,9 +39,9 @@ public:
 			, OffsetMatrix(offsetMatrix)
 		{ }
 
-		int ID;
 		std::string Name;
 		glm::mat4 OffsetMatrix;
+        int ID;
 
 		Bone* Parent;
 		std::vector<Bone*> Children;

include/Game/Systems/InterpolationSystem.h

@@ -10,11 +10,12 @@
 #include "Common.h"
 #include "Core/System.h"
 #include "Core/EventBroker.h"
+#include "Core/ResourceManager.h"
+#include "Core/ConfigFile.h"
+#include "Core/EPlayerSpawned.h"
 
 #include "Network/EInterpolate.h"
 
-#define SNAPSHOTINTERVAL 0.05f
-
 class InterpolationSystem : public PureSystem
 {
     struct Transform 
@@ -25,29 +26,28 @@ class InterpolationSystem : public PureSystem
         double interpolationTime;
     };
 public:
-    InterpolationSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("Transform")
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
-    }
+    InterpolationSystem(World* world, EventBroker* eventBroker);
     ~InterpolationSystem() { }
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt) override;
 private:
     std::unordered_map<EntityID, Transform> m_NextTransform;
     std::unordered_map<EntityID, Transform> m_LastReceivedTransform;
+    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
     //glm::vec3 vectorInterpolation(glm::vec3 prev, glm::vec3 next, double currentTime);
     template <typename T>
     T vectorInterpolation(T prev, T next, double currentTime)
     {
         T difference = next - prev;
-        T vector = (difference / SNAPSHOTINTERVAL) * static_cast<float>(currentTime);
+        T vector = (difference / m_SnapshotInterval) * static_cast<float>(currentTime);
         return vector;
     }
+    float m_SnapshotInterval;
 
     EventRelay<InterpolationSystem, Events::Interpolate> m_EInterpolate;
     bool InterpolationSystem::OnInterpolate(const Events::Interpolate& e);
+    EventRelay<InterpolationSystem, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };
 
 #endif

include/Game/Systems/PlayerMovementSystem.h

@@ -1,14 +1,23 @@
 #include "Common.h"
 #include "GLM.h"
 #include "Core/System.h"
+#include "Core/EPlayerSpawned.h"
+#include "Input/FirstPersonInputController.h"
+#include <imgui/imgui.h>
 
-class PlayerMovementSystem : public PureSystem
+class PlayerMovementSystem : public ImpureSystem, PureSystem
 {
 public:
-    PlayerMovementSystem(World* world, EventBroker* eventBroker)
-        : System(world, eventBroker)
-        , PureSystem("Player")
-    { }
+    PlayerMovementSystem(World* world, EventBroker* eventBroker);
+    ~PlayerMovementSystem();
 
+    virtual void Update(double dt) override;
     virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt);
+
+private:
+    // State
+    std::unordered_map<EntityWrapper, FirstPersonInputController<PlayerMovementSystem>*> m_PlayerInputControllers;
+
+    EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
+    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };

include/Game/Systems/PlayerSpawnSystem.h

@@ -2,6 +2,9 @@
 #include "Input/EInputCommand.h"
 #include "Systems/SpawnerSystem.h"
 #include "Events/ESpawnerSpawn.h"
+#include "Core/EPlayerSpawned.h"
+#include "Rendering/ESetCamera.h"
+#include "Core/ConfigFile.h"
 
 class PlayerSpawnSystem : public ImpureSystem
 {
@@ -11,8 +14,18 @@ public:
     virtual void Update(double dt) override;
 
 private:
+    struct SpawnRequest
+    {
+        int PlayerID;
+        ComponentInfo::EnumType Team;
+    };
+
+    bool m_NetworkEnabled = false;
+    std::vector<SpawnRequest> m_SpawnRequests;
+    std::map<int, EntityWrapper> m_PlayerEntities;
+
     EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
-
-    std::vector<int> m_SpawnRequests;
+    EventRelay<PlayerSpawnSystem, Events::PlayerSpawned> m_OnPlayerSpawnerd;
+    bool OnPlayerSpawned(Events::PlayerSpawned& e);
 };

resources/DefaultConfig.ini

@@ -1,11 +1,13 @@
 [Debug]
 LogLevel=1
 LoadMap=
-EditorEnabled=false
 ; if true -> Pool allocation is not used when calling Allocate/Free, just use regular dynamic allocation. 
 ; if false -> Use pool allocation.
 DisableMemoryPool=false
 
+[Editor]
+CameraSpeed=3
+
 [Video]
 Fullscreen=false
 VSYNC=false
@@ -19,6 +21,11 @@ IsServer=false
 Name=Bob
 Address=127.0.0.1
 Port=13
+MaxConnections=8
+SnapshotInterval=0.05
+SendInputIntervalMs=33
+PingIntervalMs= 1000
+TimeoutMs=15000
 
 [Multithreading]
 ResourceLoading=true

resources/Schema/Components/Player.xml

@@ -1,8 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Player.xsd">
-	<Velocity X="0" Y="0" Z="0"/>
-	<Forward>false</Forward>
-	<Left>false</Left>
-	<Back>false</Back>
-	<Right>false</Right>
+	<MovementSpeed>3</MovementSpeed>
+	<CrouchSpeed>1.5</CrouchSpeed>
 </Player>

resources/Schema/Components/Player.xsd

@@ -9,11 +9,8 @@
 		</xs:annotation>
 		<xs:complexType>
 			<xs:all>
-				<xs:element name="Velocity" type="t:Vector" minOccurs="0"/>
-				<xs:element name="Forward" type="t:bool" minOccurs="0"/>
-				<xs:element name="Left" type="t:bool" minOccurs="0"/>
-				<xs:element name="Back" type="t:bool" minOccurs="0"/>
-				<xs:element name="Right" type="t:bool" minOccurs="0"/>
+				<xs:element name="MovementSpeed" type="t:float" minOccurs="0"/>
+				<xs:element name="CrouchSpeed" type="t:float" minOccurs="0"/>
 			</xs:all>
 		</xs:complexType>
 	</xs:element>

resources/Schema/Entities/AnimatedArmy.xml

@@ -0,0 +1,273 @@
+<?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:Camera/>
+        <c:Listener/>
+        <c:Transform>
+          <Position X="4.52910185" Y="5.50171423" Z="7.69566345"/>
+          <Orientation X="-0.453785568" Y="0.436270237" Z="-1.03594937e-06"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/dummyscene.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="-0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/animtest.</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.0966923237" Y="1.2939688" Z="0.399702221"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/animTest.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="1.31816244" Z="1.1888907"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/animTest.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="0.708824873" Y="1.30000007" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/animTest.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="1.36948848" Y="1.20000005" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:DirectionalLight>
+          <Intensity>0.13000047206878662</Intensity>
+        </c:DirectionalLight>
+        <c:Transform>
+          <Position X="0" Y="2.77622533" Z="0"/>
+          <Orientation X="0" Y="1.30900002" Z="1.73600006"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.30000001192092896</Speed>
+          <Axis X="0" Y="5" Z="0"/>
+        </c:RaptorCopter>
+        <c:Transform>
+          <Orientation X="117.03714" Y="3023.50244" Z="3.03297734"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="1" G="1" R="0"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="1" Z="1.29999995"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0" G="1" R="0"/>
+              <Radius>5</Radius>
+              <Intensity>0.80000001192092896</Intensity>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="1" Z="-1.29999995"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="1" G="0" R="0.478431374"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="-1.30000007" Y="1" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0" G="1" R="1"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="1.29999995" Y="1" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:RaptorCopter>
+          <Speed>0.50999981164932251</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
+        <c:Transform>
+          <Position X="0" Y="-0.100000001" Z="0"/>
+          <Orientation X="0" Y="191.457993" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0.301960796" G="0.0901960805" R="0.247058824"/>
+              <Radius>5</Radius>
+              <Intensity>5</Intensity>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="3" Z="5"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0.960784316" G="1" R="0"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="3" Z="-7.66608238"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0.00784313772" G="1" R="1"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="-3.47176075" Y="3" Z="-8.09415054"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0" G="0" R="1"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="-9.50536728" Y="2" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="1" G="0" R="1"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="3" Z="4.40877533"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0.431372553" G="0.0745098069" R="1"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="5.83008432" Y="3" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0" G="0.623529434" R="0.929411769"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="3.72500014" Y="3" Z="-4.26100016"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="0" Y="3" Z="-7.50000048"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:PointLight>
+              <Color A="1" B="0.192156866" G="1" R="0"/>
+              <Radius>5</Radius>
+            </c:PointLight>
+            <c:Transform>
+              <Position X="-5.90153885" Y="3" Z="-5.40681458"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/CaptureTest.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.obj</Resource>
+          <Resource>../assets/Models/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.196078435" R="0.196078435"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/CollidableCube.xml

@@ -0,0 +1,15 @@
+<?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:Collidable/>
+    <c:Model>
+      <Resource>Models/Core/UnitCube.obj</Resource>
+    </c:Model>
+    <c:Transform/>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/CollisionTest1.xml

@@ -24,7 +24,7 @@
           <Static>false</Static>
         </c:Collidable>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="1" R="0"/>
         </c:Model>
         <c:Transform>

resources/Schema/Entities/CollisionTestLevel.xml

@@ -6,7 +6,7 @@
 			<Orientation X="0" Y="0" Z="0"/>
 		</c:Transform>
 		<c:Model>
-			<Resource>Models/DummyScene.obj</Resource>
+			<Resource>Models/DummyScene.mesh</Resource>
 		</c:Model>
 	</Components>
 	<Children>
@@ -17,7 +17,7 @@
 					<Scale X="1" Y="1" Z="1"/>
 				</c:Transform>
 				<c:Model>
-					<Resource>Models/Core/UnitSphere.obj</Resource>
+					<Resource>Models/Core/UnitSphere.mesh</Resource>
 				</c:Model>
 			</Components>
 		</Entity>
@@ -28,7 +28,7 @@
 					<Scale X="2" Y="2" Z="2"/>
 				</c:Transform>
 				<c:Model>
-					<Resource>Models/RotationWidgetX.obj</Resource>
+					<Resource>Models/RotationWidgetX.mesh</Resource>
 				</c:Model>
 				<c:Trigger>
 				</c:Trigger>
@@ -43,7 +43,7 @@
 					<Position X="2.5"/>
 				</c:Transform>
 				<c:Model>
-					<Resource>Models/Core/UnitCube.obj</Resource>
+					<Resource>Models/Core/UnitCube.mesh</Resource>
 				</c:Model>
 				<c:AABB>
 				</c:AABB>
@@ -69,7 +69,7 @@
 							<Orientation X="0.0" Y="0" Z="1.0"/>
 						</c:Transform>
 						<c:Model>
-							<Resource>Models/Core/UnitRaptor.obj</Resource>
+							<Resource>Models/Core/UnitRaptor.mesh</Resource>
 							<Color R="1" G="0.4" B="0.8"/>
 						</c:Model>
 					</Components>
@@ -94,7 +94,7 @@
 											<Orientation X="0" Y="0" Z="0"/>
 										</c:Transform>
 										<c:Model>
-											<Resource>Models/Core/UnitCube.obj</Resource>
+											<Resource>Models/Core/UnitCube.mesh</Resource>
 											<Color R="1" G="0.4" B="0.8"/>
 										</c:Model>
 									</Components>
@@ -107,7 +107,7 @@
 											<Orientation X="0" Y="1.57" Z="0"/>
 										</c:Transform>
 										<c:Model>
-											<Resource>Models/Core/UnitCube.obj</Resource>
+											<Resource>Models/Core/UnitCube.mesh</Resource>
 											<Color R="1" G="0.4" B="0.8"/>
 										</c:Model>
 									</Components>

resources/Schema/Entities/EditorTestWorld.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Scale X="100" Y="1" Z="100"/>
@@ -58,7 +58,7 @@
       <Components>
         <c:DirectionalLight/>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.obj</Resource>
+          <Resource>Models/DirectionalLightWidget.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="2.1529963" Y="6.59221172" Z="0.169116676"/>
@@ -70,7 +70,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Assault.obj</Resource>
+          <Resource>Models/Assault.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="-2.00568962" Y="0.527161121" Z="0"/>
@@ -94,7 +94,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Core/UnitSphere.obj</Resource>
+          <Resource>Models/Core/UnitSphere.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="0" Y="3.70000029" Z="0"/>

resources/Schema/Entities/EditorWidgetRotate.xml

@@ -18,7 +18,7 @@
           <Axis X="1" Y="0" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/RotationWidgetX.obj</Resource>
+          <Resource>Models/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.obj</Resource>
+          <Resource>Models/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.obj</Resource>
+          <Resource>Models/RotationWidgetZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>

resources/Schema/Entities/EditorWidgetScale.xml

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

resources/Schema/Entities/EditorWidgetTranslate.xml

@@ -3,7 +3,7 @@
 
   <Components>
     <c:Model>
-      <Resource>Models/TranslationWidgetOrigin.obj</Resource>
+      <Resource>Models/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.obj</Resource>
+          <Resource>Models/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.obj</Resource>
+          <Resource>Models/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.obj</Resource>
+          <Resource>Models/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.obj</Resource>
+          <Resource>Models/WidgetPlaneX.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.obj</Resource>
+          <Resource>Models/WidgetPlaneY.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -78,7 +78,7 @@
           <Axis X="1" Y="1" Z="0"/>
         </c:EditorWidget>
         <c:Model>
-          <Resource>Models/WidgetPlaneZ.obj</Resource>
+          <Resource>Models/WidgetPlaneZ.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>

resources/Schema/Entities/Empty.xml

@@ -5,6 +5,16 @@
     <c:Transform/>
   </Components>
 
+  <Children>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource></Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
       <Children/>
+    </Entity>
+  </Children>
 
 </Entity>

resources/Schema/Entities/Model.xml

@@ -0,0 +1,30 @@
+<?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:Camera/>
+        <c:Listener/>
+        <c:Transform>
+          <Orientation X="0" Y="-0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource>models/animTest.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Entities/MovementTest.xml

@@ -6,66 +6,178 @@
   </Components>
 
   <Children>
-    <Entity>
-      <Components>
-        <c:Camera/>
-        <c:Transform/>
-      </Components>
-      <Children/>
-    </Entity>
-    <Entity>
+    <Entity name="Ground">
       <Components>
         <c:AABB/>
         <c:Collidable/>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0.513725519" G="0" R="1"/>
+          <Visible>false</Visible>
         </c:Model>
         <c:Transform>
-          <Position X="0" Y="2" Z="0"/>
-          <Scale X="5" Y="1" Z="5"/>
+          <Position X="7" Y="-0.727000058" Z="-1.22800004"/>
+          <Scale X="50" Y="1.45100009" Z="50"/>
         </c:Transform>
       </Components>
       <Children/>
     </Entity>
-    <Entity name="Player">
+    <Entity name="RedSpawn">
       <Components>
-        <c:AABB>
-          <Origin X="0" Y="0.773000062" Z="0"/>
-          <Size X="1" Y="1.60000002" Z="1"/>
-        </c:AABB>
-        <c:Collidable/>
-        <c:Physics/>
-        <c:Model>
-          <Resource>Models/Assault.obj</Resource>
-          <Color A="1" B="1" G="0" R="0"/>
-        </c:Model>
-        <c:Player/>
+        <c:PlayerSpawn/>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Red/>
+          </Team>
+        </c:Team>
         <c:Transform>
-          <Position X="0" Y="2.52699995" Z="0.0542778969"/>
+          <Position X="0.300000012" Y="0.0270000007" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Model>
+              <Resource>Models/Assault.mesh</Resource>
+              <Color A="1" B="0" G="0" R="1"/>
+            </c:Model>
+            <c:Transform>
+              <Position X="0.800000012" Y="0" Z="0"/>
             </c:Transform>
           </Components>
           <Children/>
         </Entity>
         <Entity>
           <Components>
-        <c:AABB/>
-        <c:Collidable/>
-        <c:Physics>
-          <Velocity X="0" Y="-0.0934068039" Z="0"/>
-        </c:Physics>
+            <c:SpawnPoint/>
             <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
-          <Color A="1" B="0" G="1" R="1"/>
+              <Resource>Models/Assault.mesh</Resource>
+              <Color A="1" B="0.0117647061" G="0" R="1"/>
             </c:Model>
-        <c:Player/>
             <c:Transform>
-          <Position X="0" Y="4.15580511" Z="0"/>
-          <Scale X="0.704558551" Y="0.115156889" Z="1"/>
+              <Position X="-0.600000024" Y="0" Z="0"/>
             </c:Transform>
           </Components>
           <Children/>
         </Entity>
       </Children>
+    </Entity>
+    <Entity name="DirectionalLight">
+      <Components>
+        <c:DirectionalLight/>
+        <c:Model>
+          <Resource>Models/DirectionalLightWidget.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Position X="-6.00145912" Y="1.42697716" Z="3.04144025"/>
+          <Orientation X="5.69400024" Y="841.179565" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="ObstacleCourse">
+      <Components>
+        <c:Model>
+          <Resource>Models/Test/ObstacleCourse.mesh</Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="ObstacleCoursePlayerBox">
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="6.32800007" Y="0.807000041" Z="-2.2750001"/>
+          <Scale X="1" Y="1.60000002" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="ObstacleCourse1uHigh">
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="9.11900043" Y="0.5" Z="-2.10900021"/>
+          <Scale X="1" Y="1" Z="8.1960001"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="ObstacleCourseWhoTheFuckKnows">
+      <Components>
+        <c:AABB/>
+        <c:Collidable/>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="13.2370005" Y="1.28600001" Z="-1.71700013"/>
+          <Scale X="2.58000016" Y="2.58300018" Z="21.1860008"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="BlueSpawn">
+      <Components>
+        <c:PlayerSpawn/>
+        <c:Spawner>
+          <EntityFile>Schema/Entities/Player.xml</EntityFile>
+        </c:Spawner>
+        <c:Team>
+          <Team>
+            <Blue/>
+          </Team>
+        </c:Team>
+        <c:Transform>
+          <Position X="0.300000012" Y="0.0270000007" Z="6.67400026"/>
+          <Orientation X="0" Y="3.20700026" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Model>
+              <Resource>Models/Assault.mesh</Resource>
+              <Color A="1" B="1" G="0.254901975" R="0"/>
+            </c:Model>
+            <c:Transform>
+              <Position X="0.800000012" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity>
+          <Components>
+            <c:SpawnPoint/>
+            <c:Model>
+              <Resource>Models/Assault.mesh</Resource>
+              <Color A="1" B="1" G="0.254901975" R="0"/>
+            </c:Model>
+            <c:Transform>
+              <Position X="-0.600000024" Y="0" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
 
 </Entity>

resources/Schema/Entities/OctreeTest.xml

@@ -11,7 +11,7 @@
         <c:AABB/>
         <c:Collidable/>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0" R="0"/>
         </c:Model>
         <c:Transform>
@@ -27,7 +27,7 @@
           <Static>false</Static>
         </c:Collidable>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="0" R="1"/>
         </c:Model>
         <c:Transform>
@@ -42,7 +42,7 @@
           <Static>false</Static>
         </c:Collidable>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="1" R="0"/>
         </c:Model>
         <c:Transform>

resources/Schema/Entities/Player.xml

@@ -2,17 +2,120 @@
 <Entity name="Player" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
-    <c:AABB/>
-    <c:Physics/>
+    <c:AABB>
+      <Origin X="0" Y="0.772000015" Z="0"/>
+      <Size X="1" Y="1.60000002" Z="1"/>
+    </c:AABB>
     <c:Collidable/>
-    <c:Model>
-      <Resource>Models/Core/UnitSphere.obj</Resource>
-      <Color A="1" B="1" G="0" R="0"/>
-    </c:Model>
-    <c:Player/>
-    <c:Transform/>
+    <c:Model/>
+    <c:Physics>
+      <Velocity X="8.33307467e-09" Y="0" Z="9.82836834e-09"/>
+    </c:Physics>
+    <c:Player>
+      <MovementSpeed>5</MovementSpeed>
+    </c:Player>
+    <c:Team>
+      <Team>
+        <Red/>
+      </Team>
+    </c:Team>
+    <c:Transform>
+      <Position X="2.84928203" Y="0.0264999866" Z="7.31610918"/>
+      <Orientation X="0" Y="2.14675093" Z="0"/>
+    </c:Transform>
   </Components>
 
+  <Children>
+    <Entity name="Camera">
+      <Components>
+        <c:Camera/>
+        <c:Transform>
+          <Position X="0" Y="1.37700009" Z="0"/>
+          <Orientation X="0.921535373" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="PlayerName">
+          <Components>
+            <c:Text>
+              <Resource>Fonts/DroidSans.ttf,100</Resource>
+              <Color A="1" B="0" G="1" R="0"/>
+              <Visible>false</Visible>
+            </c:Text>
+            <c:Transform>
+              <Position X="0" Y="0.247910097" Z="-0.447844714"/>
+              <Scale X="0.100000001" Y="0.113000005" Z="0.5"/>
+              <Orientation X="0" Y="3.14199996" Z="0"/>
+            </c:Transform>
+          </Components>
           <Children/>
+        </Entity>
+        <Entity name="CameraModel">
+          <Components>
+            <c:Model>
+              <Resource>Models/Camera.mesh</Resource>
+            </c:Model>
+            <c:Transform>
+              <Position X="0" Y="0.0331346765" Z="-0.0792061687"/>
+              <Scale X="1.30000007" Y="1.50000012" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+    <Entity name="ThirdPersonCamera">
+      <Components>
+        <c:Camera/>
+        <c:Model>
+          <Resource>Models/Camera.mesh</Resource>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="-0.284000009" Y="1.83800006" Z="1.18900001"/>
+          <Orientation X="5.95600033" Y="0" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="PlayerModel">
+      <Components>
+        <c:Model>
+          <Resource>Models/AssaultHeadless.mesh</Resource>
+        </c:Model>
+        <c:Transform>
+          <Orientation X="0" Y="3.14159274" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="AABBStanding">
+      <Components>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Color A="0.427450985" B="1" G="1" R="1"/>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0.772000015" Z="0"/>
+          <Scale X="1" Y="1.60000002" Z="1"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity name="AABBCrouching">
+      <Components>
+        <c:Model>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
+          <Color A="0.745098054" B="1" G="0" R="1"/>
+          <Visible>false</Visible>
+        </c:Model>
+        <c:Transform>
+          <Position X="0" Y="0.772000015" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
 
 </Entity>

resources/Schema/Entities/RaptorCopter.xml

@@ -7,7 +7,7 @@
 			<Orientation X="0.0" Y="0" Z="0.0"/>
 		</c:Transform>
 		<c:Model>
-			<Resource>Models/Core/UnitRaptor.obj</Resource>
+			<Resource>Models/Core/UnitRaptor.mesh</Resource>
 			<Color R="1" G="0.4" B="0.8"/>
 		</c:Model>
 	</Components>
@@ -31,7 +31,7 @@
 							<Scale X="0.1" Y="0.4" Z="0.1"/>
 						</c:Transform>
 						<c:Model>
-							<Resource>Models/Core/UnitCylinder.obj</Resource>
+							<Resource>Models/Core/UnitCylinder.mesh</Resource>
 							<Color R="1" G="0.4" B="0.8"/>
 						</c:Model>
 					</Components>
@@ -44,7 +44,7 @@
 							<Orientation X="0" Y="0" Z="0"/>
 						</c:Transform>
 						<c:Model>
-							<Resource>Models/Core/UnitCube.obj</Resource>
+							<Resource>Models/Core/UnitCube.mesh</Resource>
 							<Color R="1" G="0.4" B="0.8"/>
 						</c:Model>
 					</Components>
@@ -57,7 +57,7 @@
 							<Orientation X="0" Y="1.57" Z="0"/>
 						</c:Transform>
 						<c:Model>
-							<Resource>Models/Core/UnitCube.obj</Resource>
+							<Resource>Models/Core/UnitCube.mesh</Resource>
 							<Color R="1" G="0.4" B="0.8"/>
 						</c:Model>
 					</Components>

resources/Schema/Entities/RenderingWorld.xml

@@ -35,7 +35,7 @@
               <FOV>80</FOV>
             </c:Camera>
             <c:Model>
-              <Resource>Models/Camera.obj</Resource>
+              <Resource>Models/Camera.mesh</Resource>
             </c:Model>
             <c:Transform>
               <Position X="0" Y="1.39121652" Z="-0.043014247"/>
@@ -58,70 +58,16 @@
                       <Color A="0" B="0.659900069" G="0" R="0.340099931"/>
                     </c:Fill>
                     <c:Model>
-                      <Resource>Models/Core/UnitHexagon.obj</Resource>
+                      <Resource>Models/Core/UnitHexagon.mesh</Resource>
                       <Color A="0.313725501" B="0.70588237" G="0.70588237" R="0.70588237"/>
                     </c:Model>
                     <c:Transform>
-                      <Position X="-0.287027329" Y="-0.282350302" Z="-1.52214652e-05"/>
+                      <Position X="-0.285538822" Y="-0.282350302" Z="-1.52214652e-05"/>
                       <Scale X="0.200000003" Y="0.200000003" Z="0.5"/>
                       <Orientation X="0" Y="0.666000009" Z="0"/>
                     </c:Transform>
                   </Components>
                   <Children>
-                    <Entity name="Hexagon2">
-                      <Components>
-                        <c:Model>
-                          <Resource>Models/Core/UnitHexagon.obj</Resource>
-                          <Color A="0.392156869" B="1" G="1" R="1"/>
-                        </c:Model>
-                        <c:Transform>
-                          <Position X="0.120033145" Y="0.0776480734" Z="-1.56768795e-06"/>
-                          <Scale X="0.5" Y="0.5" Z="0.5"/>
-                        </c:Transform>
-                      </Components>
-                      <Children>
-                        <Entity name="SelectedWeaponUI">
-                          <Components>
-                            <c:Model>
-                              <Resource>Models/SecondaryWeapon.fbx</Resource>
-                              <Color A="0.423529416" B="1" G="3.92156863" R="1"/>
-                            </c:Model>
-                            <c:Transform>
-                              <Position X="-0.00400000019" Y="0.0138316695" Z="0.00813383237"/>
-                              <Scale X="2" Y="2" Z="1"/>
-                            </c:Transform>
-                          </Components>
-                          <Children/>
-                        </Entity>
-                      </Children>
-                    </Entity>
-                    <Entity name="Hexagon3">
-                      <Components>
-                        <c:Model>
-                          <Resource>Models/Core/UnitHexagon.obj</Resource>
-                          <Color A="0.392156869" B="1" G="1" R="1"/>
-                        </c:Model>
-                        <c:Transform>
-                          <Position X="0.119999997" Y="-0.0780000016" Z="0"/>
-                          <Scale X="0.5" Y="0.5" Z="0.5"/>
-                        </c:Transform>
-                      </Components>
-                      <Children>
-                        <Entity name="UnselectedWeaponUI">
-                          <Components>
-                            <c:Model>
-                              <Resource>Models/SecondaryWeapon.fbx</Resource>
-                              <Color A="0.466666669" B="0" G="0" R="0"/>
-                            </c:Model>
-                            <c:Transform>
-                              <Position X="-0.00400000019" Y="0.0136327185" Z="0.00800000038"/>
-                              <Scale X="2" Y="2" Z="1"/>
-                            </c:Transform>
-                          </Components>
-                          <Children/>
-                        </Entity>
-                      </Children>
-                    </Entity>
                     <Entity name="Ammo">
                       <Components>
                         <c:Text>
@@ -165,25 +111,6 @@
                   </Components>
                   <Children/>
                 </Entity>
-                <Entity>
-                  <Components>
-                    <c:HealthHUD/>
-                    <c:Fill>
-                      <Percentage>0.65990006923675537</Percentage>
-                      <Color A="0" B="0.659900069" G="0" R="0.340099931"/>
-                    </c:Fill>
-                    <c:Model>
-                      <Resource>Models/Core/UnitRaptor.obj</Resource>
-                      <Color A="0.678431392" B="3.92156863" G="3.92156863" R="3.92156863"/>
-                    </c:Model>
-                    <c:Transform>
-                      <Position X="0" Y="-0.118439019" Z="-0.165149197"/>
-                      <Scale X="0.100000001" Y="1" Z="0.200000003"/>
-                      <Orientation X="1.42800009" Y="1.61800003" Z="0"/>
-                    </c:Transform>
-                  </Components>
-                  <Children/>
-                </Entity>
               </Children>
             </Entity>
           </Children>
@@ -193,7 +120,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Core/UnitPlane.obj</Resource>
+          <Resource>Models/Core/UnitPlane.mesh</Resource>
         </c:Model>
         <c:Transform>
           <Position X="0" Y="-0.689623177" Z="0.600000024"/>
@@ -205,7 +132,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Assault.obj</Resource>
+          <Resource>Models/Assault.mesh</Resource>
           <Color A="1" B="3.92156863" G="1" R="1"/>
         </c:Model>
         <c:Transform>
@@ -234,7 +161,7 @@
           <Axis X="0.200000003" Y="3.4000001" Z="0.5"/>
         </c:RaptorCopter>
         <c:Transform>
-          <Orientation X="676.517334" Y="19246.6816" Z="1116.82788"/>
+          <Orientation X="758.058899" Y="20632.8691" Z="1320.68018"/>
         </c:Transform>
       </Components>
       <Children>
@@ -381,7 +308,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Assault.obj</Resource>
+          <Resource>Models/Assault.mesh</Resource>
           <Color A="1" B="1" G="1" R="3.92156863"/>
         </c:Model>
         <c:Transform>
@@ -397,7 +324,7 @@
           <Intensity>0.10000000149011612</Intensity>
         </c:DirectionalLight>
         <c:Model>
-          <Resource>Models/DirectionalLightWidget.obj</Resource>
+          <Resource>Models/DirectionalLightWidget.mesh</Resource>
           <Color A="1" B="0" G="3.92156863" R="3.92156863"/>
         </c:Model>
         <c:Transform>
@@ -410,7 +337,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="39.2156868" R="1"/>
         </c:Model>
         <c:Transform>

resources/Schema/Entities/ShootEventTest.xml

@@ -9,7 +9,7 @@
     <Entity>
       <Components>
         <c:Model>
-          <Resource>../assets/Models/DummyScene.obj</Resource>
+          <Resource>../assets/Models/DummyScene.mesh</Resource>
         </c:Model>
         <c:Transform/>
       </Components>
@@ -41,7 +41,7 @@
           <HomePointForTeam>3</HomePointForTeam>
         </c:CapturePoint>
         <c:Model>
-          <Resource>../assets/Models/Core/UnitSphere.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/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.obj</Resource>
+          <Resource>../assets/Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="0" G="0" R="4.5"/>
         </c:Model>
         <c:Player/>

resources/Schema/Entities/SoundTestLevel.xml

@@ -12,7 +12,7 @@
           <FilePath></FilePath>
         </c:SoundEmitter>
         <c:Model>
-          <Resource>Models/Core/UnitCube.obj</Resource>
+          <Resource>Models/Core/UnitCube.mesh</Resource>
           <Color A="1" B="1" G="0.58431375" R="0.43921569"/>
         </c:Model>
         <c:Transform/>

resources/Schema/Entities/SpawnTest.xml

@@ -24,7 +24,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Core/UnitSphere.obj</Resource>
+              <Resource>Models/Core/UnitSphere.mesh</Resource>
             </c:Model>
             <c:Transform>
               <Position X="0" Y="0" Z="1.26689196"/>
@@ -37,7 +37,7 @@
           <Components>
             <c:SpawnPoint/>
             <c:Model>
-              <Resource>Models/Core/UnitSphere.obj</Resource>
+              <Resource>Models/Core/UnitSphere.mesh</Resource>
             </c:Model>
             <c:Transform>
               <Position X="0" Y="0" Z="-1.14786315"/>

resources/Schema/Entities/Test.xml

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

resources/Schema/Types.xsd

@@ -16,6 +16,9 @@
 	<xs:simpleType name="double">
 		<xs:restriction base="xs:decimal"></xs:restriction>
 	</xs:simpleType>
+	<xs:simpleType name="float">
+		<xs:restriction base="xs:decimal"></xs:restriction>
+	</xs:simpleType>
 	<xs:simpleType name="string">
 		<xs:restriction base="xs:string"></xs:restriction>
 	</xs:simpleType>

resources/Shaders/BasicForward.vert.glsl

@@ -9,18 +9,14 @@ 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 DiffuseVertexColor;
-layout(location = 6) in vec4 SpecularVertexColor;
-layout(location = 7) in vec4 BoneIndices1;
-layout(location = 8) in vec4 BoneIndices2;
-layout(location = 9) in vec4 BoneWeights1;
-layout(location = 10) in vec4 BoneWeights2;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
 
 out VertexData{
 	vec3 Position;
 	vec3 Normal;
 	vec2 TextureCoordinate;
-	vec4 DiffuseColor;
 }Output;
 
 void main()
@@ -30,5 +26,4 @@ void main()
 	Output.Position = Position;
 	Output.TextureCoordinate = TextureCoords;
 	Output.Normal = Normal;
-	Output.DiffuseColor = DiffuseVertexColor;
 }

resources/Shaders/ForwardPlus.frag.glsl

@@ -4,6 +4,7 @@ uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
 uniform vec4 Color;
+uniform vec4 DiffuseColor;
 uniform vec2 ScreenDimensions;
 uniform vec4 FillColor;
 uniform float FillPercentage;
@@ -49,7 +50,6 @@ in VertexData{
 	vec3 Position;
 	vec3 Normal;
 	vec2 TextureCoordinate;
-	vec4 DiffuseColor;
 }Input;
 
 out vec4 sceneColor;
@@ -138,7 +138,7 @@ void main()
 	}
 
 	//sceneColor += Input.DiffuseColor;
-	vec4 color_result = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color;
+	vec4 color_result = DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color;
 	
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;

resources/Shaders/ForwardPlus.vert.glsl

@@ -3,32 +3,37 @@
 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 DiffuseVertexColor;
-layout(location = 6) in vec4 SpecularVertexColor;
-layout(location = 7) in vec4 BoneIndices1;
-layout(location = 8) in vec4 BoneIndices2;
-layout(location = 9) in vec4 BoneWeights1;
-layout(location = 10) in vec4 BoneWeights2;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
 
 out VertexData{
 	vec3 Position;
 	vec3 Normal;
 	vec2 TextureCoordinate;
-	vec4 DiffuseColor;
 }Output;
 
 void main()
 {
-	gl_Position = P*V*M * vec4(Position, 1.0);
 
-	Output.Position = Position;
+
+	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.DiffuseColor = DiffuseVertexColor;
 }

src/Engine/Collision/CollisionSystem.cpp

@@ -31,7 +31,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         }
         if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             (glm::vec3&)cTransform["Position"] += resolutionVector;
-            cPhysics["Velocity"] = glm::vec3(0, 0, 0);
+            ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
         }
     }
 

src/Engine/Core/EntityWrapper.cpp

@@ -5,6 +5,9 @@ const EntityWrapper EntityWrapper::Invalid = EntityWrapper(nullptr, EntityID_Inv
 
 bool EntityWrapper::HasComponent(const std::string& componentName)
 {
+    if (!Valid()) {
+        return false;
+    }
     return World->HasComponent(ID, componentName);
 }
 
@@ -17,6 +20,34 @@ EntityWrapper EntityWrapper::Parent()
     }
 }
 
+EntityWrapper EntityWrapper::FirstChildByName(const std::string& name)
+{
+    auto itPair = this->World->GetChildren(this->ID);
+    if (itPair.first == itPair.second) {
+        return EntityWrapper::Invalid;
+    }
+
+    for (auto it = itPair.first; it != itPair.second; ++it) {
+        if (this->World->GetName(it->second) == name) {
+            return EntityWrapper(this->World, it->second);
+        }
+    }
+
+    return EntityWrapper::Invalid;
+}
+
+bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
+{
+    EntityWrapper entity = *this;
+    while (entity.Parent().Valid()) {
+        entity = entity.Parent();
+        if (entity == potentialParent) {
+            return true;
+        }
+    }
+    return false;
+}
+
 bool EntityWrapper::Valid()
 {
     if (this->World == nullptr) {

src/Engine/Core/Octree.cpp

@@ -276,7 +276,7 @@ std::vector<int> Child::childIndicesContainingBox(const AABB& box) const
     }
 }
 
-inline bool Child::hasChildren() const
+bool Child::hasChildren() const
 {
     return m_Children[0] != nullptr;
 }

src/Engine/Core/Transform.cpp

@@ -1,5 +1,10 @@
 #include "Core/Transform.h"
 
+glm::vec3 Transform::AbsolutePosition(EntityWrapper entity)
+{
+    return AbsolutePosition(entity.World, entity.ID);
+}
+
 glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
 {
     glm::vec3 position;
@@ -14,6 +19,11 @@ glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
     return position;
 }
 
+glm::quat Transform::AbsoluteOrientation(EntityWrapper entity)
+{
+    return AbsoluteOrientation(entity.World, entity.ID);
+}
+
 glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
 {
     glm::quat orientation;
@@ -27,6 +37,11 @@ glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
     return orientation;
 }
 
+glm::vec3 Transform::AbsoluteScale(EntityWrapper entity)
+{
+    return AbsoluteScale(entity.World, entity.ID);
+}
+
 glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
 {
     glm::vec3 scale(1.f);
@@ -40,6 +55,11 @@ glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
     return scale;
 }
 
+glm::mat4 Transform::ModelMatrix(EntityWrapper entity)
+{
+    return ModelMatrix(entity.ID, entity.World);
+}
+
 glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
 {
     glm::vec3 position = Transform::AbsolutePosition(world, entity);

src/Engine/Editor/EditorRenderSystem.cpp

@@ -39,7 +39,7 @@ void EditorRenderSystem::Update(double dt)
                 continue;
             } catch (const std::exception&) {
                 try {
-                    model = ResourceManager::Load<::Model>("Models/Core/Error.obj");
+                    model = ResourceManager::Load<::Model>("Models/Core/Error.mesh");
                 } catch (const std::exception&) {
                     continue;
                 }

src/Engine/Editor/EditorSystem.cpp

@@ -14,10 +14,11 @@ EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* re
     m_EditorWorldSystemPipeline->AddSystem<EditorWidgetSystem>(0, m_Renderer);
     m_EditorWorldSystemPipeline->AddSystem<EditorRenderSystem>(1, m_Renderer, m_RenderFrame);
     
-    m_Camera = importEntity(EntityWrapper(m_EditorWorld, EntityID_Invalid), "Schema/Entities/Empty.xml");
-    m_EditorWorld->AttachComponent(m_Camera.ID, "Transform");
-    m_EditorWorld->AttachComponent(m_Camera.ID, "Camera");
-    m_DebugCameraInputController = new DebugCameraInputController<EditorSystem>(m_EventBroker, -1);
+    m_EditorCamera = importEntity(EntityWrapper(m_EditorWorld, EntityID_Invalid), "Schema/Entities/Empty.xml");
+    m_ActualCamera = m_EditorCamera;
+    m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Transform");
+    m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Camera");
+    m_EditorCameraInputController = new EditorCameraInputController<EditorSystem>(m_EventBroker, -1);
 
     m_EditorGUI = new EditorGUI(m_World, m_EventBroker);
     m_EditorGUI->SetEntitySelectedCallback(std::bind(&EditorSystem::OnEntitySelected, this, std::placeholders::_1));
@@ -33,38 +34,70 @@ EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* re
 
     EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorSystem::OnMousePress);
     EVENT_SUBSCRIBE_MEMBER(m_EWidgetDelta, &EditorSystem::OnWidgetDelta);
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &EditorSystem::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &EditorSystem::OnSetCamera);
 
     m_EditorStats = new EditorStats();
 
-    Events::SetCamera e;
-    e.CameraEntity = m_Camera;
-    m_EventBroker->Publish(e);
+    if (m_Enabled) {
+        Enable();
+    }
 }
 
 EditorSystem::~EditorSystem()
 {
     delete m_EditorStats;
     delete m_EditorGUI;
-    delete m_DebugCameraInputController;
+    delete m_EditorCameraInputController;
     delete m_EditorWorldSystemPipeline;
     delete m_EditorWorld;
 }
 
 void EditorSystem::Update(double dt)
 {
+    double now = glfwGetTime();
+    double actualDelta = now - m_LastTime;
+    m_LastTime = now;
+
+    if (m_Enabled) {
         m_EventBroker->Process<EditorGUI>();
         m_EditorGUI->Draw();
-    m_EditorStats->Draw(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);
         }
 
-    m_EditorWorldSystemPipeline->Update(dt);
+        m_EditorWorldSystemPipeline->Update(actualDelta);
 
-    m_DebugCameraInputController->Update(dt);
-    m_Camera["Transform"]["Position"] = m_DebugCameraInputController->Position();
-    m_Camera["Transform"]["Orientation"] = glm::eulerAngles(m_DebugCameraInputController->Orientation());
+        ComponentWrapper& cameraTransform = m_EditorCamera["Transform"];
+        glm::vec3& ori = cameraTransform["Orientation"];
+        ori.x = m_EditorCameraInputController->Rotation().x;
+        ori.y = m_EditorCameraInputController->Rotation().y;
+        glm::vec3& pos = cameraTransform["Position"];
+        pos += m_EditorCameraInputController->Movement() * glm::inverse(glm::quat(ori)) * (float)actualDelta;
+    }
+}
+
+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);
+    m_Enabled = true;
+}
+
+void EditorSystem::Disable()
+{
+    m_EditorCameraInputController->Disable();
+    m_EventBroker->Publish(Events::LockMouse());
+    Events::SetCamera e;
+    e.CameraEntity = m_ActualCamera;
+    m_EventBroker->Publish(e);
+    m_Enabled = false;
 }
 
 void EditorSystem::OnEntitySelected(EntityWrapper entity)
@@ -148,6 +181,33 @@ bool EditorSystem::OnWidgetDelta(const Events::WidgetDelta& e)
     return true;
 }
 
+bool EditorSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    if (e.PlayerID != -1) {
+        return false;
+    }
+
+    if (e.Command == "ToggleEditor" && e.Value > 0) {
+        if (m_Enabled) {
+            Disable();
+        } else {
+            Enable();
+        }
+    }
+    return true;
+}
+
+bool EditorSystem::OnSetCamera(const Events::SetCamera& e)
+{
+    if (m_Enabled && e.CameraEntity != m_EditorCamera) {
+        m_ActualCamera = e.CameraEntity;
+        Events::SetCamera e2;
+        e2.CameraEntity = m_EditorCamera;
+        m_EventBroker->Publish(e2);
+    }
+    return true;
+}
+
 EntityWrapper EditorSystem::importEntity(EntityWrapper parent, boost::filesystem::path filePath)
 {
     if (parent.World == nullptr) {

src/Engine/Network/Client.cpp

@@ -5,14 +5,20 @@ using namespace boost::asio::ip;
 
 Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 {
+    Network::initialize();
+
     // Asumes root node is EntityID 0
     insertIntoServerClientMaps(0, 0);
+    // Init timer
+    m_TimeSinceSentInputs = std::clock();
     // Default is local host
     std::string address = config->Get<std::string>("Networking.Address", "127.0.0.1");
     int port = config->Get<int>("Networking.Port", 13);
     m_ReceiverEndpoint = udp::endpoint(boost::asio::ip::address::from_string(address), port);
     // Set up network stream
     m_PlayerName = config->Get<std::string>("Networking.Name", "Raptorcopter");
+    m_SendInputIntervalMs = config->Get<int>("Networking.SendInputIntervalMs", 33);
+
 }
 
 Client::~Client()
@@ -37,19 +43,24 @@ void Client::Update()
     readFromServer();
     if (m_IsConnected) {
         hasServerTimedOut();
+        // Don't sent 1 input in 1 packet, bunch em up.
+        if (m_SendInputIntervalMs < (1000 * (std::clock() - m_TimeSinceSentInputs) / (double)CLOCKS_PER_SEC)) {
+            sendInputCommands();
+            m_TimeSinceSentInputs = std::clock();
         }
+    }
+    Network::Update();
 }
 
 void Client::readFromServer()
 {
     while (m_Socket.available()) {
-        bytesRead = receive(readBuf, INPUTSIZE);
+        bytesRead = receive(readBuf);
         if (bytesRead > 0) {
             Packet packet(readBuf, bytesRead);
             parseMessageType(packet);
         }
     }
-    sendInputCommands();
 }
 
 void Client::parseMessageType(Packet& packet)
@@ -66,12 +77,9 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::Connect:
         parseConnect(packet);
         break;
-    case MessageType::ClientPing:
+    case MessageType::Ping:
         parsePing();
         break;
-    case MessageType::ServerPing:
-        parseServerPing();
-        break;
     case MessageType::Message:
         break;
     case MessageType::Snapshot:
@@ -81,6 +89,13 @@ void Client::parseMessageType(Packet& packet)
         break;
     case MessageType::PlayerConnected:
         parsePlayerConnected(packet);
+        break;
+    case MessageType::Kick:
+        parseKick();
+        break;
+    case MessageType::OnPlayerSpawned:
+        parsePlayersSpawned(packet);
+        break;
     default:
         break;
     }
@@ -99,11 +114,6 @@ void Client::parsePlayerConnected(Packet & packet)
 }
 
 void Client::parsePing()
-{
-
-}
-
-void Client::parseServerPing()
 {
     // Might miss connect message so set it here instead.
     m_IsConnected = true;
@@ -112,11 +122,26 @@ void Client::parseServerPing()
     LOG_INFO("%i: response time with ctime(ms): %f", m_PacketID, m_DurationOfPingTime);
     m_StartPingTime = std::clock();
 
-    Packet packet(MessageType::ServerPing, m_SendPacketID);
+    Packet packet(MessageType::Ping, m_SendPacketID);
     packet.WriteString("Ping recieved");
     send(packet);
 }
 
+void Client::parseKick()
+{ 
+    LOG_WARNING("You have been kicked from the server.");
+    m_IsConnected = false;
+}
+
+void Client::parsePlayersSpawned(Packet& packet)
+{ 
+    Events::PlayerSpawned e;
+    e.Player = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
+    e.Spawner = EntityWrapper(m_World, m_ServerIDToClientID[packet.ReadPrimitive<EntityID>()]);
+    e.PlayerID = -1;
+    m_EventBroker->Publish(e);
+}
+
 // Fields with strings will not work right now
 void Client::InterpolateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
 {
@@ -153,8 +178,12 @@ void Client::parseSnapshot(Packet& packet)
 {
     std::string componentType = packet.ReadString();
     while (packet.DataReadSize() < packet.Size()) {
+        // HACK
+        std::string entityName = packet.ReadString();
         // Components EntityID
         EntityID receivedEntityID = packet.ReadPrimitive<EntityID>();
+        // HACK
+        m_World->SetName(receivedEntityID, entityName);
         // Parents EntityID 
         EntityID receivedParentEntityID = packet.ReadPrimitive<EntityID>();
         ComponentInfo componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
@@ -211,15 +240,20 @@ void Client::parseSnapshot(Packet& packet)
     }
 }
 
-int Client::receive(char* data, size_t length)
+int Client::receive(char* data)
 {
     boost::system::error_code error;
 
     int bytesReceived = m_Socket.receive_from(boost
-        ::asio::buffer((void*)data, length),
+        ::asio::buffer((void*)data, INPUTSIZE),
         m_ReceiverEndpoint,
         0, error);
-
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += bytesReceived;
+        m_NetworkData.DataReceivedThisInterval += bytesReceived;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
     if (error) {
         //LOG_ERROR("receive: %s", error.message().c_str());
     }
@@ -232,6 +266,12 @@ void Client::send(Packet& packet)
         packet.Data(),
         packet.Size()),
         m_ReceiverEndpoint, 0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+        m_NetworkData.AmountOfMessagesSent++;
+    }
 }
 
 void Client::connect()
@@ -250,14 +290,6 @@ void Client::disconnect()
     send(packet);
 }
 
-void Client::ping()
-{
-    //Packet packet(MessageType::Connect, m_SendPacketID);
-    //packet.WriteString("Ping");
-    //m_StartPingTime = std::clock();
-    //send(packet);
-}
-
 bool Client::OnInputCommand(const Events::InputCommand & e)
 {
     if (e.Command == "ConnectToServer") { // Connect for now
@@ -275,6 +307,15 @@ bool Client::OnInputCommand(const Events::InputCommand & e)
         if (e.Value > 0) {
             becomePlayer();
         }
+    } else if (e.Command == "LogNetworkBandwidth") {
+        if (e.Value > 0) {
+            // Save to file if we no longer want to read data.
+            if (isReadingData) {
+                saveToFile();
+            }
+            isReadingData = !isReadingData;
+            m_SaveDataTimer = std::clock();
+        }
     } else {
         m_InputCommandBuffer.push_back(e);
         //LOG_DEBUG("Client::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
@@ -305,7 +346,7 @@ bool Client::hasServerTimedOut()
 {
     // Time in ms
     float timeSincePing = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
-    if (timeSincePing > TIMEOUTMS) {
+    if (timeSincePing > m_TimeoutMs) {
         // Clear everything and go to menu.
         LOG_INFO("Server has timed out, returning to menu, Beep Boop.");
         m_IsConnected = false;
@@ -319,7 +360,7 @@ EntityID Client::createPlayer()
     EntityID entityID = m_World->CreateEntity();
     ComponentWrapper transform = m_World->AttachComponent(entityID, "Transform");
     ComponentWrapper model = m_World->AttachComponent(entityID, "Model");
-    model["Resource"] = "Models/Core/UnitSphere.obj";
+    model["Resource"] = "Models/Core/UnitSphere.mesh";
     ComponentWrapper player = m_World->AttachComponent(entityID, "Player");
     return entityID;
 }

src/Engine/Network/Network.cpp

@@ -0,0 +1,68 @@
+#include "Network/Network.h"
+
+void Network::Update()
+{ 
+    updateNetworkData();
+}
+
+void Network::saveToFile()
+{
+    std::ofstream outfile;
+    time_t t = time(0);
+    // get time now
+    struct tm * now = localtime(&t);
+    // Get current time and date
+    std::string dateAndTime = "BandwidthData - " + std::to_string(now->tm_year + 1900) + '-'
+        + std::to_string(now->tm_mon + 1) + '-'
+        + std::to_string(now->tm_mday) + '_'
+        + std::to_string(now->tm_hour) + "h."
+        + std::to_string(now->tm_min) + "m."
+        + std::to_string(now->tm_sec) + 's';
+
+    outfile.open(dateAndTime + ".csv");
+    outfile << "Total time," + std::to_string(m_NetworkData.TotalTime) + "\n";
+    outfile << "Total data received," + std::to_string(m_NetworkData.TotalDataReceived) + "\n";
+    outfile << "Total data sent," + std::to_string(m_NetworkData.TotalDataSent) + "\n";
+    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);
+    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";
+    outfile << "Avarage data sents B/s: " + std::to_string(dataSentPerSec) + "\n";
+    
+    outfile << "time, avg receive B, avg send B\n";
+    for (int i = 0; i < m_NetworkData.BandwidthBytes.size(); i++) {
+        outfile << std::to_string(i) + ",";
+        outfile << std::to_string(m_NetworkData.BandwidthBytes[i].first) + ",";
+        outfile << std::to_string(m_NetworkData.BandwidthBytes[i].second) + "\n";
+    }
+    outfile.close();
+
+}
+
+void Network::updateNetworkData()
+{
+    std::clock_t currentTime = std::clock();
+    // Send snapshot
+    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));
+        // Reset interval stuff
+        m_SaveDataTimer = std::clock();
+        m_NetworkData.DataSentThisInterval = 0;
+        m_NetworkData.DataReceivedThisInterval = 0;
+    }
+}
+
+void Network::initialize()
+{ 
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_MaxConnections = config->Get<int>("Networking.MaxConnections", 8);
+    m_TimeoutMs = config->Get<int>("Networking.TimeoutMs", 20000);
+}

src/Engine/Network/Packet.cpp

@@ -39,6 +39,7 @@ void Packet::Init(MessageType type, unsigned int & packetID)
     Packet::WritePrimitive<int>(messageType);
     Packet::WritePrimitive<int>(packetID);
     packetID++;
+    m_HeaderSize = m_Offset;
 }
 
 void Packet::WriteString(const std::string& str)

src/Engine/Network/Server.cpp

@@ -1,7 +1,13 @@
 #include "Network/Server.h"
 
-Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 13))
-{ }
+Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 27666))
+{
+    Network::initialize();
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    snapshotInterval = 1000 * config->Get<float>("Networking.SnapshotInterval", 0.05);
+    pingIntervalMs = config->Get<float>("Networking.PingIntervalMs", 1000);
+
+}
 
 Server::~Server()
 {
@@ -14,7 +20,8 @@ void Server::Start(World* world, EventBroker* eventBroker)
     m_EventBroker = eventBroker;
     // Subscribe to events
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Server::OnInputCommand);
-    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Server::OnPlayerSpawned);
+    for (size_t i = 0; i < m_MaxConnections; i++) {
         m_PlayerDefinitions[i].StopTime = std::clock();
     }
     LOG_INFO("I am Server. BIP BOP\n");
@@ -24,14 +31,17 @@ void Server::Update()
 {
     readFromClients();
     m_EventBroker->Process<Server>();
-}
+    if (isReadingData) {
+        Network::Update();
+    }
 
+}
 
 void Server::readFromClients()
 {
     while (m_Socket.available()) {
         try {
-            bytesRead = receive(readBuffer, INPUTSIZE);
+            bytesRead = receive(readBuffer);
             Packet packet(readBuffer, bytesRead);
             parseMessageType(packet);
         } catch (const std::exception& err) {
@@ -46,7 +56,7 @@ void Server::readFromClients()
     }
 
     // Send pings each 
-    if (intervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
+    if (pingIntervalMs < (1000 * (currentTime - previousePingMessage) / (double)CLOCKS_PER_SEC)) {
         sendPing();
         previousePingMessage = currentTime;
     }
@@ -70,11 +80,8 @@ void Server::parseMessageType(Packet& packet)
     case MessageType::Connect:
         parseConnect(packet);
         break;
-    case MessageType::ClientPing:
-        //parseClientPing();
-        break;
-    case MessageType::ServerPing:
-        parseServerPing();
+    case MessageType::Ping:
+        parsePing();
         break;
     case MessageType::Message:
         break;
@@ -97,21 +104,47 @@ void Server::parseMessageType(Packet& packet)
     }
 }
 
-int Server::receive(char * data, size_t length)
+int Server::receive(char * data)
 {
-    length = m_Socket.receive_from(
+    unsigned int length = m_Socket.receive_from(
         boost::asio::buffer((void*)data
-            , length)
+            , INPUTSIZE)
         , m_ReceiverEndpoint, 0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataReceived += length;
+        m_NetworkData.DataReceivedThisInterval += length;
+        m_NetworkData.AmountOfMessagesReceived++;
+    }
     return length;
 }
 
-void Server::send(Packet& packet, int userID)
+void Server::send(Packet& packet, UserID user)
 {
     int bytesSent = m_Socket.send_to(
         boost::asio::buffer(packet.Data(), packet.Size()),
-        m_ConnectedUsers[userID].Endpoint,
+        m_ConnectedUsers[user].Endpoint,
         0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+        m_NetworkData.AmountOfMessagesSent++;
+    }
+}
+
+void Server::send(PlayerID player, Packet& packet)
+{
+    int bytesSent = m_Socket.send_to(
+        boost::asio::buffer(packet.Data(), packet.Size()),
+        m_PlayerDefinitions[player].Endpoint,
+        0);
+    // Network Debug data
+    if (isReadingData) {
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+        m_NetworkData.AmountOfMessagesSent++;
+    }
 }
 
 void Server::send(Packet & packet)
@@ -122,6 +155,11 @@ void Server::send(Packet & packet)
             packet.Size()),
         m_ReceiverEndpoint,
         0);
+    if (isReadingData) {
+        // Network Debug data
+        m_NetworkData.TotalDataSent += packet.Size();
+        m_NetworkData.DataSentThisInterval += packet.Size();
+    }
 }
 
 void Server::broadcast(Packet& packet)
@@ -143,9 +181,12 @@ void Server::sendSnapshot()
         Packet packet(MessageType::Snapshot);
         ComponentPool* componentPool = it.second;
         ComponentInfo componentInfo = componentPool->ComponentInfo();
+
         // Component Type
         packet.WriteString(componentInfo.Name);
         for (auto& componentWrapper : *componentPool) {
+            // HACK: Send entity name
+            packet.WriteString(m_World->GetName(componentWrapper.EntityID));
             // Components EntityID
             packet.WritePrimitive(componentWrapper.EntityID);
             // Parents EntityID
@@ -160,8 +201,10 @@ void Server::sendSnapshot()
                 }
             }
         }
+        if (packet.Size() > packet.HeaderSize() + componentInfo.Name.size()) {
             broadcast(packet);
         }
+    }
 }
 
 void Server::sendPing()
@@ -174,7 +217,7 @@ void Server::sendPing()
         }
     }
     // Create ping message
-    Packet packet(MessageType::ServerPing);
+    Packet packet(MessageType::Ping);
     packet.WriteString("Ping from server");
     // Time message
     m_StartPingTime = std::clock();
@@ -191,7 +234,7 @@ void Server::checkForTimeOuts()
         if (m_ConnectedUsers[i].Endpoint.address() != boost::asio::ip::address()) {
             int stopPing = 1000 * m_ConnectedUsers[i].StopTime /
                 static_cast<double>(CLOCKS_PER_SEC);
-            if (startPing > stopPing + TIMEOUTMS) {
+            if (startPing > stopPing + m_TimeoutMs) {
                 LOG_INFO("User %i timed out!", i);
                 disconnect(i);
             }
@@ -199,35 +242,40 @@ void Server::checkForTimeOuts()
     }
 }
 
-void Server::disconnect(int i)
+void Server::disconnect(UserID user)
 {
     //broadcast("A player disconnected");
-    LOG_INFO("User %s disconnected/timed out", m_PlayerDefinitions[i].Name.c_str());
+    LOG_INFO("User %s disconnected/timed out", m_PlayerDefinitions[user].Name.c_str());
     // Remove enteties and stuff (When we can remove entity, remove it and tell clients to remove the copy they have)
-    m_PlayerDefinitions[i].Endpoint = boost::asio::ip::udp::endpoint();
-    m_PlayerDefinitions[i].EntityID = -1;
-    m_PlayerDefinitions[i].Name = "";
-    m_PlayerDefinitions[i].PacketID = 0;
-    m_ConnectedUsers.erase(m_ConnectedUsers.begin() + i);
+    Events::PlayerDisconnected e;
+    e.Entity = m_PlayerDefinitions[user].EntityID;
+    e.PlayerID = user;
+    m_EventBroker->Publish(e);
+
+    m_PlayerDefinitions[user].Endpoint = boost::asio::ip::udp::endpoint();
+    m_PlayerDefinitions[user].EntityID = -1;
+    m_PlayerDefinitions[user].Name = "";
+    m_PlayerDefinitions[user].PacketID = 0;
+    m_ConnectedUsers.erase(m_ConnectedUsers.begin() + user);
 }
 
 void Server::parseOnInputCommand(Packet& packet)
 {
-    int playerID = -1;
+    PlayerID player = -1;
     // Check which player it was who sent the message
-    for (int i = 0; i < MAXCONNECTIONS; i++) {
+    for (int i = 0; i < m_MaxConnections; i++) {
         // if the player is connected set playerID to the correct PlayerID
         if (m_PlayerDefinitions[i].Endpoint.address() == m_ReceiverEndpoint.address()
             && m_PlayerDefinitions[i].Endpoint.port() == m_ReceiverEndpoint.port()) {
-            playerID = i;
+            player = i;
             break;
         }
     }
-    if (playerID != -1) {
+    if (player != -1) {
         while (packet.DataReadSize() < packet.Size()) {
             Events::InputCommand e;
             e.Command = packet.ReadString();
-            e.PlayerID = playerID; // Set correct player id
+            e.PlayerID = player; // Set correct player id
             e.Value = packet.ReadPrimitive<float>();
             m_EventBroker->Publish(e);
             //LOG_INFO("Server::parseOnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
@@ -292,17 +340,17 @@ void Server::parseDisconnect()
 void Server::parseClientPing()
 {
     LOG_INFO("%i: Parsing ping", m_PacketID);
-    int playerID = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
-    if (playerID == -1) {
+    PlayerID player = GetPlayerIDFromEndpoint(m_ReceiverEndpoint);
+    if (player == -1) {
         return;
     }
     // Return ping
-    Packet packet(MessageType::ClientPing, m_PlayerDefinitions[playerID].PacketID);
+    Packet packet(MessageType::Ping, m_PlayerDefinitions[player].PacketID);
     packet.WriteString("Ping received");
     send(packet);
 }
 
-void Server::parseServerPing()
+void Server::parsePing()
 {
     for (int i = 0; i < m_ConnectedUsers.size(); i++) {
         if (m_ConnectedUsers[i].Endpoint.address() == m_ReceiverEndpoint.address()) {
@@ -328,7 +376,7 @@ void Server::createPlayer()
         LOG_WARNING("Already connected!");
         return;
     }
-    int userIndex;
+    UserID userIndex;
     for (userIndex = 0; userIndex < m_ConnectedUsers.size(); userIndex++) {
         if (m_ConnectedUsers[userIndex].Endpoint.address() == m_ReceiverEndpoint.address() &&
             m_ConnectedUsers[userIndex].Endpoint.port() == m_ReceiverEndpoint.port()) {
@@ -340,14 +388,14 @@ void Server::createPlayer()
         LOG_WARNING("Not a recognized user!");
         return;
     }
-    for (int playerIndex = 0; playerIndex < MAXCONNECTIONS; playerIndex++) {
+    for (PlayerID playerIndex = 0; playerIndex < m_MaxConnections; playerIndex++) {
         if (m_PlayerDefinitions[playerIndex].Endpoint.address() == boost::asio::ip::address()) {
             m_PlayerDefinitions[playerIndex] = m_ConnectedUsers[userIndex];
             EntityID entityID = m_World->CreateEntity();
             ComponentWrapper transform = m_World->AttachComponent(entityID, "Transform");
             transform["Position"] = glm::vec3(-1.5f, 0.f, 0.f);
             ComponentWrapper model = m_World->AttachComponent(entityID, "Model");
-            model["Resource"] = "Models/Core/UnitSphere.obj";
+    model["Resource"] = "Models/Core/UnitSphere.mesh"; 
             model["Color"] = glm::vec4(rand()%255 / 255.f, rand()%255 / 255.f, rand() %255 / 255.f, 1.f);
             ComponentWrapper player = m_World->AttachComponent(entityID, "Player");
             m_PlayerDefinitions[playerIndex].EntityID = entityID;
@@ -358,9 +406,16 @@ void Server::createPlayer()
 
 }
 
-int Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
+void Server::kick(PlayerID player)
 {
-    for (int i = 0; i < MAXCONNECTIONS; i++) {
+    disconnect(player);
+    Packet packet = Packet(MessageType::Kick);
+    send(packet);
+}
+
+PlayerID Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
+{
+    for (int i = 0; i < m_MaxConnections; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() == endpoint.address() &&
             m_PlayerDefinitions[i].Endpoint.port() == endpoint.port()) {
             return i;
@@ -372,5 +427,25 @@ int Server::GetPlayerIDFromEndpoint(boost::asio::ip::udp::endpoint endpoint)
 bool Server::OnInputCommand(const Events::InputCommand & e)
 {
     //LOG_DEBUG("Server::OnInputCommand: Command is %s. Value is %f. PlayerID is %i.", e.Command.c_str(), e.Value, e.PlayerID);
+    if (e.Command == "LogNetworkBandwidth" && e.Value > 0) {
+        if (isReadingData) {
+            saveToFile();
+        }
+        isReadingData = !isReadingData;
+        m_SaveDataTimer = std::clock();
+    }
+    if (e.Command == "KickPlayer" && e.Value > 0) {
+        kick(0);
+    }
+
     return true;
 }
+
+bool Server::OnPlayerSpawned(const Events::PlayerSpawned & e)
+{
+    Packet packet = Packet(MessageType::OnPlayerSpawned);
+    packet.WritePrimitive<EntityID>(e.Player.ID);
+    packet.WritePrimitive<EntityID>(e.Spawner.ID);
+    send(e.PlayerID, packet);
+    return false;
+}

src/Engine/Rendering/DrawBloomPass.cpp

@@ -4,7 +4,7 @@ DrawBloomPass::DrawBloomPass(IRenderer* renderer)
 {
     m_Renderer = renderer;
 
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
     InitializeTextures();
     InitializeBuffers();

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -4,8 +4,8 @@ DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
 {
     m_Renderer = renderer;
 
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-    m_Exposure = 1; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+    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.
 
     InitializeShaderPrograms();
 }

src/Engine/Rendering/DrawFinalPass.cpp

@@ -65,6 +65,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
     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);
 
+
     //TODO: Render: Add code for more jobs than modeljobs.
     for (auto &job : scene.ForwardJobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
@@ -72,6 +73,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
             //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
+            glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(modelJob->DiffuseColor));
 
             glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(modelJob->FillColor));
             glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), modelJob->FillPercentage);
@@ -84,7 +86,11 @@ void DrawFinalPass::Draw(RenderScene& scene)
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
             glActiveTexture(GL_TEXTURE1);
+            if (modelJob->IncandescenceTexture != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, modelJob->IncandescenceTexture->m_Texture);
+            } else {
                 glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+            }
 
             /*if(modelJob->GlowMap != nullptr) {
             glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture);
@@ -92,14 +98,23 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
             }*/
 
+            //TODO: Fixa så att modelsJobs kan spela upp olika animationer och så att den kan få in en tid istället för 1.0f - Hälsningar Johan och Andreas :)
+            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+                auto animation = modelJob->Model->m_RawModel->m_Skeleton->GetAnimation("running");
+                if (animation != nullptr) {
+                    std::vector<glm::mat4> frameBones = modelJob->Model->m_RawModel->m_Skeleton->GetFrameBones(
+                        *animation,
+                        0.0f
+                        );
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                }
+            }
+
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
-
-            continue;
+            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
         }
     }
-    m_FinalPassFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
     delete state;
 }

src/Engine/Rendering/DrawScreenQuadPass.cpp

@@ -4,7 +4,7 @@ DrawScreenQuadPass::DrawScreenQuadPass(IRenderer* renderer)
 {
     m_Renderer = renderer;
 
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
     InitializeShaderPrograms();
 }

src/Engine/Rendering/Model.cpp

@@ -15,6 +15,9 @@ Model::Model(std::string fileName)
         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));
+        }
     }
 
     // Generate GL buffers
@@ -32,7 +35,7 @@ Model::Model(std::string fileName)
     GLERROR("GLEW: BufferFail4");
 
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
-    std::vector<int> structSizes = { 3, 3, 3, 3, 2, 4, 4, 4, 4, 4, 4 };
+	std::vector<int> structSizes = { 3, 3, 3, 3, 2, 4, 4 };
     int stride = 0;
     for (int size : structSizes) {
         stride += size;
@@ -48,10 +51,6 @@ Model::Model(std::string fileName)
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
         glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
-        glVertexAttribPointer(element, structSizes[element], GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * (offset += structSizes[element - 1]))); element++;
     }
     GLERROR("GLEW: BufferFail5");
 
@@ -62,10 +61,6 @@ Model::Model(std::string fileName)
     glEnableVertexAttribArray(4);
     glEnableVertexAttribArray(5);
     glEnableVertexAttribArray(6);
-    glEnableVertexAttribArray(7);
-    glEnableVertexAttribArray(8);
-    glEnableVertexAttribArray(9);
-    glEnableVertexAttribArray(10);
     GLERROR("GLEW: BufferFail5");
 
     //CreateBuffers();

src/Engine/Rendering/RawModelAssimp.cpp

@@ -1,6 +1,8 @@
-#include "Rendering/RawModel.h"
+#include "Rendering/RawModelAssimp.h"
 
-RawModel::RawModel(std::string fileName)
+#ifdef USING_ASSIMP_AS_IMPORTER
+
+RawModelAssimp::RawModelAssimp(std::string fileName)
 {
 	Assimp::Importer importer;
 	const aiScene* scene = importer.ReadFile(fileName, aiProcess_CalcTangentSpace | aiProcess_Triangulate);
@@ -75,20 +77,6 @@ RawModel::RawModel(std::string fileName)
 				desc.TextureCoords = glm::vec2(uv.x, uv.y);
 			}
             
-			// Material diffuse color
-			aiColor3D diffuse;
-			material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
-            float opacity;
-            material->Get(AI_MATKEY_OPACITY, opacity);
-			desc.DiffuseVertexColor = glm::vec4(diffuse.r, diffuse.g, diffuse.b, opacity);
-
-			desc.DiffuseVertexColor = glm::vec4(diffuse.r, diffuse.g, diffuse.b, opacity);
-            
-			// Material specular color
-			aiColor3D specular;
-			material->Get(AI_MATKEY_COLOR_SPECULAR, specular);
-			desc.SpecularVertexColor = glm::vec4(specular.r, specular.g, specular.b, 1.f);
-
 			m_Vertices.push_back(desc);
 		}
 
@@ -128,7 +116,7 @@ RawModel::RawModel(std::string fileName)
 		}
 		for (auto& vertex : m_Vertices) {
 			vertex.Tangent = glm::normalize(vertex.Tangent);
-			vertex.BiTangent = glm::normalize(glm::cross(vertex.Tangent, glm::normalize(vertex.Normal)));
+			vertex.BiNormal = glm::normalize(glm::cross(vertex.Tangent, glm::normalize(vertex.Normal)));
 		}
 
 		// Material info
@@ -201,10 +189,7 @@ RawModel::RawModel(std::string fileName)
 				LOG_WARNING("Vertex weights (%i) greater than max weights per vertex (%i)", weights.size(), maxWeights);
 			}
 			for (int weightIndex = 0; weightIndex < weights.size() && weightIndex < maxWeights && weightIndex < 4; ++weightIndex) {
-				std::tie(desc.BoneIndices1[weightIndex], desc.BoneWeights1[weightIndex]) = weights[weightIndex];
-			}
-			for (int weightIndex = 4; weightIndex < weights.size() && weightIndex < maxWeights && weightIndex < 8; ++weightIndex) {
-				std::tie(desc.BoneIndices2[weightIndex - 4], desc.BoneWeights2[weightIndex - 4]) = weights[weightIndex];
+				std::tie(desc.BoneIndices[weightIndex], desc.BoneWeights[weightIndex]) = weights[weightIndex];
 			}
 		}
 
@@ -290,14 +275,14 @@ RawModel::RawModel(std::string fileName)
 	}
 }
 
-RawModel::~RawModel()
+RawModelAssimp::~RawModelAssimp()
 {
 	if (m_Skeleton) {
 		delete m_Skeleton;
 	}
 }
 
-void RawModel::CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID)
+void RawModelAssimp::CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &boneInfo, std::map<std::string, int> &boneNameMapping, aiNode* node, int parentID)
 {
 	std::string nodeName = node->mName.C_Str();
 
@@ -317,3 +302,5 @@ void RawModel::CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &b
 		CreateSkeleton(boneInfo, boneNameMapping, child, parentID);
 	}
 }
+
+#endif

src/Engine/Rendering/RawModelCustom.cpp

@@ -0,0 +1,381 @@
+#include "Rendering/RawModelCustom.h"
+
+#ifndef USING_ASSIMP_AS_IMPORTER
+
+RawModelCustom::RawModelCustom(std::string fileName)
+{
+    if(fileName.substr(fileName.find_last_of(".")).compare(".mesh") != 0) {
+        throw Resource::FailedLoadingException("Unknown model file format. Please use \".mesh\" files.");
+    }
+    fileName = fileName.erase(fileName.find_last_of("."), fileName.find_last_of(".") - fileName.size());
+    ReadMeshFile(fileName);
+    ReadMaterialFile(fileName);
+    ReadAnimationFile(fileName);
+}
+
+void RawModelCustom::ReadMeshFile(std::string filePath)
+{ 
+    char* fileData;
+    filePath += ".mesh";
+    std::ifstream in(filePath.c_str(), std::ios_base::binary | std::ios_base::ate);
+
+    if (!in.is_open()) {
+        throw Resource::FailedLoadingException("Open mesh file failed");
+    }
+    unsigned int fileByteSize = in.tellg();
+    in.seekg(0, std::ios_base::beg);
+
+    fileData = new char[fileByteSize];
+    in.read(fileData, fileByteSize);
+    in.close();
+
+    unsigned int offset = 0;
+    if (fileByteSize > 0) {
+        ReadMeshFileHeader(offset, fileData, fileByteSize);
+        ReadMesh(offset, fileData, fileByteSize);
+    }
+    delete fileData;
+}
+
+void RawModelCustom::ReadMeshFileHeader(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    m_Vertices.resize(*(unsigned int*)(fileData + offset));
+    offset += sizeof(unsigned int);
+    m_Indices.resize(*(unsigned int*)(fileData + offset));
+    offset += sizeof(unsigned int);
+#else
+#endif
+}
+
+void RawModelCustom::ReadMesh(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+{
+    ReadVertices(offset, fileData, fileByteSize);
+    ReadIndices(offset, fileData, fileByteSize);
+}
+
+void RawModelCustom::ReadVertices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    if (offset +  m_Vertices.size() * sizeof(Vertex) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading vertices failed");
+    }
+
+    memcpy(&m_Vertices[0], fileData + offset, m_Vertices.size() * sizeof(Vertex));
+    offset += m_Vertices.size() * sizeof(Vertex);
+#else
+#endif
+}
+
+void RawModelCustom::ReadIndices(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    if (offset + m_Indices.size() * sizeof(unsigned int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading indices failed");
+    }
+
+    memcpy(&m_Indices[0], fileData + offset, m_Indices.size() * sizeof(unsigned int));
+    offset += m_Indices.size() * sizeof(unsigned int);
+
+#else
+#endif
+}
+
+void RawModelCustom::ReadMaterialFile(std::string filePath)
+{ 
+    char* fileData;
+    filePath += ".mtrl";
+    std::ifstream in(filePath.c_str(), std::ios_base::binary | std::ios_base::ate);
+
+    if (!in.is_open()) {
+        throw Resource::FailedLoadingException("Open material file failed");
+    }
+    unsigned int fileByteSize = in.tellg();
+    in.seekg(0, std::ios_base::beg);
+
+    fileData = new char[fileByteSize];
+    in.read(fileData, fileByteSize);
+    in.close();
+
+    unsigned int offset = 0;
+    if (fileByteSize > 0) {
+        ReadMaterials(offset, fileData, fileByteSize);
+    }
+    delete fileData;
+}
+
+void RawModelCustom::ReadMaterials(unsigned int& offset, char* fileData, unsigned int& fileByteSize)
+{ 
+#ifdef BOOST_LITTLE_ENDIAN
+    unsigned int* numMaterials = (unsigned int*)(fileData);
+    MaterialGroups.reserve(*numMaterials);
+    offset += sizeof(unsigned int);
+
+    for (int i = 0; i < *numMaterials; i++) {
+        ReadMaterialSingle(offset, fileData, fileByteSize);
+    }
+#else
+#endif
+}
+
+void RawModelCustom::ReadMaterialSingle(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+{ 
+    MaterialGroup newMaterial;
+
+#ifdef BOOST_LITTLE_ENDIAN
+
+    if (offset + sizeof(unsigned int) * 4 > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading Material texture names length failed");
+    }
+
+    unsigned int* nameLengths = (unsigned int*)(fileData + offset); 
+    offset += sizeof(unsigned int) * 4;
+
+    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];
+    }
+
+#else
+#endif
+
+    MaterialGroups.push_back(newMaterial);
+}
+
+void RawModelCustom::ReadAnimationFile(std::string filePath)
+{ 
+    char* fileData;
+    filePath += ".anim";
+    std::ifstream in(filePath.c_str(), std::ios_base::binary | std::ios_base::ate);
+
+    if (!in.is_open()) {
+        //throw Resource::FailedLoadingException("Open animation file failed");
+        return;
+    }
+
+    unsigned int fileByteSize = in.tellg();
+    in.seekg(0, std::ios_base::beg);
+
+    fileData = new char[fileByteSize];
+    in.read(fileData, fileByteSize);
+    in.close();
+
+    unsigned int offset = 0;
+    if (fileByteSize > 0) {
+        m_Skeleton = new Skeleton();
+
+#ifdef BOOST_LITTLE_ENDIAN
+        unsigned int numBindPoses = *(unsigned int*)(fileData);
+        offset += sizeof(unsigned int);
+        unsigned int numAnimations = *(unsigned int*)(fileData + offset);
+        offset += sizeof(unsigned int);
+#else
+#endif
+
+        ReadAnimationBindPoses(offset, fileData, fileByteSize);
+        ReadAnimationClips(offset, fileData, fileByteSize, numAnimations);
+    }
+    delete fileData;
+}
+
+void RawModelCustom::ReadAnimationBindPoses(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    unsigned int* numBones = (unsigned int*)(fileData + offset);
+    offset += sizeof(unsigned int);
+
+    for (unsigned int i = 0; i < *numBones; i++) {
+        ReadAnimationJoint(offset, fileData, fileByteSize);
+    }
+#else
+#endif
+}
+
+void RawModelCustom::ReadAnimationJoint(unsigned int &offset, char* fileData, unsigned int& fileByteSize)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    if (offset + sizeof(unsigned int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading Joint name length failed");
+    }
+    unsigned int jointNameLength = *(unsigned int*)(fileData + offset);
+    offset += sizeof(unsigned int);
+
+    if (offset + jointNameLength > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading Joint name failed");
+    }
+    std::string jointName = (fileData + offset);
+    offset += jointNameLength;
+
+    if (offset + sizeof(float) * 4 * 4 > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading Joint offset matrix failed");
+    }
+    glm::mat4 offsetMatrix;
+    memcpy(&offsetMatrix, fileData + offset, sizeof(float) * 4 * 4);
+    offset += sizeof(float) * 4 * 4;
+    
+    if (offset + sizeof(int) > fileByteSize) { 
+        throw Resource::FailedLoadingException("Reading Joint ID failed");
+    }
+    int jointID = *(int*)(fileData + offset);
+    offset += sizeof(int);
+
+    if (offset + sizeof(int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading Joint Parent ID failed");
+    }
+    int jointParentID = *(int*)(fileData + offset);
+    offset += sizeof(int);
+
+    // Adding joint to the Skeleton
+    m_Skeleton->CreateBone(jointID, jointParentID, jointName, offsetMatrix);
+
+
+#else
+#endif
+}
+
+void RawModelCustom::ReadAnimationClips(unsigned int &offset, char* fileData, 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)
+{
+#ifdef BOOST_LITTLE_ENDIAN
+    Skeleton::Animation newAnimation;
+
+    if (offset + sizeof(unsigned int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationClip name length failed");
+    }
+    unsigned int clipNameLength = *(unsigned int*)(fileData + offset);
+    offset += sizeof(unsigned int);
+
+    if (offset + clipNameLength > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationClip name failed");
+    }
+    newAnimation.Name = (fileData + offset);
+    offset += clipNameLength;
+
+    if (offset + sizeof(float) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationClip duration failed");
+    }
+
+    newAnimation.Duration = *(float*)(fileData + offset);
+    offset += sizeof(float);
+
+    if (offset + sizeof(unsigned int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationClip NrOfKeyframes failed");
+    }
+    unsigned int nrOfKeyframes = *(unsigned int*)(fileData + offset);
+    offset += sizeof(unsigned int);
+
+    if (offset + sizeof(unsigned int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationClip NrOfJoints failed");
+    }
+    unsigned int nrOfJoints = *(unsigned int*)(fileData + offset);
+    offset += sizeof(unsigned int);
+
+    newAnimation.Keyframes.reserve(nrOfKeyframes);
+    for (unsigned int i = 0; i < nrOfKeyframes; i++) { 
+        ReadAnimationKeyFrame(offset, fileData, fileByteSize, nrOfJoints, newAnimation);
+    }
+    m_Skeleton->Animations[newAnimation.Name] = newAnimation;
+#else
+#endif
+}
+
+void RawModelCustom::ReadAnimationKeyFrame(unsigned int &offset, char* fileData, unsigned int& fileByteSize, unsigned int nrOfJoints, Skeleton::Animation& animation)
+{
+    Skeleton::Animation::Keyframe newKeyFrame;
+
+    if (offset + sizeof(int) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame index failed");
+    }
+    newKeyFrame.Index = *(int*)(fileData + offset);
+    offset += sizeof(int);
+
+    if (offset + sizeof(float) > fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame time failed");
+    }
+    newKeyFrame.Time = *(float*)(fileData + offset);
+    offset += sizeof(float);
+
+    if (offset + sizeof(Skeleton::Animation::Keyframe::BoneProperty) * nrOfJoints> fileByteSize) {
+        throw Resource::FailedLoadingException("Reading AnimationKeyFrame joints failed");
+    }
+
+    Skeleton::Animation::Keyframe::BoneProperty newBone;
+    for (unsigned int i = 0; i < nrOfJoints; i++) {
+        memcpy(&newBone, (fileData + offset), sizeof(Skeleton::Animation::Keyframe::BoneProperty));
+        offset += sizeof(Skeleton::Animation::Keyframe::BoneProperty);
+        newKeyFrame.BoneProperties[newBone.ID] = newBone;
+    }
+    animation.Keyframes.push_back(newKeyFrame);
+}
+
+RawModelCustom::~RawModelCustom()
+{
+    if (m_Skeleton != nullptr) {
+        delete m_Skeleton;
+    }
+}
+
+#endif

src/Engine/Rendering/RenderSystem.cpp

@@ -8,6 +8,7 @@ RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRender
 {
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &RenderSystem::OnSetCamera);
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &RenderSystem::OnPlayerSpawned);
 
     m_Camera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 5000.f);
 }
@@ -47,15 +48,22 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs)
             continue;
         }
 
+        EntityWrapper entity(m_World, modelComponent.EntityID);
+
+        // Don't render the local player
+        if (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) {
+            continue;
+        }
+
         Model* model;
         try {
             model = ResourceManager::Load<::Model, true>(resource);
         } catch (const Resource::StillLoadingException&) {
             //continue;
-            model = ResourceManager::Load<::Model>("Models/Core/UnitRaptor.obj");
+            model = ResourceManager::Load<::Model>("Models/Core/UnitRaptor.mesh");
         } catch (const std::exception&) {
             try {
-                model = ResourceManager::Load<::Model>("Models/Core/Error.obj");
+                model = ResourceManager::Load<::Model>("Models/Core/Error.mesh");
             } catch (const std::exception&) {
                 continue;
             }
@@ -81,6 +89,14 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs)
     }
 }
 
+bool RenderSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+{
+    if (e.PlayerID == -1) {
+        m_LocalPlayer = e.Player;
+    }
+    return true;
+}
+
 void RenderSystem::fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
 {
     auto pointLights = m_World->GetComponents("PointLight");
@@ -168,12 +184,13 @@ void RenderSystem::Update(double dt)
 {
     m_EventBroker->Process<RenderSystem>();
 
-    if (m_CurrentCamera) {
-        ComponentWrapper cameraTransform = m_CurrentCamera["Transform"];
-        m_Camera->SetPosition(cameraTransform["Position"]);
-        m_Camera->SetOrientation(glm::quat((const glm::vec3&)cameraTransform["Orientation"]));
+    // Update the current camera used for rendering
+    if (m_CurrentCamera.Valid()) {
+        m_Camera->SetPosition(Transform::AbsolutePosition(m_CurrentCamera));
+        m_Camera->SetOrientation(Transform::AbsoluteOrientation(m_CurrentCamera));
     }
 
+
     RenderScene scene;
     scene.Camera = m_Camera;
     scene.Viewport = Rectangle(1280, 720);

src/Engine/Rendering/Renderer.cpp

@@ -13,9 +13,9 @@ void Renderer::Initialize()
     m_TextPass->Initialize();
 
 
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+   /* m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
-    m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");
+    m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");*/
 
     m_ImGuiRenderPass = new ImGuiRenderPass(this, m_EventBroker);
 }

src/Engine/Rendering/Skeleton.cpp

@@ -84,10 +84,13 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, const Animation::Keyf
 			positionInterp.z = 0;
 		}
 
+
 		boneMatrix = parentMatrix * (glm::translate(positionInterp) * glm::toMat4(rotationInterp) * glm::scale(scaleInterp));
 		boneMatrices[bone->ID] = boneMatrix * bone->OffsetMatrix;
 	} else {
-		boneMatrix = parentMatrix * bone->Parent->OffsetMatrix; // * glm::inverse(bone->OffsetMatrix);
+        if (bone->Parent) {
+            boneMatrix = parentMatrix; // * glm::inverse(bone->OffsetMatrix);
+        }
 		boneMatrices[bone->ID] = boneMatrix; // * bone->OffsetMatrix;
 	}
 
@@ -95,6 +98,7 @@ void Skeleton::AccumulateBoneTransforms(bool noRootMotion, const Animation::Keyf
 		std::string name = child->Name;
 		AccumulateBoneTransforms(noRootMotion, currentFrame, nextFrame, progress, boneMatrices, child, boneMatrix);
 	}
+
 }
 
 int Skeleton::GetBoneID(std::string name)

src/Engine/Sound/SoundSystem.cpp

@@ -198,7 +198,7 @@ bool SoundSystem::OnPlaySoundOnPosition(const Events::PlaySoundOnPosition & e)
     (float&)(double)emitter["RollOffFactor"] = e.RollOffFactor;
     (float&)(double)emitter["ReferenceDistance"] = e.ReferenceDistance;
     auto model = m_World->AttachComponent(emitterID, "Model");
-    (std::string&)model["Resource"] = "Models/Core/UnitCube.obj";
+    (std::string&)model["Resource"] = "Models/Core/UnitCube.mesh"; // 360NoScope UnitCube
     source->Type = SoundType::SFX;
     m_Sources[emitterID] = source;
     playSound(source);

src/Game/Systems/InterpolationSystem.cpp

@@ -1,24 +1,14 @@
 #include "Systems/InterpolationSystem.h"
 
-//void InterpolationSystem::UpdateComponent(World * world, ComponentWrapper & transform, double dt)
-//{
-//    if (m_InterpolationPoints[transform.EntityID].size() > 0) {
-//        Transform& sTransform = m_InterpolationPoints[transform.EntityID].front();
-//        sTransform.interpolationTime += dt;
-//        if (sTransform.interpolationTime > 0.05) {
-//            double time = std::fmod(sTransform.interpolationTime, 0.05f);
-//            m_InterpolationPoints[transform.EntityID].pop();
-//            if (m_InterpolationPoints[transform.EntityID].size() <= 0) {
-//                return;
-//            }
-//            sTransform = m_InterpolationPoints[transform.EntityID].front();
-//            sTransform.interpolationTime = time;
-//        }
-//        glm::vec3 nextPosition = sTransform.Position;
-//        glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
-//        transform["Position"] = vectorInterpolation(currentPosition, nextPosition, sTransform.interpolationTime);
-//    }
-//}
+InterpolationSystem::InterpolationSystem(World* world, EventBroker* eventBroker) 
+    : System(world, eventBroker)
+    , PureSystem("Transform")
+{
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05);
+    EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &InterpolationSystem::OnPlayerSpawned);
+}
 
 void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt)
 {
@@ -26,10 +16,10 @@ void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
         m_NextTransform[transform.EntityID].interpolationTime += dt;
         Transform sTransform = m_NextTransform[transform.EntityID];
         double time = sTransform.interpolationTime;
-        if (time > SNAPSHOTINTERVAL) {
+        if (time > m_SnapshotInterval) {
             if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
                 m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];
-                m_NextTransform[transform.EntityID].interpolationTime = time - SNAPSHOTINTERVAL;
+                m_NextTransform[transform.EntityID].interpolationTime = time - m_SnapshotInterval;
                 sTransform = m_NextTransform[transform.EntityID];
                 m_LastReceivedTransform.erase(transform.EntityID);
             } else {
@@ -37,14 +27,22 @@ void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
             }
         }
         if (transform.Info.Name == "Transform") {
+            bool isLocalPlayer = entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer);
             // Position
             glm::vec3 nextPosition = sTransform.Position;
             glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
+            // HACK: Hardcoded tolerance value for player position desync = 1
+            if (isLocalPlayer && glm::length(nextPosition - currentPosition) < 1.f) {
+                return;
+            }
             (glm::vec3&)transform["Position"] += vectorInterpolation<glm::vec3>(currentPosition, nextPosition, sTransform.interpolationTime);
             // Orientation
+            // Don't force orientation for players
+            if (!isLocalPlayer) {
                 glm::quat nextOrientation = sTransform.Orientation;
                 glm::quat currentOrientation = glm::quat(static_cast<glm::vec3>(transform["Orientation"]));
-            (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / SNAPSHOTINTERVAL));
+                (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / m_SnapshotInterval));
+            }
             // Scale
             glm::vec3 nextScale = sTransform.Scale;
             glm::vec3 currentScale = static_cast<glm::vec3>(transform["Scale"]);
@@ -53,6 +51,12 @@ void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrappe
     }
 }
 
+bool InterpolationSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+{
+    m_LocalPlayer = e.Player;
+    return true;
+}
+
 bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
 {
     Transform transform;
@@ -72,15 +76,5 @@ bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
     } else { // Did not
         m_NextTransform[e.Entity] = transform;
     }
-    // Check if queue already exists
-    //if (m_InterpolationPoints.find(e.Entity) != m_InterpolationPoints.end()) { // Did exist, push to queue
-    //    m_InterpolationPoints[e.Entity].push(transform);
-    //} 
-
-    //else { // Did not exist, create queue
-    //    std::queue<Transform> transformQueue;
-    //    transformQueue.push(transform);
-    //    m_InterpolationPoints[e.Entity] = transformQueue;
-    //}
     return false;
 }

src/Game/Systems/PlayerMovementSystem.cpp

@@ -1,18 +1,132 @@
 #include "Systems/PlayerMovementSystem.h"
 
+PlayerMovementSystem::PlayerMovementSystem(World* world, EventBroker* eventBroker) 
+    : System(world, eventBroker)
+    , PureSystem("Player")
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &PlayerMovementSystem::OnPlayerSpawned);
+}
+
+PlayerMovementSystem::~PlayerMovementSystem()
+{
+    for (auto& kv : m_PlayerInputControllers) {
+        delete kv.second;
+    }
+}
+
+void PlayerMovementSystem::Update(double dt)
+{
+    for (auto& kv : m_PlayerInputControllers) {
+        EntityWrapper player = kv.first;
+        auto& controller = kv.second;
+
+        if (!player.Valid()) {
+            continue;
+        }
+
+        EntityWrapper cameraEntity = player.FirstChildByName("Camera");
+        if (cameraEntity.Valid()) {
+            glm::vec3& cameraOrientation = cameraEntity["Transform"]["Orientation"];
+            cameraOrientation.x += controller->Rotation().x;
+            // Limit camera pitch so we don't break our necks
+            cameraOrientation.x = glm::clamp(cameraOrientation.x, -glm::half_pi<float>(), glm::half_pi<float>());
+        }
+
+        ComponentWrapper& cTransform = player["Transform"];
+        glm::vec3& ori = cTransform["Orientation"];
+        ori.y += controller->Rotation().y;
+
+        if (player.HasComponent("Physics")) {
+            ComponentWrapper cPhysics = player["Physics"];
+
+            glm::vec3 wishDirection = controller->Movement() * glm::inverse(glm::quat(ori));
+            float wishSpeed;
+            if (controller->Crouching()) {
+                wishSpeed = player["Player"]["CrouchSpeed"];
+            } else {
+                wishSpeed = player["Player"]["MovementSpeed"];
+            }
+            glm::vec3& velocity = cPhysics["Velocity"];
+            ImGui::Text("velocity: (%f, %f, %f)", velocity.x, velocity.y, velocity.z);
+            glm::vec3 groundVelocity(0.f, 0.f, 0.f);
+            groundVelocity.x = glm::dot(velocity, glm::vec3(1.f, 0.f, 0.f));
+            groundVelocity.z = glm::dot(velocity, glm::vec3(0.f, 0.f, 1.f));
+            ImGui::Text("groundVelocity: (%f, %f, %f) |%f|", groundVelocity.x, groundVelocity.y, groundVelocity.z, glm::length(wishDirection));
+            ImGui::Text("wishDirection: (%f, %f, %f) |%f|", wishDirection.x, wishDirection.y, wishDirection.z, glm::length(wishDirection));
+            float currentSpeedProj = glm::dot(groundVelocity, wishDirection);
+            float addSpeed = wishSpeed - currentSpeedProj;
+            ImGui::Text("currentSpeedProj: %f", currentSpeedProj);
+            ImGui::Text("wishSpeed: %f", wishSpeed);
+            ImGui::Text("addSpeed: %f", addSpeed);
+
+            if (addSpeed > 0) {
+                static float accel = 15.f;
+                ImGui::InputFloat("accel", &accel);
+                static float airAccel = 0.5f;
+                ImGui::InputFloat("airAccel", &airAccel);
+                float actualAccel = (velocity.y != 0) ? airAccel : accel;
+                static float surfaceFriction = 5.f;
+                ImGui::InputFloat("surfaceFriction", &surfaceFriction);
+                float accelerationSpeed = actualAccel * (float)dt * wishSpeed * surfaceFriction;
+                accelerationSpeed = glm::min(accelerationSpeed, addSpeed);
+                velocity += accelerationSpeed * wishDirection;
+                ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
+            }
+
+            if (controller->Jumping() && !controller->Crouching() && velocity.y == 0.f) {
+                velocity.y += 4.f;
+            }
+
+            //if (player.HasComponent("AABB")) {
+            //    glm::vec3& size = player["AABB"]["Size"];
+            //    if (controller->Crouching()) {
+            //        size = glm::vec3(1.f, 1.f, 1.f);
+            //    } else {
+            //        size = glm::vec3(1.f, 1.6f, 1.f);
+            //    }
+            //}
+        }
+        
+        controller->Reset();
+    }
+}
+
 void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     ComponentWrapper& cTransform = entity["Transform"];
     if (!entity.HasComponent("Physics")) {
         return;
     }
-    ComponentWrapper& cPhysics = entity["Physics"];
 
+    ComponentWrapper& cPhysics = entity["Physics"];
     glm::vec3& velocity = cPhysics["Velocity"];
+
+    // Ground friction
+    float speed = glm::length(velocity);
+    static float groundFriction = 7.f;
+    ImGui::InputFloat("groundFriction", &groundFriction);
+    static float airFriction = 0.f;
+    ImGui::InputFloat("airFriction", &airFriction);
+    float friction = (velocity.y != 0) ? airFriction : groundFriction;
+    if (speed > 0) {
+        float drop = speed * friction * (float)dt;
+        float multiplier = glm::max(speed - drop, 0.f) / speed;
+        velocity.x *= multiplier;
+        velocity.z *= multiplier;
+    }
+
     if (cPhysics["Gravity"]) {
-        velocity.y -= 9.82 * dt;
+        velocity.y -= 9.82f * (float)dt;
     }
 
     glm::vec3& position = cTransform["Position"];
     position += velocity * (float)dt;
 }
+
+bool PlayerMovementSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+{
+    // When a player spawns, create an input controller for them
+    m_PlayerInputControllers[e.Player] = new FirstPersonInputController<PlayerMovementSystem>(m_EventBroker, e.PlayerID);
+
+    return true;
+}

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -4,6 +4,8 @@ PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker)
     : System(m_World, eventBroker)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
+    EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
+    m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
 }
 
 void PlayerSpawnSystem::Update(double dt)
@@ -13,7 +15,7 @@ void PlayerSpawnSystem::Update(double dt)
         return;
     }
 
-    for (auto& team : m_SpawnRequests) {
+    for (auto& req : m_SpawnRequests) {
         for (auto& cPlayerSpawn : *playerSpawns) {
             EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
             if (!spawner.HasComponent("Spawner")) {
@@ -22,7 +24,7 @@ void PlayerSpawnSystem::Update(double dt)
 
             // If the spawner has a team affiliation, check it
             if (spawner.HasComponent("Team")) {
-                if ((int)spawner["Team"]["Team"] != team) {
+                if ((int)spawner["Team"]["Team"] != req.Team) {
                     continue;
                 }
             }
@@ -30,7 +32,15 @@ void PlayerSpawnSystem::Update(double dt)
             // Spawn the player!
             EntityWrapper player = SpawnerSystem::Spawn(spawner);
             // Set the player team affiliation
-            player["Team"]["Team"] = team;
+            player["Team"]["Team"] = req.Team;
+
+            // Publish a PlayerSpawned event
+            Events::PlayerSpawned e;
+            e.PlayerID = req.PlayerID;
+            e.Player = player;
+            e.Spawner = spawner;
+            m_EventBroker->Publish(e);
+
         }
     }
     m_SpawnRequests.clear();
@@ -42,10 +52,60 @@ bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
         return false;
     }
 
+    // Team picks should be processed ONLY server-side!
+    // Don't make a spawn request if PlayerID is -1, i.e. we're the client.
+    if (e.PlayerID == -1 && m_NetworkEnabled) {
+        return false;
+    }
+
     if (e.Value != 0) {
-        m_SpawnRequests.push_back((int)e.Value);
+        SpawnRequest req;
+        req.PlayerID = e.PlayerID;
+        req.Team = (ComponentInfo::EnumType)e.Value;
+        m_SpawnRequests.push_back(req);
     }
 
     return true;
 }
 
+bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
+{
+    // When a player is actually spawned (since the actual spawning is handled on the server)
+
+    // Check if a player already exists
+    if (m_PlayerEntities.count(e.PlayerID) != 0) {
+        // TODO: Disallow infinite respawning here
+        m_World->DeleteEntity(m_PlayerEntities[e.PlayerID].ID);
+    }
+
+    // Store the player for future reference
+    m_PlayerEntities[e.PlayerID] = e.Player;
+
+    // Set the camera to the correct entity
+    EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera");
+    if (cameraEntity.Valid()) {
+        Events::SetCamera e;
+        e.CameraEntity = cameraEntity;
+        m_EventBroker->Publish(e);
+    }
+
+    // HACK: Set the player model color to team color
+    EntityWrapper playerModel = e.Player.FirstChildByName("PlayerModel");
+    if (playerModel.Valid() && e.Player.HasComponent("Team")) {
+        ComponentWrapper cTeam = e.Player["Team"];
+        ComponentWrapper cModel = playerModel["Model"];
+        if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Red")) {
+            cModel["Color"] = glm::vec3(1.f, 0.f, 0.f);
+        } else if ((ComponentInfo::EnumType)cTeam["Team"] == cTeam["Team"].Enum("Blue")) {
+            cModel["Color"] = glm::vec3(0.f, 0.25f, 1.f);
+        }
+    }
+
+    // TODO: Set the player name to whatever
+    //EntityWrapper playerName = e.Player.FirstChildByName("PlayerName");
+    //if (playerName.Valid()) {
+    //    playerName["Text"]["Content"] = ???;
+    //}
+
+    return true;
+}

src/Tests/CollisionTest.cpp

@@ -27,7 +27,9 @@ using boost::unit_test_framework::test_case;
 void RayTest(std::string fileName) {
     //simple box test
     Ray ray(glm::vec3(-50, 0, 0), glm::vec3(1, 0, 0));
-    //using a rawmodel here, else we have to init the renderingsystem
+    //using a 
+    
+    here, else we have to init the renderingsystem
     ResourceManager::RegisterType<RawModel>("RawModel");
     auto unitBox = ResourceManager::Load<RawModel>(fileName);
     BOOST_REQUIRE(unitBox != nullptr);
@@ -106,7 +108,7 @@ BOOST_AUTO_TEST_CASE(collisionTest2)
 BOOST_AUTO_TEST_CASE(rayVsModelTest)
 {
     //simple box test
-    RayTest("Models/Core/UnitCube.obj");
+    RayTest("Models/Core/UnitCube.mesh"); // 360NoScope Unitcube
 }
 
 BOOST_AUTO_TEST_CASE(rayVsModelTest2)
@@ -128,7 +130,7 @@ BOOST_AUTO_TEST_CASE(rayVsModelTest2)
     someAABB = AABB(minPos, maxPos);
     //using a rawmodel here, else we have to init the renderingsystem
     ResourceManager::RegisterType<RawModel>("RawModel");
-    auto unitBox = ResourceManager::Load<RawModel>("Models/Core/UnitCube.obj");
+    auto unitBox = ResourceManager::Load<RawModel>("Models/Core/UnitCube.mesh"); // 360NoScope unitcube
     BOOST_CHECK(unitBox != nullptr);
 
     for (size_t i = 0; i < 1000000; i++)
@@ -187,19 +189,19 @@ BOOST_AUTO_TEST_CASE(rayVsModelTest2)
 BOOST_AUTO_TEST_CASE(rayVsModelTest3)
 {
     //simple test
-    RayTest("Models/Core/UnitSphere.obj");
+    RayTest("Models/Core/UnitSphere.mesh"); // 360NoScope unitSphere
 }
 
 BOOST_AUTO_TEST_CASE(rayVsModelTest4)
 {
     //simple test
-    RayTest("Models/Core/UnitCylinder.obj");
+    RayTest("Models/Core/UnitCylinder.mesh"); // 360NoScope unitCylinder
 }
 
 BOOST_AUTO_TEST_CASE(rayVsModelTest5)
 {
     //simple test
-    RayTest("Models/Core/UnitRaptor.obj");
+    RayTest("Models/Core/UnitRaptor.mesh"); // 360NoScope unitRaptor
 }
 BOOST_AUTO_TEST_CASE(octTest)
 {

src/Tests/HealthSystemTest.cpp

@@ -56,7 +56,7 @@ GameHealthSystemTest::GameHealthSystemTest()
     EntityID playerID = m_World->CreateEntity();
     ComponentWrapper transform = m_World->AttachComponent(playerID, "Transform");
     ComponentWrapper model = m_World->AttachComponent(playerID, "Model");
-    model["Resource"] = "Models/Core/UnitSphere.obj";
+    model["Resource"] = "Models/Core/UnitSphere.mesh"; // 360NoScope UnitSphere
     ComponentWrapper player = m_World->AttachComponent(playerID, "Player");
     ComponentWrapper health = m_World->AttachComponent(playerID, "Health");
     healthsID = playerID;
@@ -81,7 +81,7 @@ GameHealthSystemTest::GameHealthSystemTest()
     EntityID playerID2 = m_World->CreateEntity();
     ComponentWrapper transform2 = m_World->AttachComponent(playerID2, "Transform");
     ComponentWrapper model2 = m_World->AttachComponent(playerID2, "Model");
-    model2["Resource"] = "Models/Core/UnitSphere.obj";
+    model2["Resource"] = "Models/Core/UnitSphere.mesh"; // 360NoScope UnitSphere
     ComponentWrapper player2 = m_World->AttachComponent(playerID2, "Player");
     ComponentWrapper health2 = m_World->AttachComponent(playerID2, "Health");
     //END TEST

src/Tests/OldOctTree.cpp

@@ -112,7 +112,7 @@ void OctTree::Update(float dt, World* world, Camera* cam)
         ComponentWrapper transform = world->AttachComponent(m_BoxID, "Transform");
         transform["Scale"] = boxSize;
         ComponentWrapper model = world->AttachComponent(m_BoxID, "Model");
-        model["Resource"] = "Models/Core/UnitBox.obj";
+        model["Resource"] = "Models/Core/UnitBox.mesh"; // 360NoScope UnitBox
         m_UpdatedOnce = true;
     }
 

src/Tests/ResourceManagerTest.cpp

@@ -26,7 +26,7 @@ BOOST_AUTO_TEST_CASE(resourceManagerTest)
     BOOST_CHECK(!ResourceManager::IsResourceLoaded("ConfigFile", "Config.ini"));
 
     //configfile without register
-    BOOST_CHECK_THROW(ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj"),Resource::FailedLoadingException);
+    BOOST_CHECK_THROW(ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh"),Resource::FailedLoadingException);
     //there is no error feedback to check if you try to release the wrong resources - hence that cant be tested either
 }
 

tools/MayaExporter/MayaExporter/Export.cpp

@@ -0,0 +1,224 @@
+#include "Export.h"
+
+Export::Export()
+{ 
+
+}
+
+bool Export::Meshes(std::string pathName, bool selectedOnly)
+{ 
+    MStatus status;
+    if (pathName.empty()) {
+        MGlobal::displayError(MString() + "Export::Meshes() got no pathName. Do not know where to write file");
+        return false;
+    }
+
+    MSelectionList selectedOnStart;
+    MGlobal::getActiveSelectionList(selectedOnStart);
+    if (selectedOnStart.length() > 0) {
+        for (int i = 0; i < selectedOnStart.length(); i++) {
+            MObject item;
+            selectedOnStart.getDependNode(i, item);
+            MGlobal::unselect(item);
+        }
+    }
+    MGlobal::displayInfo(MString() + "Disabel IKSolvers");
+    status = MGlobal::executeCommand("doEnableNodeItems false all;");
+    if (status != MS::kSuccess) {
+        MGlobal::displayError(MString() + "EnableNodeItems false all failed: " + status.errorString());
+    }
+    MGlobal::displayInfo(MString() + "Has disabel IKSolvers");
+    MObjectArray Objects;
+    if (selectedOnly) {
+        // Retrieving the objects we currently have selected
+
+        // Loop through or list of selection(s)
+        for (unsigned int i = 0; i < selectedOnStart.length(); i++) {
+            MObject object;
+            selectedOnStart.getDependNode(i, object);
+
+            if (object.hasFn(MFn::kMesh)) {
+                MFnMesh shape(object);
+                
+                for (unsigned int k = 0; k < shape.parentCount(); k++) {                 
+                    MFnDependencyNode thisNode(object);
+                    MPlugArray connections;
+                    thisNode.findPlug("inMesh").connectedTo(connections, true, true);
+
+                    for (unsigned int i = 0; i < connections.length(); i++) {
+                        if (connections[i].node().apiType() == MFn::kSkinClusterFilter) {
+                            MGlobal::select(shape.parent(i), MGlobal::kReplaceList);
+                            MGlobal::displayInfo(MString() + "Moving " + thisNode.name() + " to bindPose.");
+                            status = MGlobal::executeCommand("GoToBindPose;");
+                            if (status != MS::kSuccess) {
+                                MGlobal::displayError(MString() + "GoToBindPose: " + status.errorString());
+                            }
+                            MGlobal::displayInfo(MString() + "Has moved " + thisNode.name() + " to bindPose.");
+                        }
+                    }
+                }
+                Objects.append(object);
+            }
+        }
+    } else {
+        // Loop through all nodes in the scene
+        MItDependencyNodes it(MFn::kMesh);
+        for (; !it.isDone(); it.next()) {
+            MObject node = it.thisNode();
+            MFnDependencyNode thisNode(node);
+            MPlugArray connections;
+            thisNode.findPlug("inMesh").connectedTo(connections, true, true);
+
+            for (unsigned int i = 0; i < connections.length(); i++) {
+                if (connections[i].node().apiType() == MFn::kSkinClusterFilter) {
+                    MGlobal::select(node);
+                    MGlobal::displayInfo(MString() + "Moving " + thisNode.name() + " to bindPose.");
+                    MGlobal::executeCommand("GoToBindPose");
+                    MGlobal::displayInfo(MString() + "Has moved " + thisNode.name() + " to bindPose.");
+                }
+            }
+
+            Objects.append(node);
+        }
+    }
+    GetMeshData(Objects);
+    WriteMeshData(pathName);
+    MGlobal::displayInfo(MString() + "Enabling IKSolvers");
+    status = MGlobal::executeCommand("doEnableNodeItems true all;");
+    if (status != MS::kSuccess) {
+        MGlobal::displayError(MString() + "doEnableNodeItems true all: " + status.errorString());
+    }
+    MGlobal::displayInfo(MString() + "Has enabling IKSolvers");
+    if (selectedOnStart.length() > 0) {
+        for (int i = 0; i < selectedOnStart.length(); i++) {
+            MObject item;
+            selectedOnStart.getDependNode(i, item);
+            MGlobal::select(item);
+        }
+    }
+    return true;
+}
+
+bool Export::Materials(std::string pathName)
+{ 
+    if (!GetMaterialData())
+        return false;
+    WriteMaterialData(pathName);
+    return true;
+}
+
+bool Export::Animations(std::string pathName, std::vector<AnimationInfo> animInfo)
+{ 
+    if (MAnimControl::currentTime().unit() != MTime::kNTSCField) {
+
+        MGlobal::displayError(MString() + "Please change to 60 FPS under Preferences/Settings!");
+        return false;
+    }
+
+    if (pathName.empty()) {
+        MGlobal::displayError(MString() + "Export::Animations() got no pathName. Do not know where to write file");
+        return false;
+    }
+    allBindPoses = m_SkeletonHandler.GetBindPoses();
+
+    for (auto clip : animInfo) {
+        if (!GetAnimationData(clip)) {
+            MGlobal::displayError(MString() + "Export::Animations() failed to export " + clip.Name.c_str());
+            return false;
+        }
+    }
+    WriteAnimData(pathName);
+    return true;
+}
+
+bool Export::GetMeshData(MObjectArray object)
+{ 
+    meshes = m_MeshHandler.GetMeshData(object);
+    return true;
+}
+
+bool Export::GetMaterialData()
+{ 
+    // Traverse scene and return vector with all materials
+    AllMaterials = m_MaterialHandler.DoIt(meshes);
+
+    return true;
+}
+
+bool Export::GetAnimationData(AnimationInfo animInfo)
+{
+    if (animInfo.Name.empty()) {
+        MGlobal::displayError(MString() + "A clip does not have a name");
+        return false;
+    }
+    if (animInfo.End - animInfo.Start <= 0) {
+        MGlobal::displayError(MString() + "A clip ends before it starts or contains 0 frames");
+        return false;
+    }
+
+    allAnimations.push_back(m_SkeletonHandler.GetAnimData(animInfo.Name, animInfo.Start, animInfo.End));
+    return true;
+}
+
+void Export::WriteMeshData(std::string pathName)
+{
+    m_MeshFile.ASCIIFilePath(pathName +"_mesh.txt");
+    m_MeshFile.binaryFilePath(pathName + ".mesh");
+
+    m_MeshFile.OpenFiles();
+
+    m_MeshFile.writeToFiles((OutputData*)&meshes);
+
+    m_MeshFile.CloseFiles();
+}
+
+void Export::WriteAnimData(std::string pathName)
+{
+    if (allBindPoses.size() > 0) {
+        m_AnimFile.ASCIIFilePath(pathName + "_anim.txt");
+        m_AnimFile.binaryFilePath(pathName + ".anim");
+
+        m_AnimFile.OpenFiles();
+        int size = allBindPoses.size();
+        m_AnimFile.writeToFiles(&size);
+
+        
+        size = allAnimations.size();
+        m_AnimFile.writeToFiles(&size);
+
+        //print out all bind poses
+        for (auto aBindPose : allBindPoses) {
+            m_AnimFile.writeToFiles((OutputData*)&aBindPose);
+        }
+        for (auto aAnimation : allAnimations) {
+            m_AnimFile.writeToFiles((OutputData*)&aAnimation);
+        }
+
+        m_AnimFile.CloseFiles();
+    } else
+        MGlobal::displayInfo("Export::WriteAnimData() got called when allBindPoses contained no data, did not write nor created them");
+}
+
+void Export::WriteMaterialData(std::string pathName)
+{ 
+    m_MtrlFile.ASCIIFilePath(pathName +"_mtrl.txt");
+    m_MtrlFile.binaryFilePath(pathName + ".mtrl");
+
+    m_MtrlFile.OpenFiles();
+
+    int size = (*AllMaterials).size();
+    m_MtrlFile.writeToFiles(&size);
+
+    for (auto aMaterial : *AllMaterials) {
+        m_MtrlFile.writeToFiles((OutputData*)&aMaterial);
+    }
+    m_MtrlFile.CloseFiles();
+}
+
+Export::~Export()
+{
+   /* delete m_MaterialHandler;
+    delete m_SkeletonHandler;
+    delete m_MeshHandler;*/
+
+}

tools/MayaExporter/MayaExporter/Export.h

@@ -0,0 +1,58 @@
+#ifndef Export_Export_h__
+#define Export_Export_h__
+
+#include <vector>
+#include <string>
+
+#include "MayaIncludes.h"
+#include "Material.h"
+#include "Mesh.h"
+#include "Skeleton.h"
+#include "WriteToFile.h"
+
+class Export {
+public:
+    Export();
+
+    ~Export();
+
+    struct AnimationInfo {
+        std::string Name;
+        int Start;
+        int End;
+    };
+
+    bool Meshes(std::string pathName, bool selectedOnly = false);
+    bool Materials(std::string pathName);
+    bool Animations(std::string pathName, std::vector<AnimationInfo> animInfo);
+
+private:
+    bool GetMeshData(MObjectArray object);
+    bool GetMaterialData();
+    bool GetAnimationData(AnimationInfo info);
+
+    void WriteMeshData(std::string pathName);
+    void WriteAnimData(std::string pathName);
+    void WriteMaterialData(std::string pathName);
+
+    Material m_MaterialHandler;
+    Skeleton m_SkeletonHandler;
+    MeshClass m_MeshHandler;
+    
+
+    //File export
+    WriteToFile m_MeshFile;
+    WriteToFile m_AnimFile;
+    WriteToFile m_MtrlFile;
+
+    //Mesh Data
+    Mesh meshes;
+
+    //Animation Data
+    std::vector<BindPoseSkeletonNode> allBindPoses;
+    std::vector<Animation> allAnimations;
+
+    //Material Data
+    std::vector<MaterialNode>* AllMaterials;
+};
+#endif

tools/MayaExporter/MayaExporter/GeneratedFiles/Debug/moc_Menu.cpp

@@ -22,7 +22,7 @@ static const uint qt_meta_data_Menu[] = {
        6,       // revision
        0,       // classname
        0,    0, // classinfo
-       7,   14, // methods
+       5,   14, // methods
        0,    0, // properties
        0,    0, // enums/sets
        0,    0, // constructors
@@ -30,22 +30,19 @@ static const uint qt_meta_data_Menu[] = {
        0,       // signalCount
 
  // slots: signature, parameters, type, tag, flags
-      14,    6,    5,    5, 0x08,
-      35,    5,    5,    5, 0x08,
-      59,    5,    5,    5, 0x08,
+       6,    5,    5,    5, 0x08,
+      30,    5,    5,    5, 0x08,
+      51,    5,    5,    5, 0x08,
       75,    5,    5,    5, 0x08,
-      95,    5,    5,    5, 0x08,
-     116,    5,    5,    5, 0x08,
-     137,    5,    5,    5, 0x08,
+      91,    5,    5,    5, 0x08,
 
        0        // eod
 };
 
 static const char qt_meta_stringdata_Menu[] = {
-    "Menu\0\0checked\0ExportSelected(bool)\0"
-    "ExportPathClicked(bool)\0ExportAll(bool)\0"
-    "CancelClicked(bool)\0Button1Clicked(bool)\0"
-    "Button2Clicked(bool)\0Button3Clicked(bool)\0"
+    "Menu\0\0ExportPathClicked(bool)\0"
+    "AddClipClicked(bool)\0RemoveClipClicked(bool)\0"
+    "ExportAll(bool)\0CancelClicked(bool)\0"
 };
 
 void Menu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
@@ -54,13 +51,11 @@ void Menu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void *
         Q_ASSERT(staticMetaObject.cast(_o));
         Menu *_t = static_cast<Menu *>(_o);
         switch (_id) {
-        case 0: _t->ExportSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 1: _t->ExportPathClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 2: _t->ExportAll((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 3: _t->CancelClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 4: _t->Button1Clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 5: _t->Button2Clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 6: _t->Button3Clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 0: _t->ExportPathClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 1: _t->AddClipClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 2: _t->RemoveClipClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 3: _t->ExportAll((*reinterpret_cast< bool(*)>(_a[1]))); break;
+        case 4: _t->CancelClicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
         default: ;
         }
     }
@@ -98,9 +93,9 @@ int Menu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
     if (_id < 0)
         return _id;
     if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 7)
+        if (_id < 5)
             qt_static_metacall(this, _c, _id, _a);
-        _id -= 7;
+        _id -= 5;
     }
     return _id;
 }

tools/MayaExporter/MayaExporter/Material.cpp

@@ -0,0 +1,237 @@
+#include "Material.h"
+
+void Material::grabLambertProperties(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	material_node.Name = node.name().asChar();
+
+    if (!findColorTexture(material_node, node)) {
+        node.findPlug("colorR").getValue(material_node.DiffuseColor[0]);
+        node.findPlug("colorG").getValue(material_node.DiffuseColor[1]);
+        node.findPlug("colorB").getValue(material_node.DiffuseColor[2]);
+
+    }
+
+
+	if (!findIncandescenceTexture(material_node, node)) {
+        node.findPlug("incandescenceR").getValue(material_node.IncandescenceColor[0]);
+        node.findPlug("incandescenceG").getValue(material_node.IncandescenceColor[1]);
+        node.findPlug("incandescenceB").getValue(material_node.IncandescenceColor[2]);
+	}
+
+    if (findNormalTexture(material_node, node)) {
+        MGlobal::displayWarning(MString() + "Material " + node.name() + " has no normal texture.");
+    }
+}
+
+void Material::grabBlinnProperties(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	if (!findSpecularTexture(material_node, node)) {
+        node.findPlug("specularColorR").getValue(material_node.SpecularColor[0]);
+        node.findPlug("specularColorG").getValue(material_node.SpecularColor[1]);
+        node.findPlug("specularColorB").getValue(material_node.SpecularColor[2]);
+	}
+
+	m_Plug = node.findPlug("reflectivity");
+	m_Plug.getValue(material_node.ReflectionFactor);
+
+	m_Plug = node.findPlug("eccentricity");
+	float TempEccent;
+	m_Plug.getValue(TempEccent);
+
+	// Blinn works differently from Phong which is used in-game.
+	// This is some magic numbers and math to make a conversion estimate between the two.
+	// There is no exact conversion between the two, so there are errors.
+
+	// Phong min/max is around Blinn 0.7/0.1
+	TempEccent = std::max(std::min(TempEccent, 0.7f), 0.1f);
+
+	material_node.SpecularExponent = std::max(std::min(((2.66f) + (427.0f) * exp((-14.8f) * TempEccent)), 100.0f), 2.0f);
+}
+
+void Material::grabPhongProperties(MaterialNode& material_node, MFnDependencyNode& node)
+{
+    if (!findSpecularTexture(material_node, node)) {
+        node.findPlug("specularColorR").getValue(material_node.SpecularColor[0]);
+        node.findPlug("specularColorG").getValue(material_node.SpecularColor[1]);
+        node.findPlug("specularColorB").getValue(material_node.SpecularColor[2]);
+    }
+
+	m_Plug = node.findPlug("reflectivity");
+	m_Plug.getValue(material_node.ReflectionFactor);
+
+	m_Plug = node.findPlug("cosinePower ");
+	m_Plug.getValue(material_node.SpecularExponent);
+}
+
+bool Material::findColorTexture(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	MPlugArray AllConnections;
+  
+	m_Plug = node.findPlug("color", true);
+	m_Plug.connectedTo(AllConnections, true, false);
+
+	for (int i = 0; i < AllConnections.length(); i++) {
+		if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
+			MFnDependencyNode TextureNode(AllConnections[i].node());
+            
+			std::string FullPath = TextureNode.findPlug("fileTextureName").asString().asChar();
+			m_TexturePaths.push_back(FullPath);
+
+            MString workspace;
+            MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
+                workspace);
+            FullPath = FullPath.substr(workspace.length());
+            FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
+			material_node.ColorMapFile = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
+
+            material_node.ColorMapFileLength = material_node.ColorMapFile.length() + 1;
+			// Test
+            MGlobal::displayInfo(MString() + "getAbsolutePathToResources: " + workspace);
+			MGlobal::displayInfo(MString() + "Texture file: " + FullPath.c_str());
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool Material::findNormalTexture(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	MPlugArray AllConnections;
+	MPlugArray AllBumpConnections;
+
+	m_Plug = node.findPlug("normalCamera", true);
+	m_Plug.connectedTo(AllConnections, true, false);
+
+	for (int i = 0; i < AllConnections.length(); i++) {
+		if (AllConnections[i].node().apiType() == MFn::kBump) {
+			MFnDependencyNode BumpNode(AllConnections[i].node());
+
+			BumpNode.findPlug("bumpValue").connectedTo(AllBumpConnections, true, false);
+			for (int j = 0; j < AllBumpConnections.length(); j++) {
+				if (AllBumpConnections[j].node().hasFn(MFn::kFileTexture)) {
+					MFnDependencyNode TextureNode(AllBumpConnections[j].node());
+
+					std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
+					m_TexturePaths.push_back(FullPath);
+
+                    MString workspace;
+                    MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
+                        workspace);
+                    FullPath = FullPath.substr(workspace.length());
+                    FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
+                    material_node.NormalMapFile = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
+                    material_node.NormalMapFileLength = material_node.NormalMapFile.length() + 1;
+					return true;
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+bool Material::findSpecularTexture(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	MPlugArray AllConnections;
+
+	m_Plug = node.findPlug("specularColor", true);
+	m_Plug.connectedTo(AllConnections, true, false);
+
+	for (int i = 0; i < AllConnections.length(); i++) {
+		if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
+			MFnDependencyNode TextureNode(AllConnections[i].node());
+
+			std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
+			m_TexturePaths.push_back(FullPath);
+
+            MString workspace;
+            MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
+                workspace);
+            FullPath = FullPath.substr(workspace.length());
+            FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
+            material_node.SpecularMapFile = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
+            material_node.SpecularMapFileLength = material_node.SpecularMapFile.length() + 1;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Material::findIncandescenceTexture(MaterialNode& material_node, MFnDependencyNode& node)
+{
+	MPlugArray AllConnections;
+
+	m_Plug = node.findPlug("incandescence", true);
+	m_Plug.connectedTo(AllConnections, true, false);
+
+	for (int i = 0; i < AllConnections.length(); i++) {
+		if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
+			MFnDependencyNode TextureNode(AllConnections[i].node());
+
+			std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
+			m_TexturePaths.push_back(FullPath);
+
+            MString workspace;
+            MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
+                workspace);
+            FullPath = FullPath.substr(workspace.length());
+            FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
+            material_node.IncandescenceMapFile = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
+            material_node.IncandescenceMapFileLength = material_node.IncandescenceMapFile.length() + 1;
+			return true;
+		}
+	}
+	return false;
+}
+
+// Returns the absolute path for all textures. Use for copying texture files.
+std::vector<std::string>* Material::TexturePaths()
+{
+	return &m_TexturePaths;
+}
+
+// Traverse the DAG and grab all the materials
+std::vector<MaterialNode>* Material::DoIt(Mesh mesh)
+{
+	// All materials we care about inherit from Lambert
+	MItDependencyNodes matIt(MFn::kLambert);
+    m_AllMaterials.clear();
+	while (!matIt.isDone()) {
+		MFnDependencyNode MaterialFnDN(matIt.thisNode());
+		MaterialNode MaterialStorage;
+        bool meshHasMaterial = false;
+        //Mesh Indices is a map with <string : MaterialName, vector<int> : indices>
+        int totalIndices = 0;
+        for (auto aMeshMaterial : mesh.Indices) {
+            MGlobal::displayInfo(MString() + "Material: " + aMeshMaterial.first.c_str() + " " + MaterialFnDN.name().asChar());
+            if (aMeshMaterial.first.compare(MaterialFnDN.name().asChar()) == 0) {
+                meshHasMaterial = true;
+                MaterialStorage.IndexStart = totalIndices;
+                MaterialStorage.IndexEnd = totalIndices + aMeshMaterial.second.size() - 1;
+                break;
+            }
+            totalIndices += aMeshMaterial.second.size();
+        }
+        if (meshHasMaterial) {
+            grabLambertProperties(MaterialStorage, MaterialFnDN);
+
+            if (matIt.thisNode().hasFn(MFn::kPhong)) {         
+                grabPhongProperties(MaterialStorage, MaterialFnDN);
+
+            } else if (matIt.thisNode().hasFn(MFn::kBlinn)) {
+                grabBlinnProperties(MaterialStorage, MaterialFnDN);
+
+            } else if (matIt.thisNode().hasFn(MFn::kLambert)) {
+                MaterialStorage.ReflectionFactor = 0.0f;
+                MaterialStorage.SpecularExponent = 0.0f;      
+            }
+
+            m_AllMaterials.push_back(MaterialStorage);
+        }
+		matIt.next();
+	}
+
+	return &m_AllMaterials;
+}
+

tools/MayaExporter/MayaExporter/Material.h

@@ -0,0 +1,115 @@
+#ifndef Material_Material_h__
+#define Material_Material_h__
+
+#include <vector>
+#include <array>
+#include <algorithm>
+#include <cmath>
+#include <map>
+
+#include "MayaIncludes.h"
+#include "OutputData.h"
+#include "Mesh.h"
+
+class MaterialNode : public OutputData
+{
+public:
+	std::string Name;
+
+	float ReflectionFactor;
+    float SpecularExponent;
+
+    float DiffuseColor[3]{ 1.0f, 1.0f, 1.0f };
+    unsigned int ColorMapFileLength = 0;
+	std::string ColorMapFile;
+
+    float SpecularColor[3]{ 1.0f, 1.0f, 1.0f };
+    unsigned int SpecularMapFileLength = 0;
+	std::string SpecularMapFile;
+
+    unsigned int NormalMapFileLength = 0;
+	std::string NormalMapFile;
+
+    float IncandescenceColor[3]{ 1.0f, 1.0f, 1.0f };
+    unsigned int IncandescenceMapFileLength = 0;
+	std::string IncandescenceMapFile;
+
+    unsigned int IndexStart;
+    unsigned int IndexEnd;
+
+    virtual void WriteBinary(std::ostream& out)
+    {
+        out.write((char*)&ColorMapFileLength, sizeof(unsigned int));
+        out.write((char*)&NormalMapFileLength, sizeof(unsigned int));
+        out.write((char*)&SpecularMapFileLength, sizeof(unsigned int));
+        out.write((char*)&IncandescenceMapFileLength, sizeof(unsigned int));
+
+        out.write((char*)&SpecularExponent, sizeof(float));
+        out.write((char*)&ReflectionFactor, sizeof(float));
+        out.write((char*)&DiffuseColor, sizeof(float) * 3);
+        out.write((char*)&SpecularColor, sizeof(float) * 3);
+        out.write((char*)&IncandescenceColor, sizeof(float) * 3);
+        out.write((char*)&IndexStart, sizeof(unsigned int));
+        out.write((char*)&IndexEnd, sizeof(unsigned int));
+
+        out.write(ColorMapFile.c_str(), ColorMapFileLength);
+        out.write(NormalMapFile.c_str(), NormalMapFileLength);
+        out.write(SpecularMapFile.c_str(), SpecularMapFileLength);
+        out.write(IncandescenceMapFile.c_str(), IncandescenceMapFileLength);
+    }
+
+    virtual void WriteASCII(std::ostream& out) const
+    {
+        out << "New Material _ not in binary" << endl;
+        out << "number of indices: " << Name << " _ not in binary" << endl;
+
+        out << "ColorMapFile length: " << ColorMapFileLength << endl;
+        out << "NormalMapFile length: " << NormalMapFileLength << endl;
+        out << "SpecularMapFile length: " << SpecularMapFileLength << endl;
+        out << "IncandescenceMapFile length: " << IncandescenceMapFileLength << endl;
+
+        out << "SpecularExponent: " << SpecularExponent << endl;
+        out << "ReflectionFactor: " << ReflectionFactor << endl;
+        out << "DiffuseColor: " << DiffuseColor[0] << " "  << DiffuseColor[1] << " "  << DiffuseColor[2] << endl;
+        out << "SpecularColor: " << SpecularColor[0] << " "  << SpecularColor[1] << " "  << SpecularColor[2] << endl;
+        out << "IncandescenceColor: " << IncandescenceColor[0] << " "  << IncandescenceColor[1] << " "  << IncandescenceColor[2] << endl;
+        out << "IndexStart: " << IndexStart << endl;
+        out << "IndexEnd: " << IndexEnd << endl;
+
+        if (ColorMapFileLength > 0)
+            out << "ColorMapFile: " << ColorMapFile << endl;
+
+        if (NormalMapFileLength > 0)
+            out << "NormalMapFile: " << NormalMapFile << endl;
+        
+        if (SpecularMapFileLength > 0)
+            out << "SpecularMapFile: " << SpecularMapFile << endl;
+     
+        if (IncandescenceMapFileLength > 0)
+            out << "IncandescenceMapFile: " << IncandescenceMapFile << endl;
+    }
+};
+
+class Material
+{
+public:
+	Material() {};
+	~Material() {};
+	std::vector<MaterialNode>* DoIt(Mesh mesh);
+	std::vector<std::string>* TexturePaths();
+private:
+	MPlug m_Plug;
+	
+	std::vector<MaterialNode> m_AllMaterials;
+	std::vector<std::string> m_TexturePaths;
+
+	bool findColorTexture(MaterialNode& material_node, MFnDependencyNode& node);
+	bool findNormalTexture(MaterialNode& material_node, MFnDependencyNode& node);
+	bool findSpecularTexture(MaterialNode& material_node, MFnDependencyNode& node);
+	bool findIncandescenceTexture(MaterialNode& material_node, MFnDependencyNode& node);
+	void grabLambertProperties(MaterialNode& material_node, MFnDependencyNode& node);
+	void grabBlinnProperties(MaterialNode& material_node, MFnDependencyNode& node);
+	void grabPhongProperties(MaterialNode& material_node, MFnDependencyNode& node);
+};
+
+#endif // Material_Material_h__

tools/MayaExporter/MayaExporter/MayaExporter.vcxproj

@@ -140,6 +140,7 @@
       </DebugInformationFormat>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
+      <Optimization>Disabled</Optimization>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -152,6 +153,8 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="Export.cpp" />
+    <ClCompile Include="Material.cpp" />
     <ClCompile Include="Menu.cpp" />
     <ClCompile Include="GeneratedFiles\Debug\moc_Menu.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
@@ -172,6 +175,9 @@
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="Main.cpp" />
+    <ClCompile Include="Mesh.cpp" />
+    <ClCompile Include="Skeleton.cpp" />
+    <ClCompile Include="WriteToFile.cpp" />
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="MayaExporter.ui">
@@ -194,6 +200,11 @@
     </CustomBuild>
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="Export.h" />
+    <ClInclude Include="Mesh.h" />
+    <ClInclude Include="OutputData.h" />
+    <ClInclude Include="Skeleton.h" />
+    <ClInclude Include="WriteToFile.h" />
     <CustomBuild Include="Menu.h">
       <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Moc%27ing Menu.h...</Message>
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">.\GeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
@@ -213,6 +224,7 @@
       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(QTDIR)\bin\moc.exe;%(FullPath);$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
     </CustomBuild>
     <ClInclude Include="GeneratedFiles\ui_MayaExporter.h" />
+    <ClInclude Include="Material.h" />
     <ClInclude Include="MayaIncludes.h" />
   </ItemGroup>
   <ItemGroup>

tools/MayaExporter/MayaExporter/MayaExporter.vcxproj.filters

@@ -50,6 +50,21 @@
     <ClCompile Include="Main.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Material.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Mesh.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Skeleton.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="WriteToFile.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Export.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="leeeeel.qrc">
@@ -69,5 +84,23 @@
     <ClInclude Include="GeneratedFiles\ui_MayaExporter.h">
       <Filter>Generated Files</Filter>
     </ClInclude>
+    <ClInclude Include="Material.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Mesh.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Skeleton.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="WriteToFile.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OutputData.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Export.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

tools/MayaExporter/MayaExporter/MayaIncludes.h

@@ -30,6 +30,21 @@
 #include <maya/MItDependencyNodes.h>
 #include <maya/MFnNurbsCurve.h>
 #include <maya/MCommandMessage.h>
+#include <maya/MPlug.h>
+#include <maya/MAnimControl.h>
+#include <maya/MTime.h>
+#include <maya/MDataHandle.h>
+#include <maya/MTransformationMatrix.h>
+#include <maya/MFnMatrixData.h>
+#include <maya/MItMeshFaceVertex.h>
+#include <maya/MFnSkinCluster.h>
+#include <maya/MDagPathArray.h>
+#include <maya/MItGeometry.h>
+#include <maya/MItMeshVertex.h>
+#include <maya/MFnWeightGeometryFilter.h>
+#include <maya/MItDependencyGraph.h>
+#include <maya/MQuaternion.h>
+#include <maya/MFnNumericAttribute.h>
 
 
 // Wrappers
@@ -58,5 +73,6 @@
 #pragma comment(lib,"Foundation.lib")
 #pragma comment(lib,"OpenMaya.lib")
 #pragma comment(lib,"OpenMayaUI.lib")
+#pragma comment (lib, "OpenMayaAnim.lib")
 
 #endif

tools/MayaExporter/MayaExporter/Menu.cpp

@@ -10,223 +10,200 @@ Menu::Menu()
 Menu::Menu(QDialog* dialog)
 {
 	// Save the dialog pointer. Needed when the application gets destroyed
-	dialogPointer = dialog;
+	m_DialogPointer = dialog;
 
 	// Create QpushButtons & give them names
-	exportSelectedButton = new QPushButton("&Export Selected", this);
-	browseButton = new QPushButton("&...", this);
-	exportAllButton = new QPushButton("&Export All", this);
-	cancelButton = new QPushButton("&Cancel", this);
+	m_BrowseButton = new QPushButton("&...", this);
+	m_ExportAllButton = new QPushButton("&Export", this);
+	m_CancelButton = new QPushButton("&Cancel", this);
+	m_AddClipsButton = new QPushButton("&Add Clips", this);
+	m_RemoveClipsButton = new QPushButton("&Remove Latest Clip", this);
 
 	// Option box and checkboxes
 	QGroupBox *optionsBox = new QGroupBox(tr("Options"));
 
-	exportAnimationsButton = new QCheckBox(tr("&Export Animations"));
-	copyTexturesButton = new QCheckBox(tr("&Copy Textures"));
-	button3 = new QCheckBox(tr("option3"));
+    m_ExportSelectedButton = new QCheckBox(tr("&Export Selected"));
+	m_ExportAnimationsButton = new QCheckBox(tr("&Export Animations"));
+	m_ExportMaterialButton = new QCheckBox(tr("&Export Material"));;
 
-	exportAnimationsButton->setChecked(true);
-	copyTexturesButton->setChecked(true);
+	m_ExportAnimationsButton->setChecked(true);
+    m_ExportMaterialButton->setChecked(true);
 	QVBoxLayout *vbox = new QVBoxLayout;
-	vbox->addWidget(exportAnimationsButton);
-	vbox->addWidget(copyTexturesButton);
-	vbox->addWidget(button3);
+    vbox->addWidget(m_ExportSelectedButton);
+	vbox->addWidget(m_ExportAnimationsButton);
+	vbox->addWidget(m_ExportMaterialButton);
+
 	vbox->addStretch(1);
 	optionsBox->setLayout(vbox);
 
 	// Connect the buttons with signals & functions
-	connect(exportSelectedButton, SIGNAL(clicked(bool)), this, SLOT(ExportSelected(bool)));
-	connect(browseButton, SIGNAL(clicked(bool)), this, SLOT(ExportPathClicked(bool)));
-	connect(exportAllButton, SIGNAL(clicked(bool)), this, SLOT(ExportAll(bool)));
-	connect(cancelButton, SIGNAL(clicked(bool)), this, SLOT(CancelClicked(bool)));
+	connect(m_BrowseButton, SIGNAL(clicked(bool)), this, SLOT(ExportPathClicked(bool)));
+	connect(m_ExportAllButton, SIGNAL(clicked(bool)), this, SLOT(ExportAll(bool)));
+	connect(m_CancelButton, SIGNAL(clicked(bool)), this, SLOT(CancelClicked(bool)));
+	connect(m_AddClipsButton, SIGNAL(clicked(bool)), this, SLOT(AddClipClicked(bool)));
+	connect(m_RemoveClipsButton, SIGNAL(clicked(bool)), this, SLOT(RemoveClipClicked(bool)));
 
-	connect(exportAnimationsButton, SIGNAL(clicked(bool)), this, SLOT(Button1Clicked(bool)));
-	connect(copyTexturesButton, SIGNAL(clicked(bool)), this, SLOT(Button2Clicked(bool)));
-	connect(button3, SIGNAL(clicked(bool)), this, SLOT(Button3Clicked(bool)));
+    connect(m_ExportSelectedButton, SIGNAL(clicked(bool)), this, SLOT(NULL));
+	connect(m_ExportAnimationsButton, SIGNAL(clicked(bool)), this, SLOT(NULL));
+	connect(m_ExportMaterialButton, SIGNAL(clicked(bool)), this, SLOT(NULL));
 
 	// Creating several layouts, adding widgets & adding them to one layout in the end
 	QHBoxLayout* topLayout = new QHBoxLayout;
 	QVBoxLayout* midLayout = new QVBoxLayout;
 	QHBoxLayout* botLayout = new QHBoxLayout;
 	QVBoxLayout* baseLayout = new QVBoxLayout;
+	QHBoxLayout* clipButtonLayout = new QHBoxLayout;
+	QHBoxLayout* startEndLabelLayout = new QHBoxLayout;
+	m_ClipLayout = new QVBoxLayout;
 
-	exportPath = new QLineEdit;
-	fileDialog = new QFileDialog;
 
+
+	m_ExportPath = new QLineEdit;
+	m_FileDialog = new QFileDialog;
+    QString tmpPath("C:/Users/Nickelodion/Desktop/workspace/tacticalZ/assets/models/");
+    m_ExportPath->setText(tmpPath);
 	QLabel* exportLabel = new QLabel;
 	exportLabel->setText("Export Path:");
+	QLabel* nameLabel = new QLabel;
+	nameLabel->setText("Name:");
+	QLabel* startLabel = new QLabel;
+	startLabel->setText("Start:");
+	QLabel* endLabel = new QLabel;
+	endLabel->setText("End:");
+
+	//exportLabel->setText("Export Path:");
 
 	midLayout->addWidget(optionsBox);
 
 	topLayout->addWidget(exportLabel);
-	topLayout->addWidget(exportPath);
-	topLayout->addWidget(browseButton);
+	topLayout->addWidget(m_ExportPath);
+	topLayout->addWidget(m_BrowseButton);
 
-	botLayout->addWidget(exportSelectedButton);
-	botLayout->addWidget(exportAllButton);
-	botLayout->addWidget(cancelButton);
+	botLayout->addWidget(m_ExportAllButton);
+	botLayout->addWidget(m_CancelButton);
+
+	startEndLabelLayout->addWidget(nameLabel);
+	startEndLabelLayout->addWidget(startLabel);
+	startEndLabelLayout->addWidget(endLabel);
+
+	clipButtonLayout->addWidget(m_AddClipsButton);
+	clipButtonLayout->addWidget(m_RemoveClipsButton);
 
 	baseLayout->addLayout(topLayout);
 	baseLayout->addLayout(midLayout);
 
 	baseLayout->addSpacing(10);
-	
 	baseLayout->addLayout(botLayout);
+
+	baseLayout->addSpacing(10);
+	baseLayout->addLayout(clipButtonLayout);
+	baseLayout->addLayout(startEndLabelLayout);
+	baseLayout->addLayout(m_ClipLayout);
 	baseLayout->addStretch();
 
 	// Set the layout for our window
 	dialog->setLayout(baseLayout);
 
-}
+    this->AddClipClicked(true);
+	//for (unsigned int i = 0; i < 3; i++) {
+	//	this->AddClipClicked(true);
+	//}
 
-void Menu::ExportSelected(bool checked)
-{
-	// Retrieving the objects we currently have selected
-	MSelectionList selected;
-	MGlobal::getActiveSelectionList(selected);
-
-	// Loop through or list of selection(s)
-	for (unsigned int i = 0; i < selected.length();i++)
-	{
-		MObject object;
-		selected.getDependNode(i, object);
-		MFnDependencyNode thisNode(object);
-
-		cout << thisNode.name().asChar() << endl;
-		GetMeshData(object);
-	}
-	if (exportPath->text().isEmpty())
-		cout << "Please select a folder." << endl;
-	else
-		cout << exportPath->text().toLocal8Bit().constData() << endl;
 }
 
 void Menu::ExportPathClicked(bool)
 {
 	// Opens up a file dialog. Save/Changes the name in the exportPath
-	fileDialog->setFileMode(QFileDialog::Directory);
-	fileDialog->setOption(QFileDialog::ShowDirsOnly);
-	QString fileName = fileDialog->getExistingDirectory(this, "Select", "/home", QFileDialog::ShowDirsOnly);
-	exportPath->setText(fileName);
+	m_FileDialog->setFileMode(QFileDialog::Directory);
+	m_FileDialog->setOption(QFileDialog::ShowDirsOnly);
+	QString fileName = m_FileDialog->getExistingDirectory(this, "Select", "/home", QFileDialog::ShowDirsOnly);
+	m_ExportPath->setText(fileName);
+}
+
+void Menu::AddClipClicked(bool)
+{
+	QHBoxLayout* tempLayout = new QHBoxLayout;
+
+	QLineEdit* nameLineEdit = new QLineEdit;
+	QLineEdit* startLineEdit = new QLineEdit;
+	QLineEdit* endLineEdit = new QLineEdit;
+
+	m_AnimationClipName.push_back(nameLineEdit);
+	m_StartFrameLines.push_back(startLineEdit);
+	m_EndFrameLines.push_back(endLineEdit);
+
+	tempLayout->addWidget(nameLineEdit);
+	tempLayout->addWidget(startLineEdit);
+	tempLayout->addWidget(endLineEdit);
+
+	m_ClipLayout->addLayout(tempLayout);
+	//m_ClipLayout->update();
+	layouts.push_back(tempLayout);
+}
+
+void Menu::RemoveClipClicked(bool)
+{
+	if (m_StartFrameLines.size() > 0) {
+		QLayoutItem* tempWidget;// = m_ClipLayout->itemAt(0);
+
+		for (unsigned int i = 0; i < layouts.size(); i++) {
+			while ((tempWidget = layouts[layouts.size() - 1]->takeAt(0)) != 0) {
+				delete tempWidget->widget();
+				delete tempWidget;
+			}
+		}
+
+		m_ClipLayout->removeItem(tempWidget);
+		m_ClipLayout->update();
+
+		layouts.pop_back();
+		m_StartFrameLines.pop_back();
+		m_EndFrameLines.pop_back();
+        m_AnimationClipName.pop_back();
+	}
 }
 
 void Menu::ExportAll(bool)
 {
-	MDagPath path;
+    if (m_ExportPath->text().isEmpty()) {
+        MGlobal::displayError(MString() + "Please select a folder.");
+        return;
+    }
 
-	// Loop through all nodes in the scene
-	MItDependencyNodes it(MFn::kInvalid);
-	for (;!it.isDone();it.next())
-	{
-		MObject node = it.thisNode();
-		if (node.hasFn(MFn::kMesh))
-		{
-			MFnDependencyNode thisNode(node);
+    //Export meshes
+    if (!m_Export.Meshes(m_ExportPath->text().toLocal8Bit().constData(), m_ExportSelectedButton->isChecked())) {
+        MGlobal::displayError(MString() + "Could not export mesh");
+        return;
+    }
 
-			cout << thisNode.name().asChar() << endl;
-			GetMeshData(node);
+    if (m_ExportMaterialButton->isChecked()) {
+        if (!m_Export.Materials(m_ExportPath->text().toLocal8Bit().constData())) {
+            MGlobal::displayError(MString() + "Could not export materials");
+            return;
+        }
+    }
+
+    std::vector<Export::AnimationInfo> animations;
+    for (unsigned int i = 0; i < m_AnimationClipName.size(); i++) {
+        Export::AnimationInfo thisClip;
+        thisClip.Name = std::string(m_AnimationClipName[i]->text().toLocal8Bit().constData());
+        thisClip.Start = m_StartFrameLines[i]->text().toInt();
+        thisClip.End = m_EndFrameLines[i]->text().toInt();
+
+        animations.push_back(thisClip);
+    }
+    if (m_ExportAnimationsButton->isChecked()) {
+        //Export Animations
+        if (!m_Export.Animations(m_ExportPath->text().toLocal8Bit().constData(), animations)) {
+            MGlobal::displayError(MString() + "Could not export animations");
+            return;
         }
     }
-	if (exportPath->text().isEmpty())
-		cout << "Please select a folder." << endl;
-	else
-		cout << exportPath->text().toLocal8Bit().constData() << endl;
 }
 
 void Menu::CancelClicked(bool)
 {
-	dialogPointer->close();
-}
-
-void Menu::Button1Clicked(bool)
-{
-	if(exportAnimationsButton->isChecked())
-		cout << "1 checked!" << endl;
-	else
-		cout << "1 unchecked!" << endl;
-}
-
-void Menu::Button2Clicked(bool)
-{
-	if (copyTexturesButton->isChecked())
-		cout << "2 checked!" << endl;
-	else
-		cout << "2 unchecked!" << endl;
-}
-
-void Menu::Button3Clicked(bool)
-{
-	if (button3->isChecked())
-		cout << "3 checked!" << endl;
-	else
-		cout << "3 unchecked!" << endl;
-}
-
-void Menu::GetMeshData(MObject object)
-{
-	// In here, we retrieve triangulated polygons from the mesh
-	MFnMesh mesh(object);
-
-	map<UINT, vector<UINT>> vertexToIndex;
-
-	vector<VertexLayout> verticesData;
-	vector<UINT>indexArray;
-
-	MIntArray intdexOffsetVertexCount, vertices, triangleList;
-	MPointArray dummy;
-
-	UINT vertexIndex;
-	MVector normal;
-	MPoint pos;
-	float2 UV;
-	VertexLayout thisVertex;
-
-	for (MItMeshPolygon meshPolyIter(object); !meshPolyIter.isDone(); meshPolyIter.next())
-	{
-		vector<UINT> localVertexToGlobalIndex;
-		meshPolyIter.getVertices(vertices);
-
-		meshPolyIter.getTriangles(dummy, triangleList);
-		UINT indexOffset = verticesData.size();
-
-		for (UINT i = 0; i < vertices.length(); i++)
-		{
-			vertexIndex = meshPolyIter.vertexIndex(i);
-			pos = meshPolyIter.point(i);
-			pos.get(thisVertex.pos);
-
-			meshPolyIter.getNormal(i, normal);
-			thisVertex.normal[0] = normal[0];
-			thisVertex.normal[1] = normal[1];
-			thisVertex.normal[2] = normal[2];
-
-			meshPolyIter.getUV(i, UV);
-			thisVertex.uv[0] = UV[0];
-			thisVertex.uv[1] = UV[1];
-
-			verticesData.push_back(thisVertex);
-			localVertexToGlobalIndex.push_back(vertexIndex);
-
-			cout << "Pos: " << thisVertex.pos[0] << "/" << thisVertex.pos[1] << "/" << thisVertex.pos[2] << endl;
-			cout << "Normals: " << thisVertex.normal[0] << "/" << thisVertex.normal[1] << "/" << thisVertex.normal[2] << endl;
-			cout << "UV: " << thisVertex.uv[0] << "/" << thisVertex.uv[1] << endl;
-		}
-		for (UINT i = 0; i < triangleList.length(); i++)
-		{
-			UINT k = 0;
-			while (localVertexToGlobalIndex[k] != triangleList[i])
-				k++;
-			indexArray.push_back(indexOffset + k);
-		}
-	}
-	
-}
-
-void Menu::exportMaterial(MObject object)
-{
-	MItDependencyNodes matIt(MFn::kLambert);
-
-
+	m_DialogPointer->close();
 }
 
 Menu::~Menu()
@@ -235,5 +212,8 @@ Menu::~Menu()
 	//delete browseButton;
 	//delete exportPath;
 	//delete fileDialog;
-	fileDialog->~QFileDialog();
+	m_FileDialog->~QFileDialog();
+
+    //delete m_Export;
+	//delete MaterialHandler;
 }

tools/MayaExporter/MayaExporter/Menu.h

@@ -1,10 +1,9 @@
-#ifndef BUTTONS_H
-#define BUTTONS_H
+#ifndef Menu_Menu_h__
+#define Menu_Menu_h__
 
 #include <map>
 #include <vector>
 
-#include "MayaIncludes.h"
 // Qt
 #pragma comment(lib, "QtCore4")
 #pragma comment(lib, "QtGui4")
@@ -30,13 +29,11 @@
 #include <QtGui/qfiledialog.h>
 #include <QtGui/qlineedit.h>
 #include <QtGui/qgroupbox.h>
+#include <QtGui/qlayoutitem.h>
+#include <QtGui/qtabwidget.h>
 
-struct VertexLayout
-{
-	float pos[3];
-	float normal[3];
-	float uv[2];
-};
+#include "MayaIncludes.h"
+#include "Export.h"
 
 class Menu : public QWidget
 {
@@ -45,35 +42,36 @@ public:
 	Menu(QDialog* dialog);
 	~Menu();
 
-	void GetMeshData(MObject object);
-	void exportMaterial(MObject object);
-
 private slots:
-	void ExportSelected(bool checked);
 	void ExportPathClicked(bool);
+	void AddClipClicked(bool);
+	void RemoveClipClicked(bool);
 	void ExportAll(bool);
 	void CancelClicked(bool);
 
-	void Button1Clicked(bool);
-	void Button2Clicked(bool);
-	void Button3Clicked(bool);
-
-
 private:
 	Menu();
-	QPushButton* exportSelectedButton;
-	QPushButton* browseButton;
-	QPushButton* exportAllButton;
-	QPushButton* cancelButton;
+	std::vector<QLineEdit*> m_AnimationClipName;
+	std:: vector<QLineEdit*> m_StartFrameLines;
+	std::vector<QLineEdit*> m_EndFrameLines;
+	std::vector<QHBoxLayout*> layouts;
+	QVBoxLayout* m_ClipLayout;
 
-	QCheckBox* exportAnimationsButton;
-	QCheckBox* copyTexturesButton;
-	QCheckBox* button3;
+	QPushButton* m_BrowseButton = nullptr;
+	QPushButton* m_ExportAllButton = nullptr;
+	QPushButton* m_CancelButton = nullptr;
+	QPushButton* m_AddClipsButton = nullptr;
+	QPushButton* m_RemoveClipsButton = nullptr;
 
-	QLineEdit* exportPath;
-	QFileDialog* fileDialog;
-	QDialog* dialogPointer;
+    QCheckBox* m_ExportSelectedButton = nullptr;
+	QCheckBox* m_ExportAnimationsButton = nullptr;
+	QCheckBox* m_ExportMaterialButton = nullptr;
 
+	QLineEdit* m_ExportPath = nullptr;
+	QFileDialog* m_FileDialog = nullptr;
+	QDialog* m_DialogPointer = nullptr;
+
+    Export m_Export;
 };
 
 #endif

tools/MayaExporter/MayaExporter/Mesh.cpp

@@ -0,0 +1,402 @@
+#pragma once
+#include "Mesh.h"
+
+using namespace std;
+
+MeshClass::MeshClass()
+{
+
+}
+
+std::map<int, MeshClass::WeightInfo> MeshClass::GetWeightData()
+{
+    MS status;
+    map<int, WeightInfo> weightMap;
+
+	MItDependencyNodes it(MFn::kSkinClusterFilter);
+
+	while (!it.isDone()) {
+
+        MObject object = it.thisNode(&status);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + " it.thisNode() ERROR: " + status.errorString());
+            break;
+        }
+        MFnSkinCluster skinCluster(object, &status);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + "skinCluster() ERROR: " + status.errorString());
+            break;
+        }
+        MDagPathArray influences;
+
+        unsigned int nrOfInfluences = skinCluster.influenceObjects(influences,&status);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + "skinCluster.influenceObjects() ERROR: " + status.errorString());
+            break;
+        }
+
+        unsigned int index;
+        index = skinCluster.indexForOutputConnection(0,&status);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + "skinCluster.indexForOutputConnection() ERROR: " + status.errorString());
+            break;
+        }
+        MDagPath skinPath;
+        status = skinCluster.getPathAtIndex(index, skinPath);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + "skinCluster.getPathAtIndex() ERROR: " + status.errorString());
+            break;
+        }
+
+        MItGeometry geomIter(skinPath);
+        //for (unsigned int i = 0; i < nrOfInfluences; i++) {
+        //    MGlobal::displayInfo(MString() + " Influence object name: " + influences[i].partialPathName().asChar());
+        //}
+        WeightInfo weightInfo;
+
+        while (!geomIter.isDone()) {
+            MObject comp = geomIter.component(&status);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "geomIter.component() ERROR: " + status.errorString());
+                break;
+            }
+            MFloatArray weights;
+            unsigned int influenceCount;
+            status = skinCluster.getWeights(skinPath, comp, weights, influenceCount);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "skinCluster.getWeights() ERROR: " + status.errorString());
+                break;
+            }
+            MFnDependencyNode test(comp);
+            unsigned int nrOfWeights = 0;
+
+            for (unsigned int j = 0; j < weights.length() && nrOfWeights != 4; j++) {
+                if (weights[j] > 0.00001) {
+                    weightInfo.BoneWeights[nrOfWeights] = weights[j];
+                    weightInfo.BoneIndices[nrOfWeights] = j;
+                    nrOfWeights++;
+                }
+            }
+
+            float totalWeight = 0.0f;
+            for (unsigned int i = 0; i < 4; i++) {
+                totalWeight += weightInfo.BoneWeights[i];
+            }
+            for (unsigned int i = 0; i < 4; i++) {
+                weightInfo.BoneWeights[i] /= totalWeight;
+            }
+            weightMap[geomIter.index()] = weightInfo;
+
+
+            for (unsigned int k = 0; k!=nrOfWeights; k++) {
+                MGlobal::displayInfo(MString() + "influence: " + weightInfo.BoneIndices[k] + " weight: " + weightInfo.BoneWeights[k]);
+            }
+            geomIter.next();
+        }
+        it.next();
+	}
+    return weightMap;
+}
+
+Mesh MeshClass::GetMeshData(MObjectArray object)
+{
+    MS status;
+    Mesh newMesh;
+    vector<VertexLayout>& vertexList = newMesh.Vertices;
+    map<string, vector<int>>& indexLists = newMesh.Indices;
+    for (int ObjectID = 0; ObjectID < object.length(); ObjectID++) {
+        if (!object[ObjectID].hasFn(MFn::kMesh))
+            continue;
+
+        MObject node = object[ObjectID];
+        MFnDependencyNode thisNode(node);
+        MPlugArray connections;
+        thisNode.findPlug("inMesh").connectedTo(connections, true, true);
+        MGlobal::displayInfo(MString() + "inMesh");
+        bool hasSkin = false;
+        MPlug weightList, weights;
+        MObject weightListObject;
+        for (unsigned int i = 0; i < connections.length(); i++) {
+            if (connections[i].node().apiType() == MFn::kSkinClusterFilter) {
+                MFnSkinCluster skinCluster(connections[i].node());
+                weightList = skinCluster.findPlug("weightList", &status);
+                weightListObject = weightList.attribute();
+                weights = skinCluster.findPlug("weights");
+                hasSkin = true;
+                break;
+            }
+        }
+
+
+        // In here, we retrieve triangulated polygons from the mesh
+        MFnMesh mesh(object[ObjectID]);
+        MDagPathArray dagPaths;
+        status = MDagPath::getAllPathsTo(object[ObjectID], dagPaths);
+        if (status != MS::kSuccess) {
+            MGlobal::displayError(MString() + "MDagPath::getAllPathsTo() ERROR: " + status.errorString());
+            break;
+        }
+
+        for (int pathID = 0; pathID < dagPaths.length(); pathID++) {
+            MGlobal::displayInfo(dagPaths[pathID].fullPathName());
+            MDagPath thisMeshPath(dagPaths[pathID]);
+
+            MMatrix transformMatrix = thisMeshPath.inclusiveMatrix(&status);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "thisMeshPath.inclusiveMatrix() ERROR: " + status.errorString() + " for " + thisMeshPath.fullPathName());
+                break;
+            }
+
+            map<unsigned int, vector<unsigned int>> vertexToIndex;;
+
+            MIntArray intdexOffsetVertexCount, vertices, triangleList;
+            MPointArray dummy;
+            unsigned int vertexIndex;
+            MVector normal;
+            MPoint pos;
+            float2 UV;
+            double biTangent[3];
+            double biNormal[3];
+            MFloatVectorArray Tangents;
+            MFloatVectorArray biNormals;
+
+            MObjectArray shaderList;
+            MIntArray shaderIndexList;
+            status = mesh.getConnectedShaders(0, shaderList, shaderIndexList);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "mesh.getConnectedShaders() ERROR: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                break;
+            }
+
+            if (shaderList.length() == 0) {
+                MGlobal::displayError(MString() + "Object: \"" + thisMeshPath.fullPathName() + "\" have no material and will not be exported");
+                break;
+            }
+            map<string, vector<int>> materialFaceIDs;
+            MGlobal::displayInfo(MString() + "shaderIndexList: " + shaderIndexList.length());
+            MGlobal::displayInfo(MString() + "shaderList: " + shaderList.length());
+            MPlugArray plugArray;
+            for (int i = 0; i < shaderIndexList.length(); i++) {
+                MFnDependencyNode shader(shaderList[shaderIndexList[i]]);
+                MPlug p_Plug = shader.findPlug("surfaceShader", status);
+                if (status != MS::kSuccess) {
+                    MGlobal::displayError(MString() + "shader.findPlug(\"surfaceShader\") ERROR: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                    continue;
+                }
+                if (p_Plug.connectedTo(plugArray, true, false, &status)) {
+                    if (status != MS::kSuccess) {
+                        MGlobal::displayError(MString() + "p_Plug.connectedTo() ERROR in if: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                        continue;
+                    }
+                    MFnDependencyNode node = plugArray[0].node();
+                    materialFaceIDs[node.name().asChar()].push_back(i);
+                }
+                if (status != MS::kSuccess) {
+                    MGlobal::displayError(MString() + "p_Plug.connectedTo() ERROR: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                    continue;
+                }
+            }
+
+           // map<int, WeightInfo> vertexWeights = GetWeightData();
+            status = mesh.getTangents(Tangents, MSpace::kObject);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "mesh.getTangents ERROR: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                continue;
+            }
+            status = mesh.getBinormals(biNormals, MSpace::kObject);
+            if (status != MS::kSuccess) {
+                MGlobal::displayError(MString() + "mesh.getBinormals ERROR: " + status.errorString()  + " for " + thisMeshPath.fullPathName());
+                continue;
+            }
+            if(Tangents.length() == 0 || biNormals.length() == 0){
+                MGlobal::displayError(MString() + "Unknown ERROR with " + thisMeshPath.fullPathName());
+                continue;
+            }
+            MItMeshFaceVertex faceVert(object[ObjectID]);
+            int intDummy = 0;
+
+            MItMeshPolygon meshPolyIter(object[ObjectID]);
+            MFloatPointArray positions;
+
+            mesh.getPoints(positions);
+
+            for (auto aMaterial : materialFaceIDs) {
+                for (auto faceID : aMaterial.second) {
+                    vector<array<unsigned int, 2>> localVertexToGlobalIndex;
+
+                    status = meshPolyIter.setIndex(faceID, intDummy);
+                    if (status != MS::kSuccess) {
+                        MGlobal::displayError(MString() + " meshPolyIter.setIndex() ERROR: " + status.errorString() +  " for faceID " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                        break;
+                    }
+
+                    status = meshPolyIter.getVertices(vertices);
+                    if (status != MS::kSuccess) {
+                        MGlobal::displayError(MString() + "  meshPolyIter.getVertices() ERROR: " + status.errorString() +  " for faceID " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                        break;
+                    }
+
+                    status = meshPolyIter.getTriangles(dummy, triangleList);
+                    if (status != MS::kSuccess) {
+                        MGlobal::displayError(MString() + "  meshPolyIter.getTriangles() ERROR: " + status.errorString() +  " for faceID " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                        break;
+                    }
+                    //MGlobal::displayInfo("Befor Second Loop");
+                    for (unsigned int i = 0; i < vertices.length(); i++) {
+                        VertexLayout thisVertex;
+
+                        vertexIndex = meshPolyIter.vertexIndex(i, &status);
+                        if (status != MS::kSuccess) {
+                            MGlobal::displayError(MString() + "  meshPolyIter.vertexIndex() ERROR: " + status.errorString() + "for local vertex " + i + " in " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                            break;
+                        }
+
+                        status = faceVert.setIndex(meshPolyIter.index(), i, intDummy, intDummy);
+                        if (status != MS::kSuccess) {
+                            MGlobal::displayError(MString() + "faceVert.setIndex() ERROR: " + status.errorString() + "for local vertex " + i + " in " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                            break;
+                        }
+                        //MGlobal::displayInfo("In Second Loop");
+                        //pos = faceVert.position(MSpace::kTransform);
+                        //mesh.getPoint(vertexIndex, pos, MSpace::kPostTransform);
+                        pos = positions[vertexIndex];
+                        pos = pos * transformMatrix;
+                        if (abs(pos.x) > 0.0001)
+                            thisVertex.Pos[0] = pos.x;
+                        if (abs(pos.y) > 0.0001)
+                            thisVertex.Pos[1] = pos.y;
+                        if (abs(pos.z) > 0.0001)
+                            thisVertex.Pos[2] = pos.z;
+
+                        status = faceVert.getNormal(normal, MSpace::kObject);
+                        if (status != MS::kSuccess) {
+                            MGlobal::displayError(MString() + "faceVert.getNormal() ERROR: " + status.errorString() + "for local vertex " + i + " in " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                            break;
+                        }
+                        if (abs(normal[0]) > 0.0001)
+                            thisVertex.Normal[0] = normal[0];
+                        if (abs(normal[1]) > 0.0001)
+                            thisVertex.Normal[1] = normal[1];
+                        if (abs(normal[2]) > 0.0001)
+                            thisVertex.Normal[2] = normal[2];
+
+                        MFloatVector Tangent = Tangents[faceVert.tangentId()];
+                        //MVector tmp = faceVert.getTangent(MSpace::kObject, NULL);
+                        //tmp.get(biTangent);
+                        if (abs(Tangent[0]) > 0.0001)
+                            thisVertex.Tangent[0] = Tangent[0];
+                        if (abs(Tangent[1]) > 0.0001)
+                            thisVertex.Tangent[1] = Tangent[1];
+                        if (abs(Tangent[2]) > 0.0001)
+                            thisVertex.Tangent[2] = Tangent[2];
+
+                        MFloatVector biNormal = biNormals[faceVert.tangentId()];
+                        //faceVert.getBinormal().get(biNormal);
+                        if (abs(biNormal[0]) > 0.0001)
+                            thisVertex.BiNormal[0] = biNormal[0];
+                        if (abs(biNormal[1]) > 0.0001)
+                            thisVertex.BiNormal[1] = biNormal[1];
+                        if (abs(biNormal[2]) > 0.0001)
+                            thisVertex.BiNormal[2] = biNormal[2];
+
+                        status = faceVert.getUV(UV);
+                        if (status != MS::kSuccess) {
+                            MGlobal::displayError(MString() + " faceVert.getUV() ERROR: " + status.errorString() + "for local vertex " + i + " in " + faceID + " in mesh " + thisMeshPath.fullPathName());
+                            break;
+                        }
+                        thisVertex.Uv[0] = UV[0];
+                        thisVertex.Uv[1] = UV[1];
+
+                        
+                        if (hasSkin) {
+                            float totalWeight = 0.0f;
+                            unsigned int totalBones = 0;
+                            MIntArray jointIDs /* ??? */;
+                            weights.selectAncestorLogicalIndex(vertexIndex, weightListObject);
+                            weights.getExistingArrayAttributeIndices(jointIDs);
+                            for (unsigned int i = 0; i < jointIDs.length() && i < 4; i++) {
+                                if (weights[i].asFloat() > 0.001f) {
+                                    thisVertex.BoneIndices[totalBones] = jointIDs[i];
+                                    thisVertex.BoneWeights[totalBones] = weights[i].asFloat();
+                                    totalWeight = totalWeight + weights[i].asFloat();
+                                    totalBones++;
+                                }
+                            }
+                           
+                            for (unsigned int i = 0; i < 4; i++) {
+                                thisVertex.BoneWeights[i] = thisVertex.BoneWeights[i] / totalWeight;
+                            }
+                        }
+
+                        //float totalWeight = thisVertex.BoneWeights[0] + thisVertex.BoneWeights[1] + thisVertex.BoneWeights[2] + thisVertex.BoneWeights[3];
+                        //if (totalWeight > 0.0001f) {
+                        //    thisVertex.BoneWeights[0] /= totalWeight;
+                        //    thisVertex.BoneWeights[1] /= totalWeight;
+                        //    thisVertex.BoneWeights[2] /= totalWeight;
+                        //    thisVertex.BoneWeights[3] /= totalWeight;
+                        //}
+
+                        std::vector<VertexLayout>::iterator it = std::find(vertexList.begin(), vertexList.end(), thisVertex);
+                        array<unsigned int, 2> tmp;
+                        if (it != vertexList.end()) {
+                            tmp[0] = vertexIndex;
+                            tmp[1] = it - vertexList.begin();
+                            localVertexToGlobalIndex.push_back(tmp);
+                        } else {
+                            tmp[0] = vertexIndex;
+                            tmp[1] = vertexList.size();
+                            localVertexToGlobalIndex.push_back(tmp);
+                            vertexList.push_back(thisVertex);
+                        }
+                        //MGlobal::displayInfo(MString() + "localVertexToGlobalIndex[localVertexToGlobalIndex.size()-1]: " + localVertexToGlobalIndex[localVertexToGlobalIndex.size()-1][0] + " " + localVertexToGlobalIndex[localVertexToGlobalIndex.size()-1][1]);
+                        //cout << "Pos: " << thisVertex.Pos[0] << "/" << thisVertex.Pos[1] << "/" << thisVertex.Pos[2] << endl;
+                        //cout << "Normals: " << thisVertex.Normal[0] << "/" << thisVertex.Normal[1] << "/" << thisVertex.Normal[2] << endl;
+                        //cout << "Bi-Normals: " << thisVertex.BiNormal[0] << "/" << thisVertex.BiNormal[1] << "/" << thisVertex.BiNormal[2] << endl;
+                        //cout << "Bi-Tangents: " << thisVertex.BiTangent[0] << "/" << thisVertex.BiTangent[1] << "/" << thisVertex.BiTangent[2] << endl;
+                        //cout << "UV: " << thisVertex.Uv[0] << "/" << thisVertex.Uv[1] << endl;
+                    }
+                    for (unsigned int i = 0; i < triangleList.length(); i++) {
+                        unsigned int  k = 0;
+                        if (localVertexToGlobalIndex.size() > 0) {
+                            //MGlobal::displayInfo(MString() + "triangleList[i] : " + triangleList[i]);
+                            while (localVertexToGlobalIndex[k][0] != triangleList[i] && k < localVertexToGlobalIndex.size()) {
+                                k++;
+                            }
+                            //MGlobal::displayInfo(MString() + "localVertexToGlobalIndex[k] : " + localVertexToGlobalIndex[k][0] + " " + localVertexToGlobalIndex[k][1]);
+                            indexLists[aMaterial.first.c_str()].push_back(localVertexToGlobalIndex[k][1]);
+                        }
+                    }
+                }
+                //  MGlobal::displayInfo( MString() + "localVertexToGlobalIndex.size(): " + localVertexToGlobalIndex.size());
+                //    if (localVertexToGlobalIndex.size() > 0) {
+                //        MGlobal::displayInfo(MString() + "triangleList.length(): " + triangleList.length());
+                //        for (unsigned int i = triangleList.length() - 1; i >= 0; i--) {
+                //            MGlobal::displayInfo(MString() + "i: " + i);
+                //            unsigned int  k = localVertexToGlobalIndex.size() - 1;
+                //            MGlobal::displayInfo(MString() + "triangleList[i] : " + triangleList[i]);
+                //            while (localVertexToGlobalIndex[k] != triangleList[i] && k >= 0) {
+                //                MGlobal::displayInfo(MString() + "k: " + k);
+                //                k--;
+                //            }
+                //            MGlobal::displayInfo(MString() + "localVertexToGlobalIndex[k] : " + localVertexToGlobalIndex[k]);
+                //            indexList.push_back(indexOffset + k);
+                //        }
+                //    }
+            }
+        }
+    }
+
+    int totalIndices = 0;
+    for (auto aList : newMesh.Indices) {
+        totalIndices += aList.second.size();
+    }
+    newMesh.NumIndices = totalIndices;
+    newMesh.NumVertices = newMesh.Vertices.size();
+
+    return newMesh;
+}
+
+MeshClass::~MeshClass()
+{
+
+}

tools/MayaExporter/MayaExporter/Mesh.h

@@ -0,0 +1,117 @@
+#ifndef Mesh_Mesh_h__
+#define Mesh_Mesh_h__
+
+#include <map>
+#include <vector>
+#include <array>
+
+#include "OutputData.h"
+#include "MayaIncludes.h"
+
+class VertexLayout : public OutputData
+{
+public:
+    float Pos[3]{ 0 };
+	float Normal[3]{ 0 };
+	float Tangent[3]{ 0 };
+	float BiNormal[3]{ 0 };
+	float Uv[2]{ 0 };
+	float BoneIndices[4]{ 0 };
+	float BoneWeights[4]{ 0 };
+
+    virtual void WriteBinary(std::ostream& out)
+    {
+        out.write((char*)&Pos, sizeof(float) * 3);
+        out.write((char*)&Normal, sizeof(float) * 3);
+        out.write((char*)&Tangent, sizeof(float) * 3);
+        out.write((char*)&BiNormal, sizeof(float) * 3);
+        out.write((char*)&Uv, sizeof(float) * 2);
+        out.write((char*)&BoneIndices, sizeof(float) * 4);
+        out.write((char*)&BoneWeights, sizeof(float) * 4);
+    }
+
+    virtual void WriteASCII(std::ostream& out) const
+    {
+        out <<  Pos[0] << " " << Pos[1]  << " " << Pos[2] << endl;
+        out <<  Normal[0] << " " << Normal[1]  << " " << Normal[2] << endl;
+        out <<  Tangent[0] << " " << Tangent[1]  << " " << Tangent[2] << endl;
+        out <<  BiNormal[0] << " " << BiNormal[1]  << " " << BiNormal[2] << endl;
+        out <<  Uv[0] << " " << Uv[1]  << endl;
+        out <<  BoneIndices[0] << " " << BoneIndices[1]  << " " << BoneIndices[2] << " " << BoneIndices[3] << endl;
+        out <<  BoneWeights[0] << " " << BoneWeights[1]  << " " << BoneWeights[2] << " " << BoneWeights[3] << endl;
+
+    }
+    bool operator==(const VertexLayout& right)
+    {
+        return
+            this->Pos[0] == right.Pos[0] &&  this->Pos[1] == right.Pos[1] &&  this->Pos[2] == right.Pos[2] &&
+            this->Normal[0] == right.Normal[0] &&  this->Normal[1] == right.Normal[1] &&  this->Normal[2] == right.Normal[2] &&
+            this->Tangent[0] == right.Tangent[0] &&  this->Tangent[1] == right.Tangent[1] &&  this->Tangent[2] == right.Tangent[2] &&
+            this->BiNormal[0] == right.BiNormal[0] &&  this->BiNormal[1] == right.BiNormal[1] &&  this->BiNormal[2] == right.BiNormal[2] &&
+            this->Uv[0] == right.Uv[0] &&  this->Uv[1] == right.Uv[1] &&
+            this->BoneIndices[0] == right.BoneIndices[0] &&  this->BoneIndices[1] == right.BoneIndices[1] &&  this->BoneIndices[2] == right.BoneIndices[2] && this->BoneIndices[3] == right.BoneIndices[3] &&
+            this->BoneWeights[0] == right.BoneWeights[0] &&  this->BoneWeights[1] == right.BoneWeights[1] &&  this->BoneWeights[2] == right.BoneWeights[2] && this->BoneWeights[3] == right.BoneWeights[3]
+            ;
+    }
+};
+
+class Mesh : public OutputData {
+public:
+    unsigned int NumVertices;
+    unsigned int NumIndices;
+    std::vector<VertexLayout> Vertices;
+    std::map<std::string, std::vector<int>> Indices;
+
+    virtual void WriteBinary(std::ostream& out)
+    {
+        out.write((char*)&NumVertices, sizeof(int));
+        out.write((char*)&NumIndices, sizeof(int));
+        for (auto aVertex : Vertices) {
+            aVertex.WriteBinary(out);
+        }
+        for (auto aIndex : Indices) {
+        //for (std::map<std::string, std::vector<int>>::reverse_iterator aIndex = Indices.rbegin(); aIndex != Indices.rend(); aIndex++){
+            //out.write((char*)(*aIndex).second.data(), sizeof(int) * (*aIndex).second.size());
+            out.write((char*)aIndex.second.data(), sizeof(int) * aIndex.second.size());
+        }
+    }
+
+    virtual void WriteASCII(std::ostream& out) const
+    {
+        out << "New Mesh _ not in binary" << endl;
+        out << "Number of vertices: " << NumVertices << endl;
+        out << "number of indices: " << NumIndices << endl;
+        int vertexNumber = 0;
+        for (auto aVertex : Vertices) {
+            out << "New vertex number: " << vertexNumber <<  " _ not in binary" << endl;
+            aVertex.WriteASCII(out);
+            vertexNumber++;
+        }
+        out << "New vertex Triangels: " << NumIndices/3 <<  " _ not in binary" << endl;
+        for (auto aIndexList : Indices) {
+            out << "Using Material: " << aIndexList.first << " _ not in binary" << endl;
+            for (int i = 0; i < aIndexList.second.size(); i += 3) {
+                out << aIndexList.second[i] << " " << aIndexList.second[i+1] << " " << aIndexList.second[i + 2] << endl;
+            }
+        }
+    }
+};
+
+
+
+class MeshClass
+{
+public:
+    MeshClass();
+    Mesh GetMeshData(MObjectArray Object);
+    ~MeshClass();
+private:
+    struct WeightInfo {
+        float BoneIndices[4] = { 0 };
+        float BoneWeights[4] = { 0 };
+    };
+    std::map<int, WeightInfo>  GetWeightData();
+
+};
+
+#endif