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

include/Engine/Core/ComponentInfo.h

@@ -14,6 +14,7 @@ struct ComponentInfo
 
     struct Field_t
     {
+        std::string Name;
         std::string Type;
         unsigned int Offset;
         unsigned int Stride;
@@ -21,7 +22,7 @@ struct ComponentInfo
 
 	std::string Name;
     std::unordered_map<std::string, Field_t> Fields;
-    std::vector<const Field_t*> FieldsInOrder;
+    std::vector<std::string> FieldsInOrder;
 	Meta_t Meta;
     std::shared_ptr<char> Defaults = nullptr;
 };

include/Engine/Core/Transform.h

@@ -4,59 +4,14 @@
 #include "../GLM.h"
 #include "World.h"
 
-static class Transform
+namespace Transform
 {
-public:
-    static glm::vec3 AbsolutePosition(World* world, EntityID entity)
-    {
-        glm::vec3 position;
 
-        while (entity != EntityID_Invalid) {
+glm::vec3 AbsolutePosition(World* world, EntityID entity);
-            ComponentWrapper transform = world->GetComponent(entity, "Transform");
+glm::quat AbsoluteOrientation(World* world, EntityID entity);
-            EntityID parent = world->GetParent(entity);
+glm::vec3 AbsoluteScale(World* world, EntityID entity);
-            position += AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"];
+glm::mat4 ModelMatrix(EntityID entity, World* world);
-            entity = parent;
-        }
 
-        return position;
+}
-    };
-
-    static glm::quat AbsoluteOrientation(World* world, EntityID entity)
-    {
-        glm::quat orientation;
-
-        while (entity != EntityID_Invalid) {
-            ComponentWrapper transform = world->GetComponent(entity, "Transform");
-            orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
-            entity = world->GetParent(entity);
-        }
-
-        return orientation;
-    };
-
-    static glm::vec3 AbsoluteScale(World* world, EntityID entity)
-    {
-        glm::vec3 scale(1.f);
-
-        while (entity != EntityID_Invalid) {
-            ComponentWrapper transform = world->GetComponent(entity, "Transform");
-            scale *= (glm::vec3)transform["Scale"];
-            entity = world->GetParent(entity);
-        }
-
-        return scale;
-    };
-
-    static glm::mat4 ModelMatrix(EntityID entity, World* world)
-    {
-        glm::vec3 position = Transform::AbsolutePosition(world, entity);
-        glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
-        glm::vec3 scale = Transform::AbsoluteScale(world, entity);
-
-        glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
-        return modelMatrix;
-    }
-
-};
 
 #endif

include/Engine/Network/Client.h

@@ -23,7 +23,6 @@ public:
     ~Client();
     void Start(World* world, EventBroker* eventBroker) override;
     void Update() override;
-    void Close();
 private:
     // Assio UDP logic
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
@@ -32,7 +31,7 @@ private:
 
     // Sending message to server logic
     int bytesRead = -1;
-    char readBuf[1024] = { 0 };
+    char readBuf[INPUTSIZE] = { 0 };
     int snapshotInterval = 33;
     std::clock_t previousSnapshotMessage = std::clock();
 
@@ -49,7 +48,6 @@ private:
     // Network logic
     PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
     SnapshotDefinitions m_NextSnapshot;
-    bool m_ThreadIsRunning = true;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
     // Use to check if we should send disconnect message
@@ -59,7 +57,7 @@ private:
     // Private member functions
     void readFromServer();
     void sendSnapshotToServer();
-    int receive(char* data, size_t length);
+    int  receive(char* data, size_t length);
     void send(Packet& packet);
     void connect();
     void disconnect();
@@ -67,6 +65,7 @@ private:
     void moveMessageHead(char*& data, size_t& length, size_t stepSize);
     void parseMessageType(Packet& packet);
     void parseEventMessage(Packet& packet);
+    void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
     void parseConnect(Packet& packet);
     void parsePing();
     void parseServerPing();

include/Engine/Network/Network.h

@@ -6,7 +6,7 @@
 #include "Network/Packet.h"
 
 #define MAXCONNECTIONS 8
-#define INPUTSIZE 128
+#define INPUTSIZE 4097
 
 class Network
 {

include/Engine/Network/Packet.h

@@ -14,15 +14,17 @@ public:
     Packet(MessageType type, unsigned int& packetID);
     // Used to create packet from already existing data buffer.
     Packet(char* data, const int sizeOfPacket);
-    
     ~Packet();
+    void Init(MessageType type, unsigned int& packetID);
+
     // Add primitive types like int, float, char...
     template<typename T>
     void WritePrimitive(T val)
     {
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
-            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for!");
+            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for! New size is %i bytes\n", m_MaxPacketSize*2);
+            resizeData();
         }
         memcpy(m_Data + m_Offset, &val, sizeof(T));
         m_Offset += sizeof(T);
@@ -41,7 +43,7 @@ public:
         return returnValue;
     }
     // Add a string to the message
-    void WriteString(std::string str);
+    void WriteString(const std::string& str);
     // Add data to the message
     void WriteData(char* data, int sizeOfData);
     // Pops the first element as if it was a string.
@@ -50,12 +52,15 @@ public:
 
     int Size() { return m_Offset; };
     char* Data() { return m_Data; };
+    unsigned int DataReadSize() { return m_ReturnDataOffset; }
+    unsigned int MaxSize() { return m_MaxPacketSize; }
 
 private:
     char* m_Data;
     unsigned int m_ReturnDataOffset = 0;
     int m_Offset = 0;
-    unsigned int m_MaxPacketSize = 128;
+    unsigned int m_MaxPacketSize = 512;
+    void resizeData();
 };
 
 #endif

include/Engine/Network/Server.h

@@ -20,8 +20,6 @@ public:
     ~Server();
     void Start(World* m_world, EventBroker *eventBroker) override;
     void Update() override;
-    void Close();
-
 private:
     // UDP logic
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
@@ -30,7 +28,7 @@ private:
     PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
 
     // Sending messages to client logic
