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

# Conflicts:
#	resources/Schema/Entities/MovementTest.xml
#	resources/Schema/Entities/Player.xml

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/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)
-        : InputController(eventBroker)
-        , m_PlayerID(playerID)
-    {
-        EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &FirstPersonInputController::OnLockMouse);
-        EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &FirstPersonInputController::OnUnlockMouse);
-    }
+    FirstPersonInputController(EventBroker* eventBroker, int playerID);
 
-    const glm::quat Orientation() const { return m_Orientation; }
+    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()
-    {
-        Events::LockMouse e;
-        m_EventBroker->Publish(e);
-        m_MouseLocked = true;
-    }
+    void LockMouse();
+    void UnlockMouse();
+    virtual bool OnCommand(const Events::InputCommand& e) override;
+    virtual void Reset();
 
-    void UnlockMouse()
-    {
-        Events::UnlockMouse e;
-        m_EventBroker->Publish(e);
-        m_MouseLocked = false;
-    }
+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);
+};
 
-    virtual bool OnCommand(const Events::InputCommand& e) override
-    {
-        if (m_PlayerID != e.PlayerID) {
-            return false;
-        }
+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);
+}
 
-        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;
-            }
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::Reset()
+{
+    m_Rotation = glm::vec3(0.f, 0.f, 0.f);
+    m_Jumping = false;
+}
 
-            if (e.Command == "Yaw") {
-                float val = glm::radians(e.Value);
-                m_Orientation = glm::angleAxis<float>(-val, glm::vec3(0, 1, 0)) * m_Orientation;
-                return true;
-            }
-        }
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::LockMouse()
+{
+    Events::LockMouse e;
+    m_EventBroker->Publish(e);
+    m_MouseLocked = true;
+}
 
+template <typename EventContext>
+void FirstPersonInputController<EventContext>::UnlockMouse()
+{
+    Events::UnlockMouse e;
+    m_EventBroker->Publish(e);
+    m_MouseLocked = false;
+}
+
+template <typename EventContext>
+bool FirstPersonInputController<EventContext>::OnCommand(const Events::InputCommand& e)
+{
+    if (m_PlayerID != e.PlayerID) {
         return false;
     }
 
-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; }
-};
+    if (e.Command == "Pitch") {
+        float val = glm::radians(e.Value);
+        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_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;
+}
+
+template <typename EventContext>
+bool FirstPersonInputController<EventContext>::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

@@ -5,16 +5,17 @@
 // Used to determine what type of message was sent.
 enum class MessageType
 {
-	Connect,
-	Disconnect,
-	ClientPing,
-	ServerPing,
-	Message,
-	Snapshot,
+    Connect,
+    Disconnect,
+    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/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
 {
@@ -30,6 +30,7 @@ private:
     RenderFrame* m_RenderFrame;
     Camera* m_Camera;
     EntityWrapper m_CurrentCamera = EntityWrapper::Invalid;
+    EntityWrapper m_LocalPlayer = EntityWrapper::Invalid;
 
     EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
     bool OnSetCamera(Events::SetCamera &event);
@@ -41,6 +42,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