-    char readBuffer[1024] = { 0 };
+    char readBuffer[INPUTSIZE] = { 0 };
     int bytesRead = 0;
     // time for previouse message
     std::clock_t previousePingMessage = std::clock();
@@ -55,9 +53,6 @@ private:
     unsigned int m_PacketID;
     unsigned int m_PreviousPacketID;
     unsigned int m_SendPacketID;
-    
-    // Close logic
-    bool m_ThreadIsRunning = true;
 
     // Private member functions
     int  receive(char* data, size_t length);

include/Engine/Rendering/RenderSystem.h

@@ -14,22 +14,24 @@
 #include "ModelJob.h"
 #include "Renderer.h"
 #include "../Core/Transform.h"
+#include "DebugCameraInputController.h"
 
 class RenderSystem : public ImpureSystem
 {
 public:
     RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
+    ~RenderSystem();
 
     virtual void Update(World* world, double dt) override;
 
 private:
     World* m_World = nullptr;
-    const IRenderer* m_Renderer = nullptr;
+    const IRenderer* m_Renderer;
 
     RenderFrame* m_RenderFrame;
     bool m_SwitchCamera = false;
-    Camera* m_Camera = nullptr;
+    Camera* m_Camera;
-    Camera* m_DefaultCamera = nullptr;
+    DebugCameraInputController<RenderSystem>* m_DebugCameraInputController;
     
     std::list<ComponentWrapper> m_CameraComponents;
 
@@ -41,8 +43,6 @@ private:
 
     void updateCamera(World* world, double dt);
     void updateProjectionMatrix(ComponentWrapper& cameraComponent);
-    glm::mat4 m_ViewMatrix;
-    glm::mat4 m_ProjectionMatrix;
     
     void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);

src/Engine/Collision/Collision.cpp

@@ -8,196 +8,196 @@
 namespace Collision
 {
 
-    //note: this one hasnt been delta adjusted like RayVsAABB has
+//note: this one hasnt been delta adjusted like RayVsAABB has
-    bool RayAABBIntr(const Ray& ray, const AABB& box)
+bool RayAABBIntr(const Ray& ray, const AABB& box)
-    {
+{
-        glm::vec3 w = 75.0f * ray.Direction();
+    glm::vec3 w = 75.0f * ray.Direction();
-        glm::vec3 v = glm::abs(w);
+    glm::vec3 v = glm::abs(w);
-        glm::vec3 c = ray.Origin() - box.Center() + w;
+    glm::vec3 c = ray.Origin() - box.Center() + w;
-        glm::vec3 half = box.HalfSize();
+    glm::vec3 half = box.HalfSize();
 
-        if (abs(c.x) > v.x + half.x) {
+    if (abs(c.x) > v.x + half.x) {
-            return false;
+        return false;
-        }
-        if (abs(c.y) > v.y + half.y) {
-            return false;
-        }
-        if (abs(c.z) > v.z + half.z) {
-            return false;
-        }
-
-        if (abs(c.y*w.z - c.z*w.y) > half.y*v.z + half.z*v.y) {
-            return false;
-        }
-        if (abs(c.x*w.z - c.z*w.x) > half.x*v.z + half.z*v.x) {
-            return false;
-        }
-        return !(abs(c.x*w.y - c.y*w.x) > half.x*v.y + half.y*v.x);
     }
-
+    if (abs(c.y) > v.y + half.y) {
-    bool RayVsAABB(const Ray& ray, const AABB& box)
+        return false;
-    {
-        float dummy;
-        return RayVsAABB(ray, box, dummy);
     }
-
+    if (abs(c.z) > v.z + half.z) {
-    bool RayVsAABB(const Ray& ray, const AABB& box, float& outDistance)
-    {
-        glm::vec3 invdir = 1.0f / ray.Direction();
-        glm::vec3 origin = ray.Origin();
-
-        float t1 = (box.MinCorner().x - origin.x)*invdir.x;
-        float t2 = (box.MaxCorner().x - origin.x)*invdir.x;
-        float t3 = (box.MinCorner().y - origin.y)*invdir.y;
-        float t4 = (box.MaxCorner().y - origin.y)*invdir.y;
-        float t5 = (box.MinCorner().z - origin.z)*invdir.z;
-        float t6 = (box.MaxCorner().z - origin.z)*invdir.z;
-
-        float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6));
-        float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6));
-
-        //if (tmax < 0 || tmin > tmax)
-        //if tmin,tmax are almost the same (i.e. hitting exactly in the corner) then tmin might be slightly 
-        //greater than tmax becuase of floating-precision problems. fixed by adding a small delta to tmax
-        if (tmax < 0 || tmin>(tmax + 0.0001f))
-            return false;
-
-        outDistance = (tmin > 0) ? tmin : tmax;
-        return true;
-    }
-
-    bool AABBVsAABB(const AABB& a, const AABB& b)
-    {
-        const glm::vec3& aCenter = a.Center();
-        const glm::vec3& bCenter = b.Center();
-        const glm::vec3& aHSize = a.HalfSize();
-        const glm::vec3& bHSize = b.HalfSize();
-        //Test will probably exit because of the X and Z axes more often, so test them first.
-        if (abs(aCenter[0] - bCenter[0]) > (aHSize[0] + bHSize[0])) {
-            return false;
-        }
-        if (abs(aCenter[2] - bCenter[2]) > (aHSize[2] + bHSize[2])) {
-            return false;
-        }
-        return (abs(aCenter[1] - bCenter[1]) <= (aHSize[1] + bHSize[1]));
-    }
-
-    bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation)
-    {
-        minimumTranslation = glm::vec3(0, 0, 0);
-        const glm::vec3& aMax = a.MaxCorner();
-        const glm::vec3& bMax = b.MaxCorner();
-        const glm::vec3& aMin = a.MinCorner();
-        const glm::vec3& bMin = b.MinCorner();
-        const glm::vec3& bSize = b.Size();
-        const glm::vec3& aSize = a.Size();
-        float minOffset = INFINITY;
-        float off;
-        auto axisesIntersecting = glm::tvec3<bool, glm::highp>(false, false, false);
-        for (int i = 0; i < 3; ++i) {
-            off = bMax[i] - aMin[i];
-            if (off > 0 && off < bSize[i] + aSize[i]) {
-                if (off < minOffset) {
-                    minimumTranslation = glm::vec3();
-                    minimumTranslation[i] = minOffset = off;
-                }
-                axisesIntersecting[i] = true;
-            }
-            off = aMax[i] - bMin[i];
-            if (off > 0 && off < bSize[i] + aSize[i]) {
-                if (off < minOffset) {
-                    minOffset = off;
-                    minimumTranslation = glm::vec3();
-                    minimumTranslation[i] = -off;
-                }
-                axisesIntersecting[i] = true;
-            }
-        }
-        return glm::all(axisesIntersecting);
-    }
-
-    bool RayVsModel(const Ray& ray,
-        const std::vector<RawModel::Vertex>& modelVertices,
-        const std::vector<unsigned int>& modelIndices)
-    {
-        for (int i = 0; i < modelIndices.size(); ++i) {
-            glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-            glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
-            glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
-            glm::vec3 m = ray.Origin() - v0;
-            glm::vec3 MxE1 = glm::cross(m, e1);
-            glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);
-            float DetInv = glm::dot(e1, DxE2);
-            if (std::abs(DetInv) < FLT_EPSILON) {
-                continue;
-            }
-            DetInv = 1.0f / DetInv;
-            float u = glm::dot(m, DxE2) * DetInv;
-            float v = glm::dot(ray.Direction(), MxE1) * DetInv;
-            //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
-            if ((u + 0.001f) < 0 || (v + 0.001f) < 0 || 1 < u + v) {
-                continue;
-            }
-            //Here, u and v are positive, u+v <= 1, and if distance is positive - triangle is hit.
-            if (0 <= glm::dot(e2, MxE1) * DetInv) {
-                return true;
-            }
-        }
         return false;
     }
 
-    bool RayVsModel(const Ray& ray,
+    if (abs(c.y*w.z - c.z*w.y) > half.y*v.z + half.z*v.y) {
-        const std::vector<RawModel::Vertex>& modelVertices,
+        return false;
-        const std::vector<unsigned int>& modelIndices,
+    }
-        float& outDistance,
+    if (abs(c.x*w.z - c.z*w.x) > half.x*v.z + half.z*v.x) {
-        float& outUCoord,
+        return false;
-        float& outVCoord)
+    }
-    {
+    return !(abs(c.x*w.y - c.y*w.x) > half.x*v.y + half.y*v.x);
-        outDistance = INFINITY;
+}
-        bool hit = false;
-        for (int i = 0; i < modelIndices.size(); ++i) {
-            glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-            glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
-            glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
-            glm::vec3 m = ray.Origin() - v0;
-            glm::vec3 MxE1 = glm::cross(m, e1);
-            glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);//pVec
-            float DetInv = glm::dot(e1, DxE2);
-            if (std::abs(DetInv) < FLT_EPSILON) {
-                continue;
-            }
-            DetInv = 1.0f / DetInv;
-            float dist = glm::dot(e2, MxE1) * DetInv;
-            if (dist >= outDistance) {
-                continue;
-            }
-            float u = glm::dot(m, DxE2) * DetInv;
-            float v = glm::dot(ray.Direction(), MxE1) * DetInv;
 
-            //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
+bool RayVsAABB(const Ray& ray, const AABB& box)
-            //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
+{
-            if (0 <= (u + 0.001f) && 0 <= (v + 0.001f) && u + v <= 1 && 0 <= dist) {
+    float dummy;
-                outDistance = dist;
+    return RayVsAABB(ray, box, dummy);
-                outUCoord = u;
+}
-                outVCoord = v;
+
-                hit = true;
+bool RayVsAABB(const Ray& ray, const AABB& box, float& outDistance)
+{
+    glm::vec3 invdir = 1.0f / ray.Direction();
+    glm::vec3 origin = ray.Origin();
+
+    float t1 = (box.MinCorner().x - origin.x)*invdir.x;
+    float t2 = (box.MaxCorner().x - origin.x)*invdir.x;
+    float t3 = (box.MinCorner().y - origin.y)*invdir.y;
+    float t4 = (box.MaxCorner().y - origin.y)*invdir.y;
+    float t5 = (box.MinCorner().z - origin.z)*invdir.z;
+    float t6 = (box.MaxCorner().z - origin.z)*invdir.z;
+
+    float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6));
+    float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6));
+
+    //if (tmax < 0 || tmin > tmax)
+    //if tmin,tmax are almost the same (i.e. hitting exactly in the corner) then tmin might be slightly 
+    //greater than tmax becuase of floating-precision problems. fixed by adding a small delta to tmax
+    if (tmax < 0 || tmin>(tmax + 0.0001f))
+        return false;
+
+    outDistance = (tmin > 0) ? tmin : tmax;
+    return true;
+}
+
+bool AABBVsAABB(const AABB& a, const AABB& b)
+{
+    const glm::vec3& aCenter = a.Center();
+    const glm::vec3& bCenter = b.Center();
+    const glm::vec3& aHSize = a.HalfSize();
+    const glm::vec3& bHSize = b.HalfSize();
+    //Test will probably exit because of the X and Z axes more often, so test them first.
+    if (abs(aCenter[0] - bCenter[0]) > (aHSize[0] + bHSize[0])) {
+        return false;
+    }
+    if (abs(aCenter[2] - bCenter[2]) > (aHSize[2] + bHSize[2])) {
+        return false;
+    }
+    return (abs(aCenter[1] - bCenter[1]) <= (aHSize[1] + bHSize[1]));
+}
+
+bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation)
+{
+    minimumTranslation = glm::vec3(0, 0, 0);
+    const glm::vec3& aMax = a.MaxCorner();
+    const glm::vec3& bMax = b.MaxCorner();
+    const glm::vec3& aMin = a.MinCorner();
+    const glm::vec3& bMin = b.MinCorner();
+    const glm::vec3& bSize = b.Size();
+    const glm::vec3& aSize = a.Size();
+    float minOffset = INFINITY;
+    float off;
+    auto axisesIntersecting = glm::tvec3<bool, glm::highp>(false, false, false);
+    for (int i = 0; i < 3; ++i) {
+        off = bMax[i] - aMin[i];
+        if (off > 0 && off < bSize[i] + aSize[i]) {
+            if (off < minOffset) {
+                minimumTranslation = glm::vec3();
+                minimumTranslation[i] = minOffset = off;
             }
+            axisesIntersecting[i] = true;
+        }
+        off = aMax[i] - bMin[i];
+        if (off > 0 && off < bSize[i] + aSize[i]) {
+            if (off < minOffset) {
+                minOffset = off;
+                minimumTranslation = glm::vec3();
+                minimumTranslation[i] = -off;
+            }
+            axisesIntersecting[i] = true;
         }
-        return hit;
     }
+    return glm::all(axisesIntersecting);
+}
 
-    bool RayVsModel(const Ray& ray,
+bool RayVsModel(const Ray& ray,
-        const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<RawModel::Vertex>& modelVertices,
-        const std::vector<unsigned int>& modelIndices,
+    const std::vector<unsigned int>& modelIndices)
-        glm::vec3& outHitPosition)
+{
-    {
+    for (int i = 0; i < modelIndices.size(); ++i) {
-        float u;
+        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
-        float v;
+        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
-        float dist;
+        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
-        bool hit = RayVsModel(ray, modelVertices, modelIndices, dist, u, v);
+        glm::vec3 m = ray.Origin() - v0;
-        outHitPosition = ray.Origin() + dist * ray.Direction();
+        glm::vec3 MxE1 = glm::cross(m, e1);
-        return hit;
+        glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);
+        float DetInv = glm::dot(e1, DxE2);
+        if (std::abs(DetInv) < FLT_EPSILON) {
+            continue;
+        }
+        DetInv = 1.0f / DetInv;
+        float u = glm::dot(m, DxE2) * DetInv;
+        float v = glm::dot(ray.Direction(), MxE1) * DetInv;
+        //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
+        if ((u + 0.001f) < 0 || (v + 0.001f) < 0 || 1 < u + v) {
+            continue;
+        }
+        //Here, u and v are positive, u+v <= 1, and if distance is positive - triangle is hit.
+        if (0 <= glm::dot(e2, MxE1) * DetInv) {
+            return true;
+        }
     }
+    return false;
+}
+
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    float& outDistance,
+    float& outUCoord,
+    float& outVCoord)
+{
+    outDistance = INFINITY;
+    bool hit = false;
+    for (int i = 0; i < modelIndices.size(); ++i) {
+        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
+        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
+        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
+        glm::vec3 m = ray.Origin() - v0;
+        glm::vec3 MxE1 = glm::cross(m, e1);
+        glm::vec3 DxE2 = glm::cross(ray.Direction(), e2);//pVec
+        float DetInv = glm::dot(e1, DxE2);
+        if (std::abs(DetInv) < FLT_EPSILON) {
+            continue;
+        }
+        DetInv = 1.0f / DetInv;
+        float dist = glm::dot(e2, MxE1) * DetInv;
+        if (dist >= outDistance) {
+            continue;
+        }
+        float u = glm::dot(m, DxE2) * DetInv;
+        float v = glm::dot(ray.Direction(), MxE1) * DetInv;
+
+        //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
+        //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
+        if (0 <= (u + 0.001f) && 0 <= (v + 0.001f) && u + v <= 1 && 0 <= dist) {
+            outDistance = dist;
+            outUCoord = u;
+            outVCoord = v;
+            hit = true;
+        }
+    }
+    return hit;
+}
+
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    glm::vec3& outHitPosition)
+{
+    float u;
+    float v;
+    float dist;
+    bool hit = RayVsModel(ray, modelVertices, modelIndices, dist, u, v);
+    outHitPosition = ray.Origin() + dist * ray.Direction();
+    return hit;
+}
 
 bool IsSameBoxProbably(const AABB& first, const AABB& second, const float epsilon)
 {

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -144,10 +144,11 @@ void EntityFilePreprocessor::parseComponentInfo()
             }
 
             auto& field = compInfo.Fields[name];
+            field.Name = name;
             field.Type = type;
             field.Offset = fieldOffset;
             field.Stride = stride;
-            compInfo.FieldsInOrder.push_back(&field);
+            compInfo.FieldsInOrder.push_back(name);
 
             fieldOffset += stride;
         }

src/Engine/Core/Transform.cpp

@@ -0,0 +1,52 @@
+#include "Core/Transform.h"
+
+glm::vec3 Transform::AbsolutePosition(World* world, EntityID entity)
+{
+    glm::vec3 position;
+
+    while (entity != EntityID_Invalid) {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        EntityID parent = world->GetParent(entity);
+        position += Transform::AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"];
+        entity = parent;
+    }
+
+    return position;
+}
+
+glm::quat Transform::AbsoluteOrientation(World* world, EntityID entity)
+{
+    glm::quat orientation;
+
+    while (entity != EntityID_Invalid) {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
+        entity = world->GetParent(entity);
+    }
+
+    return orientation;
+}
+
+glm::vec3 Transform::AbsoluteScale(World* world, EntityID entity)
+{
+    glm::vec3 scale(1.f);
+
+    while (entity != EntityID_Invalid) {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        scale *= (glm::vec3)transform["Scale"];
+        entity = world->GetParent(entity);
+    }
+
+    return scale;
+}
+
+glm::mat4 Transform::ModelMatrix(EntityID entity, World* world)
+{
+    glm::vec3 position = Transform::AbsolutePosition(world, entity);
+    glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
+    glm::vec3 scale = Transform::AbsoluteScale(world, entity);
+
+    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
+    return modelMatrix;
+}
+

src/Engine/Editor/EditorSystem.cpp

@@ -124,6 +124,9 @@ bool EditorSystem::OnMouseMove(const Events::MouseMove& e)
     if (m_Selection == 0) {
         return false;
     }
+    if (m_Camera == nullptr) {
+        return false;
+    }
 
     auto widgetTransform = m_World->GetComponent(m_Widget, "Transform");
     glm::vec3 widgetOrientation = widgetTransform["Orientation"];

src/Engine/Input/InputProxy.cpp

@@ -62,7 +62,7 @@ void InputProxy::Process()
             e.Command = command;
             e.Value = currentValue;
             m_EventBroker->Publish(e);
-            LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
+            //LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
             m_LastCommandValues[command] = currentValue;
         }
     }
@@ -78,7 +78,7 @@ void InputProxy::Process()
         }
         //e.Value = std::max(-1.f, std::min(e.Value, 1.f));
         m_EventBroker->Publish(e);
-        LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
+        //LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
     }
     m_CommandQueue.clear();
 }

src/Engine/Network/Client.cpp

@@ -17,7 +17,6 @@ Client::Client(ConfigFile* config) : m_Socket(m_IOService)
 
 Client::~Client()
 {
-
 }
 
 void Client::Start(World* world, EventBroker* eventBroker)
@@ -27,14 +26,8 @@ void Client::Start(World* world, EventBroker* eventBroker)
     m_World = world;
 
     // Subscribe to events
-    m_EInputCommand = decltype(m_EInputCommand)(std::bind(&Client::OnInputCommand, this, std::placeholders::_1));
+    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Client::OnInputCommand);
-    m_EventBroker->Subscribe(m_EInputCommand);
 
-
-    //while (m_PlayerName.size() > 7) {
-    //    LOG_INFO("Please enter your name (No longer than 7 characters):");
-    //    std::cin >> m_PlayerName;
-    //}
     m_Socket.connect(m_ReceiverEndpoint);
     LOG_INFO("I am client. BIP BOP");
 }
@@ -44,18 +37,9 @@ void Client::Update()
     readFromServer();
 }
 
-void Client::Close()
-{
-    if (m_WasStarted) {
-        disconnect();
-        m_ThreadIsRunning = false;
-        m_EventBroker->Unsubscribe(m_EInputCommand);
-    }
-}
-
 void Client::readFromServer()
 {
-    if (m_Socket.available()) {
+    while (m_Socket.available()) {
         bytesRead = receive(readBuf, INPUTSIZE);
         if (bytesRead > 0) {
             Packet packet(readBuf, bytesRead);
@@ -65,7 +49,7 @@ void Client::readFromServer()
     std::clock_t currentTime = std::clock();
     if (snapshotInterval < (1000 * (currentTime - previousSnapshotMessage) / (double)CLOCKS_PER_SEC)) {
         if (isConnected()) {
-            sendSnapshotToServer();
+            //sendSnapshotToServer();
         }
         previousSnapshotMessage = currentTime;
     }
@@ -73,13 +57,12 @@ void Client::readFromServer()
 
 void Client::sendSnapshotToServer()
 {
-    // Reset previouse key state in snapshot.
+    // Reset previous key state in snapshot.
     m_NextSnapshot.InputForward = "";
     m_NextSnapshot.InputRight = "";
 
     auto player = m_World->GetComponent(m_PlayerDefinitions[m_PlayerID].EntityID, "Player");
 
-
     // See if any movement keys are down
     // We dont care if it's overwritten by later
     // if statement. Watcha gonna do, right!
@@ -125,6 +108,8 @@ void Client::parseMessageType(Packet& packet)
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
     m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
+    if (m_PacketID <= m_PreviousPacketID)
+        return;
     //IdentifyPacketLoss();
 
     switch (static_cast<MessageType>(messageType)) {
@@ -184,33 +169,51 @@ void Client::parseEventMessage(Packet& packet)
     }
 }
 
+void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType)
+{
+    for (auto field : componentInfo.FieldsInOrder) {
+        ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(field);
+        if (fieldInfo.Type == "string") {
+            std::string& value = packet.ReadString();
+            m_World->GetComponent(entityID, componentType)[fieldInfo.Name] = value;
+        } else {
+            memcpy(m_World->GetComponent(entityID, componentType).Data + fieldInfo.Offset, packet.ReadData(fieldInfo.Stride), fieldInfo.Stride);
+        }
+    }
+}
+
+// Field parse
 void Client::parseSnapshot(Packet& packet)
 {
-    std::string tempName;
+    std::string componentType = packet.ReadString();
-    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+    while (packet.DataReadSize() < packet.Size()) {
-        // We're checking for empty name for now. This might not be the best way,
+        EntityID entityID = packet.ReadPrimitive<EntityID>();
-        // but it is to avoid sending redundant data.
+        ComponentInfo componentInfo = m_World->GetComponents(componentType)->ComponentInfo();
-        tempName = packet.ReadString();
+        if (m_World->ValidEntity(entityID)) {
-
+            if (m_World->HasComponent(entityID, componentType)) {
-
+                // If the entity and the component exists update it
-        // Apply the position data read to the player entity
+                updateFields(packet, componentInfo, entityID, componentType);
-        // New player connected on the server side 
+                // if entity exists but not the component
-        if (m_PlayerDefinitions[i].Name == "" && tempName != "") {
+            } else {
-            m_PlayerDefinitions[i].Name = tempName;
+                // Create component
-            m_PlayerDefinitions[i].EntityID = createPlayer();
+                m_World->AttachComponent(entityID, componentType);
-        } else if (m_PlayerDefinitions[i].Name != "" && tempName == "") {
+                // Copy data to newly created component
-            // Someone disconnected
+                updateFields(packet, componentInfo, entityID, componentType);
-            // TODO: Insert code here
+            }
-            break;
+            // If the entity dosent exist nor the component
-        } else if (m_PlayerDefinitions[i].Name == "" && tempName == "") {
+        } else {
-            // Not a connected player
+            //Create Entity
-            break;
+            // If entity dosen't exist
-        }
+            EntityID newEntityID = m_World->CreateEntity();
-        if (m_PlayerDefinitions[i].EntityID != -1) {
+            // Check if EntityIDs are out of sync
-
+            if (newEntityID != entityID) {
-            // Move player to server position
+                LOG_INFO("Client::parseSnapshot(Packet& packet): Newly created EntityID is not the \
-            int dataSize = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Info.Meta.Stride;
+                            same as the one sent by server (EntityIDs are out of sync)");
-            memcpy(m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform").Data, packet.ReadData(dataSize), dataSize);
+            }
+            // Create component
+            m_World->AttachComponent(newEntityID, componentType);
+            // Copy data to newly created component
+            updateFields(packet, componentInfo, newEntityID, componentType);
         }
     }
 }
@@ -225,7 +228,7 @@ int Client::receive(char* data, size_t length)
         0, error);
 
     if (error) {
-        //LOG_ERROR("receive: %s", error.message().c_str());
+        LOG_ERROR("receive: %s", error.message().c_str());
     }
 
     return bytesReceived;

src/Engine/Network/Packet.cpp

@@ -3,13 +3,7 @@
 Packet::Packet(MessageType type, unsigned int& packetID)
 {
     m_Data = new char[m_MaxPacketSize];
-    // Create message header
+    Init(type, packetID);
-    // Add message type
-    int messageType = static_cast<int>(type);
-    Packet::WritePrimitive<int>(messageType);
-    packetID = packetID % 1000; // Packet id modulos
-    Packet::WritePrimitive<int>(packetID);
-    packetID++;
 }
 
 // Create message
@@ -28,12 +22,26 @@ Packet::~Packet()
     delete[] m_Data;
 }
 
-void Packet::WriteString(std::string str)
+void Packet::Init(MessageType type, unsigned int & packetID)
+{ 
+    m_ReturnDataOffset = 0;
+    m_Offset = 0;
+    // Create message header
+    // Add message type
+    int messageType = static_cast<int>(type);
+    Packet::WritePrimitive<int>(messageType);
+    packetID = packetID % 1000; // Packet id modulos
+    Packet::WritePrimitive<int>(packetID);
+    packetID++;
+}
+
+void Packet::WriteString(const std::string& str)
 {
     // Message, add one extra byte for null terminator
     int sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
-        LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size.\n");
+        LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size. New size is %i bytes\n", m_MaxPacketSize*2);
+        resizeData();
     }
     memcpy(m_Data + m_Offset, str.data(), sizeOfString * sizeof(char));
     m_Offset += sizeOfString * sizeof(char);
@@ -42,7 +50,8 @@ void Packet::WriteString(std::string str)
 void Packet::WriteData(char * data, int sizeOfData)
 {
     if (m_Offset + sizeOfData > m_MaxPacketSize) {
-        LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size.\n");
+        LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size. New size is %i bytes\n", m_MaxPacketSize*2);
+        resizeData();
     }
     memcpy(m_Data + m_Offset, data, sizeOfData);
     m_Offset += sizeOfData;
@@ -69,4 +78,24 @@ char * Packet::ReadData(int SizeOfData)
     unsigned int oldReturnDataOffset = m_ReturnDataOffset;
     m_ReturnDataOffset += SizeOfData;
     return (m_Data + oldReturnDataOffset);
-}
+}
+
+void Packet::resizeData()
+{ 
+
+    // Allocate memory to store our data in
+    char* holdData = new char[m_MaxPacketSize];
+    // Copy our data to the newly allocated memory
+    memcpy(holdData, m_Data, m_Offset);
+   // Increase max packet size
+    m_MaxPacketSize = m_MaxPacketSize * 2;
+    // Delete our data
+    delete m_Data;
+    // Allocate twice the memory we had before
+    m_Data = new char[m_MaxPacketSize];
+    // Copy our data to new location
+    memcpy(m_Data, holdData, m_Offset);
+    // Delete the memory allocated to hold our data
+    // while we resized the old data container.
+    delete holdData;
+}

src/Engine/Network/Server.cpp

@@ -4,7 +4,9 @@ Server::Server() : m_Socket(m_IOService, boost::asio::ip::udp::endpoint(boost::a
 { }
 
 Server::~Server()
-{ }
+{
+
+}
 
 
 void Server::Start(World* world, EventBroker* eventBroker)
@@ -22,18 +24,9 @@ void Server::Update()
     readFromClients();
 }
 
-void Server::Close()
-{
-    m_ThreadIsRunning = false;
-}
-
 void Server::readFromClients()
 {
-    // m_ThreadIsRunning might be unnecessary but the 
+    while (m_Socket.available()) {
-    // program crashed if it executed m_Socket.available()
-    // when closing the program. 
-
-    if (m_Socket.available()) {
         try {
             bytesRead = receive(readBuffer, INPUTSIZE);
             Packet packet(readBuffer, bytesRead);
@@ -41,7 +34,6 @@ void Server::readFromClients()
         } catch (const std::exception& err) {
             //LOG_ERROR("%i: Read from client crashed %s", m_PacketID, err.what());
         }
-
     }
     std::clock_t currentTime = std::clock();
     // Send snapshot
@@ -58,7 +50,7 @@ void Server::readFromClients()
 
     // Time out logic
     if (checkTimeOutInterval < (1000 * (currentTime - timOutTimer) / (double)CLOCKS_PER_SEC)) {
-        checkForTimeOuts();
+        //checkForTimeOuts();
         timOutTimer = currentTime;
     }
 }
@@ -108,7 +100,7 @@ int Server::receive(char * data, size_t length)
 
 void Server::send(Packet& packet, int playerID)
 {
-    m_Socket.send_to(
+    int bytesSent = m_Socket.send_to(
         boost::asio::buffer(packet.Data(), packet.Size()),
         m_PlayerDefinitions[playerID].Endpoint,
         0);
@@ -150,22 +142,32 @@ void Server::broadcast(Packet& packet)
     }
 }
 
+// Send snapshot fields
 void Server::sendSnapshot()
 {
-    Packet packet(MessageType::Snapshot, m_SendPacketID);
+    // Should time this
-    for (size_t i = 0; i < MAXCONNECTIONS; i++) {
+    std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
+    for (auto& it : worldComponentPools) {
+        Packet packet(MessageType::Snapshot, m_SendPacketID);
+        std::string componentType = it.first;
+        ComponentPool* componentPool = it.second;
+        ComponentInfo componentInfo = componentPool->ComponentInfo();
+        packet.WriteString(componentInfo.Name);
 
-        // Send an empty name if there is no player connected on this position.
+        for (auto& componentWrapper : *componentPool) {
-        packet.WriteString(m_PlayerDefinitions[i].Name);
+            packet.WritePrimitive(componentWrapper.EntityID);
-
+            for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
-        if (m_PlayerDefinitions[i].EntityID == -1) {
+                ComponentInfo::Field_t fieldInfo = componentInfo.Fields.at(componentField);
-            continue;
+                if (fieldInfo.Type == "string") {
+                    std::string& value = componentWrapper[componentField];
+                    packet.WriteString(value);
+                } else {
+                    packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
+                }
+            }
         }
-        // Pack transfrom component into data packet
+        broadcast(packet);
-        auto transform = m_World->GetComponent(m_PlayerDefinitions[i].EntityID, "Transform");
-        packet.WriteData(transform.Data, transform.Info.Meta.Stride);
     }
-    broadcast(packet);
 }
 
 void Server::sendPing()
@@ -174,10 +176,9 @@ void Server::sendPing()
     for (size_t i = 0; i < MAXCONNECTIONS; i++) {
         if (m_PlayerDefinitions[i].Endpoint.address() != boost::asio::ip::address()) {
             int ping = 1000 * (m_StopTimes[i] - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
-            LOG_INFO("%i: Player %i's ping: %i", m_PacketID, i, ping);
+            LOG_INFO("Last packetID received %i: Player %i's ping: %i", m_PacketID, i, ping);
         }
     }
-
     // Create ping message
     Packet packet(MessageType::ServerPing, m_SendPacketID);
     packet.WriteString("Ping from server");
@@ -271,7 +272,7 @@ void Server::parseConnect(Packet& packet)
 
             m_StopTimes[i] = std::clock();
 
-            LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name, m_PlayerDefinitions[i].Endpoint.address().to_string());
+            LOG_INFO("Player \"%s\" connected on IP: %s", m_PlayerDefinitions[i].Name.c_str(), m_PlayerDefinitions[i].Endpoint.address().to_string().c_str());
 
             Packet packet(MessageType::Connect, m_SendPacketID);
             packet.WritePrimitive<int>(i); // Player ID

src/Engine/Rendering/PickingPass.cpp

@@ -109,7 +109,7 @@ void PickingPass::ClearPicking()
 {
     m_PickingColorsToEntity.clear();
     m_EntityColors.clear();
-    m_ColorCounter[0] = 0;
+    m_ColorCounter[0] = 1;
     m_ColorCounter[1] = 0;
 
     m_PickingBuffer.Bind();
@@ -138,10 +138,10 @@ PickData PickingPass::Pick(glm::vec2 screenCoord)
         pickInfo = it->second;
     } else {
         pickData.Entity = EntityID_Invalid;
+        return pickData;
     }
-    pickData.Position = ScreenCoords::ToWorldPos(screenCoord.x, screenCoord.y, data.Depth, resolution, pickInfo.Camera->ProjectionMatrix(), pickInfo.Camera->ViewMatrix());
-   
 
+    pickData.Position = ScreenCoords::ToWorldPos(screenCoord.x, screenCoord.y, data.Depth, resolution, pickInfo.Camera->ProjectionMatrix(), pickInfo.Camera->ViewMatrix());
     pickData.Entity = pickInfo.Entity;
     pickData.Camera = pickInfo.Camera;
     pickData.World = pickInfo.World;

src/Engine/Rendering/RenderSystem.cpp

@@ -1,5 +1,4 @@
 #include "Rendering/RenderSystem.h"
-#include "Rendering/DebugCameraInputController.h"
 
 RenderSystem::RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame) :ImpureSystem(eventBrokerer)
 {
@@ -8,11 +7,14 @@ RenderSystem::RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &RenderSystem::OnSetCamera);
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
 
-    m_DefaultCamera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 5000.f);
+    m_Camera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 5000.f);
-    m_DefaultCamera->SetPosition(glm::vec3(0, 0, 10));
+    m_DebugCameraInputController = new DebugCameraInputController<RenderSystem>(eventBrokerer, -1);
-    if (m_Camera == nullptr) {
+}
-        m_Camera = m_DefaultCamera;
+
-    }
+RenderSystem::~RenderSystem()
+{
+    delete m_Camera;
+    delete m_DebugCameraInputController;
 }
 
 bool RenderSystem::OnSetCamera(const Events::SetCamera &event)
@@ -54,14 +56,11 @@ void RenderSystem::switchCamera(EntityID entity)
 void RenderSystem::updateProjectionMatrix(ComponentWrapper& cameraComponent)
 {
     double fov = cameraComponent["FOV"];
-    double aspectRatio = m_Renderer->Resolution().Width / m_Renderer->Resolution().Height;
+    double aspectRatio = (float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height;
     double nearClip = cameraComponent["NearClip"];
     double farClip = cameraComponent["FarClip"];
 
-    double fovY = atan(tan(glm::radians(fov)/2.0) * aspectRatio) * 2.0;
+    m_Camera->SetFOV(glm::radians(fov));
-    m_ProjectionMatrix = glm::perspective(fovY, aspectRatio, nearClip, farClip);
-
-    m_Camera->SetFOV(fovY);
     m_Camera->SetAspectRatio(aspectRatio);
     m_Camera->SetNearClip(nearClip);
     m_Camera->SetFarClip(farClip);
@@ -161,66 +160,61 @@ void RenderSystem::Update(World* world, double dt)
 
 void RenderSystem::updateCamera(World* world, double dt)
 {
-    
+    if (m_SwitchCamera) {
-        static DebugCameraInputController<RenderSystem> firstPersonInputController(m_EventBroker, -1);
+        auto cameras = world->GetComponents("Camera");
-
+        for (auto it = cameras->begin(); it != cameras->end(); it++) {
-        if (m_SwitchCamera) {
+            if ((*it).EntityID == m_CurrentCamera) {
-            auto cameras = world->GetComponents("Camera");
+                it++;
-            for (auto it = cameras->begin(); it != cameras->end(); it++) {
+                if (it != cameras->end()) {
-                if ((*it).EntityID == m_CurrentCamera) {
+                    switchCamera((*it).EntityID);
-                    it++;
+                } else {
-                    if (it != cameras->end()) {
+                    switchCamera((*cameras->begin()).EntityID);
-                        switchCamera((*it).EntityID);
-                    } else {
-                        switchCamera((*cameras->begin()).EntityID);
-                    }
-                    break;
                 }
+                break;
             }
+        }
+        ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
+        ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
+
+        m_DebugCameraInputController->SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
+        m_DebugCameraInputController->SetPosition(cameraTransform["Position"]);
+    }
+
+    if (m_World->ValidEntity(m_CurrentCamera)) {
+        if (world->HasComponent(m_CurrentCamera, "Camera") && world->HasComponent(m_CurrentCamera, "Transform")) {
             ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
             ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
 
-            firstPersonInputController.SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
+            m_DebugCameraInputController->Update(dt);
-            firstPersonInputController.SetPosition(cameraTransform["Position"]);
+            (glm::vec3&)cameraTransform["Orientation"] = glm::eulerAngles(m_DebugCameraInputController->Orientation());
-            
+            (glm::vec3&)cameraTransform["Position"] = m_DebugCameraInputController->Position();
-        }
+
+            glm::vec3 position = Transform::AbsolutePosition(world, m_CurrentCamera);
+            glm::quat orientation = Transform::AbsoluteOrientation(world, m_CurrentCamera);
+
+            m_Camera->SetPosition(position);
+            m_Camera->SetOrientation(orientation);
+
+            updateProjectionMatrix(cameraComponent);
+
+        }
+    } else {
+        m_Camera = m_Camera;
+
+        auto cameras = world->GetComponents("Camera");
+        if (cameras != nullptr) {
+            if (cameras->begin() != cameras->end()) {
+                ComponentWrapper& cameraC = *cameras->begin();
+                switchCamera(cameraC.EntityID);
 
-        if (m_World->ValidEntity(m_CurrentCamera)) {
-            if (world->HasComponent(m_CurrentCamera, "Camera") && world->HasComponent(m_CurrentCamera, "Transform")) {
                 ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
                 ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
 
-                firstPersonInputController.Update(dt);
+                m_DebugCameraInputController->SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
-                (glm::vec3&)cameraTransform["Orientation"] = glm::eulerAngles(firstPersonInputController.Orientation());
+                m_DebugCameraInputController->SetPosition(cameraTransform["Position"]);
-                (glm::vec3&)cameraTransform["Position"] = firstPersonInputController.Position();
-
-                glm::vec3 position = Transform::AbsolutePosition(world, m_CurrentCamera);
-                glm::quat orientation = Transform::AbsoluteOrientation(world, m_CurrentCamera);
-
-                m_Camera->SetPosition(position);
-                m_Camera->SetOrientation(orientation);
-
-                updateProjectionMatrix(cameraComponent);
-                
-            }
-        } else {
-            m_Camera = m_DefaultCamera;
-
-            auto cameras = world->GetComponents("Camera");
-            if (cameras != nullptr) {
-                if (cameras->begin() != cameras->end()) {
-                    ComponentWrapper& cameraC = *cameras->begin();
-                    switchCamera(cameraC.EntityID);
-
-                    ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
-                    ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
-
-                    firstPersonInputController.SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
-                    firstPersonInputController.SetPosition(cameraTransform["Position"]);
-                }
             }
         }
+    }
 
-        m_Camera->UpdateViewMatrix();
+    m_Camera->UpdateViewMatrix();
-}
+}
-

src/Game/Game.cpp

@@ -32,6 +32,7 @@ Game::Game(int argc, char* argv[])
         ));
     m_Renderer->Initialize();
     //m_Renderer->Camera()->SetFOV(glm::radians(m_Config->Get<float>("Video.FOV", 90.f)));
+    m_RenderFrame = new RenderFrame();
 
     // Create input manager
     m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker);
@@ -56,8 +57,6 @@ Game::Game(int argc, char* argv[])
         fp.MergeEntities(m_World);
     }
 
-    m_RenderFrame = new RenderFrame();
-
     // Create system pipeline
     m_SystemPipeline = new SystemPipeline(m_EventBroker);
     
@@ -73,7 +72,6 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel);
-
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
 
@@ -119,7 +117,6 @@ void Game::Tick()
     if (m_IsClientOrServer) {
         m_ClientOrServer->Update();
     }
-
     // Iterate through systems and update world!
     m_SystemPipeline->Update(m_World, dt);
     m_Renderer->Update(dt);
@@ -149,10 +146,5 @@ void Game::networkFunction()
         m_ClientOrServer = new Server();
     }
     m_ClientOrServer->Start(m_World, m_EventBroker);
-    // I don't think we are reaching this part of the code right now.
+
-    // ~Game() is not called if the game is exited by closing console windows
-    // When server or client is done set it to false.
-    //m_IsClientOrServer = false;
-    // Destroy it
-    //delete m_ClientOrServer;
 }