why not

.gitattributes

@@ -1,3 +0,0 @@
-*.obj filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.glb filter=lfs diff=lfs merge=lfs -text

include/client/state/GameState.h

@@ -12,11 +12,10 @@ class GameState : public ClientState {
 	game::WorldPtr m_World;
 	sim::ClientSimulation m_Simulation;
 	float m_CurrentLerp;
-	float m_ElapsedTime;
 
   public:
 	GameState(Client& a_Client, const game::WorldPtr& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps);
-	~GameState();
+	~GameState() {}
 
 	virtual void Update(float a_Delta) override;
 
@@ -24,10 +23,6 @@ class GameState : public ClientState {
 		return m_CurrentLerp;
 	}
 
-	float GetElapsedTime() const {
-		return m_ElapsedTime;
-	}
-
 	game::WorldPtr GetWorld() const {
 		return m_World;
 	}

include/td/Maths.h

@@ -4,7 +4,7 @@
 
 namespace td {
 
-// static constexpr float PI = 3.141592653f;
+static constexpr float PI = 3.141592653f;
 
 template <typename T>
 struct Vec2 {
@@ -183,51 +183,6 @@ T Lerp(T v0, T v1, T t) {
 
 }  // namespace maths
 
-template<typename T>
-Vec2<T> operator+(const Vec2<T>& vect, const Vec2<T>& other) {
-	return {vect.x + other.x, vect.y + other.y};
-}
-
-template<typename T>
-Vec2<T> operator- (const Vec2<T>& vect) {
-	return { -vect.x, -vect.y };
-}
-
-template<typename T>
-Vec2<T> operator- (const Vec2<T>& vect, const Vec2<T>& other) {
-	return vect + (-other);
-}
-
-template<typename T>
-Vec3<T> operator- (const Vec3<T>& vect) {
-	return { -vect.x, -vect.y, -vect.z };
-}
-
-template<typename T>
-Vec3<T> operator+ (const Vec3<T>& vect, const Vec3<T>& other) {
-	return { vect.x + other.x, vect.y + other.y, vect.z + other.z };
-}
-
-template<typename T>
-Vec3<T> operator- (const Vec3<T>& vect, const Vec3<T>& other) {
-	return vect + (-other);
-}
-
-template<typename T>
-Vec4<T> operator- (const Vec4<T>& vect) {
-	return { -vect.x, -vect.y, -vect.z, -vect.w };
-}
-
-template<typename T>
-Vec4<T> operator+ (const Vec4<T>& vect, const Vec4<T>& other) {
-	return { vect.x + other.x, vect.y + other.y, vect.z + other.z, vect.w + other.w };
-}
-
-template<typename T>
-Vec4<T> operator- (const Vec4<T>& vect, const Vec4<T>& other) {
-	return vect + (-other);
-}
-
 template <typename T>
 sp::DataBuffer& operator<<(sp::DataBuffer& a_Buffer, const Vec2<T>& a_Vec) {
 	return a_Buffer << a_Vec.x << a_Vec.y;

include/td/common/Event.h

@@ -1,37 +0,0 @@
-#pragma once
-
-namespace td {
-
-class EventDispatcher;
-
-class Event {
-
-};
-
-struct WindowResizeEvent {
-	int m_Width;
-	int m_Height;
-};
-
-class EventDispatcher {
-public:
-	EventDispatcher(const Event& event);
-
-	template<typename E>
-	void Dispatch();
-};
-
-// template<typename Event>
-// class ConcreteEvent : public Event {
-// public:
-// 	void Accept(EventDispatcher& a_Dispatcher) {
-// 		a_Dispatcher.Handle(*this);
-// 	}
-// };
-
-void OnEvent(const Event& event) {
-	EventDispatcher dispatcher(event);
-	dispatcher.Dispatch<WindowResizeEvent>();
-}
-
-}

include/td/display/Display.h

@@ -2,6 +2,8 @@
 
 #include <string>
 
+#include <SDL3/SDL_keycode.h>
+#include <SDL3/SDL_video.h>
 #include <td/common/StateMachine.h>
 #include <td/misc/Signal.h>
 
@@ -9,15 +11,17 @@ namespace td {
 
 class Display : public StateMachine<Display, void, float> {
   private:
-	int m_LastWidth;
-	int m_LastHeight;
+	SDL_Window* m_Window;
+	SDL_GLContext m_GLContext;
+
+	int m_LastWidth, m_LastHeight;
 	float m_AspectRatio;
 
 	bool m_ShouldClose;
 
   public:
 	utils::Signal<float> OnAspectRatioChange;
-	utils::Signal<int> OnKeyDown;
+	utils::Signal<SDL_Keycode> OnKeyDown;
 
 	Display(int a_Width, int a_Height, const std::string& a_Title);
 	~Display();

include/td/display/DisplayState.h

@@ -13,7 +13,7 @@ class DisplayState : public Display::State, private utils::SlotGuard {
 
   protected:
 	virtual void OnAspectRatioChange(float a_Ratio) {}
-	virtual void OnKeyDown(int a_Key) {}
+	virtual void OnKeyDown(SDL_Keycode a_Key) {}
 };
 
 }  // namespace td

include/td/display/state/DebugWorldState.h

@@ -13,7 +13,7 @@ namespace td {
 class DebugWorldState : public DisplayState {
   private:
 	render::RenderPipeline m_Renderer;
-	Camera m_Camera;
+	render::Camera m_Camera;
 	std::unique_ptr<server::Server> m_Server;
 	std::unique_ptr<client::Client> m_Client;
 	client::GameState* m_ClientState;
@@ -21,8 +21,6 @@ class DebugWorldState : public DisplayState {
 	std::vector<std::unique_ptr<client::Client>> m_FakeClients;
 	std::shared_ptr<server::FakeSocket> m_ServerSocket;
 
-	unsigned int m_PlaySpeed = 1;
-
   public:
 	DebugWorldState(Display& a_Display);
 	~DebugWorldState();
@@ -31,7 +29,7 @@ class DebugWorldState : public DisplayState {
 
   protected:
 	virtual void OnAspectRatioChange(float a_Ratio) override;
-	virtual void OnKeyDown(int a_Key) override;
+	virtual void OnKeyDown(SDL_Keycode a_Key) override;
 };
 
 }  // namespace td

include/td/display/state/MainMenuState.h

@@ -21,7 +21,7 @@ class MainMenuState : public DisplayState, public MainMenuStateStack {
 	void RenderBackButton();
 
   protected:
-	virtual void OnKeyDown(int a_Key) override;
+	virtual void OnKeyDown(SDL_Keycode a_Key) override;
 };
 
 }  // namespace td

include/td/game/Mobs.h

@@ -79,10 +79,9 @@ class Mob : public sp::MessageBase<MobType, MobHandler> {
 	Vec2fp m_Position;
 	Direction m_Direction;
 	std::vector<EffectDuration> m_Effects;
-	std::shared_ptr<Tower> m_LastDamage;	// the last tower that damaged the mob
+	const Tower* m_LastDamage;	// the last tower that damaged the mob
 	float m_HitCooldown;
-	std::shared_ptr<TeamCastle> m_CastleTarget;
-	bool m_HasReachedCastle = false;
+	TeamCastle* m_CastleTarget;
 	// utils::CooldownTimer m_AttackTimer;
 
 	MobPtr m_Next;

include/td/game/WorldTypes.h

@@ -25,12 +25,12 @@ enum class TileType : std::uint8_t {
 	Ice,*/
 };
 
-// static constexpr Color BLACK(0, 0, 0);
-// static constexpr Color WHITE(255, 255, 255);
+static constexpr Color BLACK{0, 0, 0};
+static constexpr Color WHITE{255, 255, 255};
 
-// static constexpr Color RED(255, 0, 0);
-// static constexpr Color GREEN(0, 255, 0);
-// static constexpr Color BLUE(0, 0, 255);
+static constexpr Color RED{255, 0, 0};
+static constexpr Color GREEN{0, 255, 0};
+static constexpr Color BLUE{0, 0, 255};
 
 class TileHandler;
 

include/td/misc/Signal.h

@@ -33,7 +33,7 @@ class SignalRaw : private NonCopyable {
 
 	void operator()(Args... args) const {
 		for (const CallBack& callback : m_Callbacks) {
-			callback->operator()(std::forward<Args>(args)...);
+			callback->operator()(args...);
 		}
 	}
 };
@@ -64,9 +64,9 @@ class Signal {
 		m_Signal->Connect(std::make_shared<CallBackRaw>(a_Callback));
 	}
 
-	[[nodiscard]] std::shared_ptr<ConnectionGuard> ConnectSafe(const CallBack& a_Callback) {
+	[[nodiscard]] std::unique_ptr<ConnectionGuard> ConnectSafe(const CallBack& a_Callback) {
 		m_Signal->Connect(a_Callback);
-		return std::make_shared<ConnectionGuard>(*this, a_Callback);
+		return std::make_unique<ConnectionGuard>(*this, a_Callback);
 	}
 
 	void Disconnect(const CallBack& a_Callback) {

include/td/misc/SlotGuard.h

@@ -12,7 +12,7 @@ namespace utils {
  */
 class SlotGuard {
   private:
-	std::vector<std::shared_ptr<Connection>> m_Connections;
+	std::vector<std::unique_ptr<Connection>> m_Connections;
 
   public:
 	/**
@@ -21,7 +21,7 @@ class SlotGuard {
 	template <typename... Args>
 	void Connect(Signal<Args...> a_Signal, const typename Signal<Args...>::CallBack::element_type& a_Callback) {
 		auto ptr = std::make_shared<typename Signal<Args...>::CallBack::element_type>(a_Callback);
-		m_Connections.emplace_back(a_Signal.ConnectSafe(ptr));
+		m_Connections.push_back(a_Signal.ConnectSafe(ptr));
 	}
 
 	void Disconnect() {

include/td/render/Camera.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <td/Maths.h>
+#include <td/misc/Signal.h>
+
+namespace td {
+namespace render {
+
+class Camera {
+  private:
+	Mat4f m_ViewMatrix;
+	Mat4f m_ProjectionMatrix;
+	Mat4f m_InvViewMatrix;
+	Mat4f m_InvProjectionMatrix;
+
+	float m_CamDistance = 25.0f;
+	Vec3f m_CamPos{0, m_CamDistance, 0};
+	Vec2f m_CamLook{};
+
+	float m_Yaw = -PI / 2.0f;
+	float m_Pitch = -PI / 2.0f + 0.0000001f;
+
+  public:
+	utils::Signal<> OnPerspectiveChange;
+	utils::Signal<> OnViewChange;
+
+	const Mat4f& GetViewMatrix() const {
+		return m_ViewMatrix;
+	}
+
+	const Mat4f& GetProjectionMatrix() const {
+		return m_ProjectionMatrix;
+	}
+
+	void UpdatePerspective(float a_AspectRatio);
+
+	void SetCamPos(const Vec3f& a_NewPos);
+};
+
+}  // namespace render
+}  // namespace td

include/td/render/OpenGL.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#ifdef TD_GL_LOADER_GLEW
+#include <GL/glew.h>
+#else
+#include <glbinding/gl/gl.h>
+using namespace gl;
+#endif

include/td/render/RayGui.h

@@ -1,11 +0,0 @@
-#pragma once
-
-// extern "C" {
-// 	#include <raygui.h>
-// }
-
-extern "C" {
-	#include <rlImGui.h>
-}
-
-#include <imgui.h>

include/td/render/Renderer.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <memory>
-#include <raylib-cpp/Camera3D.hpp>
+#include <td/render/Camera.h>
 #include <td/render/loader/GLLoader.h>
 #include <td/render/shader/CameraShaderProgram.h>
 #include <td/misc/SlotGuard.h>
@@ -21,10 +21,10 @@ template <typename TShader>
 class Renderer : public BasicRenderer, private utils::SlotGuard {
   protected:
 	std::unique_ptr<TShader> m_Shader;
-	raylib::Camera& m_Camera;
+	Camera& m_Camera;
 
   public:
-	Renderer(raylib::Camera& a_Camera);
+	Renderer(Camera& a_Camera);
 	virtual ~Renderer() {}
 
 	template <typename T>
@@ -42,7 +42,7 @@ class RenderPipeline {
 	virtual ~RenderPipeline() {}
 
 	template <typename T, typename... Args>
-	T& AddRenderer(Args... args) {
+	T& AddRenderer(Args&&... args) {
 		auto ptr = std::make_unique<T>(args...);
 		auto rawPtr = ptr.get();
 		m_Renderers.push_back(std::move(ptr));
@@ -65,16 +65,16 @@ class RenderPipeline {
 
 
 template <typename TShader>
-Renderer<TShader>::Renderer(raylib::Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) {
-	// Connect(a_Camera.OnPerspectiveChange, [this](){
-	// 	// m_Shader->Start();
-	// 	m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());
-	// });
+Renderer<TShader>::Renderer(Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) {
+	Connect(a_Camera.OnPerspectiveChange, [this](){
+		m_Shader->Start();
+		m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());
+	});
 
-	// Connect(a_Camera.OnViewChange, [this]() {
-	// 	// m_Shader->Start();
-	// 	m_Shader->SetViewMatrix(m_Camera.GetViewMatrix());
-	// });
+	Connect(a_Camera.OnViewChange, [this]() {
+		m_Shader->Start();
+		m_Shader->SetViewMatrix(m_Camera.GetViewMatrix());
+	});
 }
 
 }  // namespace render

include/td/render/loader/WorldLoader.h

@@ -1,14 +1,22 @@
 #pragma once
 
 #include <td/game/World.h>
-#include <raylib-cpp/Mesh.hpp>
+#include <td/render/loader/GLLoader.h>
 
 namespace td {
 namespace render {
 
 namespace WorldLoader {
 
-Mesh LoadWorldModel(const td::game::World* world);
+struct RenderData {
+	std::vector<float> positions;
+	std::vector<float> colors;
+};
+
+GL::VertexArray LoadMobModel();
+GL::VertexArray LoadWorldModel(const td::game::World* world);
+GL::VertexArray LoadTileSelectModel();
+RenderData LoadTowerModel(const game::TowerPtr& tower);
 
 } // namespace WorldLoader
 

include/td/render/renderer/EntityRenderer.h

@@ -3,7 +3,6 @@
 #include <td/render/Renderer.h>
 #include <td/render/shader/EntityShader.h>
 #include <td/game/World.h>
-#include <raylib-cpp/Model.hpp>
 
 namespace td {
 namespace render {
@@ -11,11 +10,10 @@ namespace render {
 class EntityRenderer : public Renderer<shader::EntityShader> {
   private:
 	game::WorldPtr m_World;
-	raylib::Model m_ZombieModel;
-	Texture2D m_ZombieTexture;
+	std::unique_ptr<GL::VertexArray> m_EntityVao;
 
   public:
-	EntityRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
+	EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~EntityRenderer();
 
 	virtual void Render(float a_Lerp) override;

include/td/render/renderer/HotkeysRenderer.h

@@ -1,20 +1,20 @@
 #pragma once
 
-#include "client/state/GameState.h"
 #include <td/render/Renderer.h>
 #include <client/PlayerManager.h>
 
 namespace td {
 namespace render {
 
-class TimerRenderer : public BasicRenderer {
-  private:
-	const client::GameState& m_State;
+/**
+ * \brief This is a debug class
+ */
+class HotkeysRenderer : public BasicRenderer {
   public:
 	virtual void Render(float a_Lerp) override;
 
-	TimerRenderer(const client::GameState& a_State);
-	~TimerRenderer() {}
+	HotkeysRenderer();
+	~HotkeysRenderer() {}
 };
 
 }  // namespace render

include/td/render/renderer/ImHotkey.h

@@ -0,0 +1,357 @@
+// ImHotKey v1.0
+// https://github.com/CedricGuillemet/ImHotKey
+//
+// The MIT License(MIT)
+// 
+// Copyright(c) 2019 Cedric Guillemet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+#pragma once
+
+#define SDL_h_
+
+/*
+How to use it?
+
+// Get some hotkeys composed of:
+// - hotkey name
+// - hotkey comment/lib
+// - hotkey scancodes. Computed by the editor. Store that value in your app.
+
+static std::vector<ImHotKey::HotKey> hotkeys = { { "Layout", "Reorder nodes in a simpler layout", 0xFFFF261D}
+        ,{"Save", "Save the current graph", 0xFFFF1F1D}
+        ,{"Load", "Load an existing graph file", 0xFFFF181D}
+        ,{"Play/Stop", "Play or stop the animation from the current graph", 0xFFFFFF3F}
+        ,{"SetKey", "Make a new animation key with the current parameters values at the current time", 0xFFFFFF1F}
+        };
+
+// The editor is a modal window. bring it with something like that
+ if (ImGui::Button("Edit Hotkeys"))
+{
+    ImGui::OpenPopup("HotKeys Editor");
+}
+ImHotKey::Edit(hotkeys.data(), hotkeys.size(), "HotKeys Editor");
+
+// ImHotKey also provides a way to retrieve HotKey
+int hotkey = ImHotKey::GetHotKey(hotkeys.data(), hotkeys.size());
+if (hotkey != -1)
+{
+    // handle the hotkey index!
+}
+
+Awesome, you are done!
+To help you integrate in your app, you can get a text (like "Ctrl + O") to integrate in your menu
+static void GetHotKeyLib(unsigned int functionKeys, char* buffer, size_t bufferSize);
+
+*/
+
+#include "imgui.h"
+#include "imgui_internal.h"
+
+namespace ImHotKey
+{
+    struct HotKey
+    {
+        const char *functionName;
+        const char *functionLib;
+        unsigned int functionKeys;
+    };
+
+    struct Key
+    {
+        const char* lib = nullptr;
+        unsigned int order;
+        unsigned int scanCodePage1 = 0; // win32 scancode
+        unsigned int scanCodePage7 = 0; // HID (SDL,...)
+        float offset = 0;
+        float width = 40;
+    };
+
+    static const Key Keys[6][18] = {
+        { {"Esc", 4, 0x1, 0x29, 18}, {"F1", 5, 0x3B, 0x3A, 18}, {"F2", 6, 0x3C, 0x3B}, {"F3", 7, 0x3D, 0x3C}, {"F4", 8, 0x3E, 0x3D}, {"F5", 9, 0x3F, 0x3E, 24}, {"F6", 10, 0x40, 0x3F}, {"F7", 11, 0x41, 0x40}, {"F8", 12, 0x42, 0x41}, {"F9", 13, 0x43, 0x42, 24}, {"F10", 14, 0x44, 0x43}, {"F11", 15, 0x57, 0x44}, {"F12", 16, 0x58, 0x45}, {"PrSn", 17, 0x37, 0x46, 24}, {"ScLk", 18, 0x46}, {"Brk", 19, 126, 0x47} },
+        { {"~", 20, 0x29, 0x35}, {"1", 21, 0x2, 0x1E}, {"2", 22, 0x3, 0x1F}, {"3", 23, 0x4, 0x20}, {"4", 24, 0x5, 0x21}, {"5", 25, 0x6, 0x22}, {"6", 26, 0x7, 0x23}, {"7", 27, 0x8, 0x24}, {"8", 28, 0x9, 0x25}, {"9", 29, 0xA, 0x26}, {"0", 30, 0xB, 0x27}, {"-", 31, 0xC, 0x2D}, {"+", 32, 0xD, 0x2E},{"Backspace", 33, 0xE, 0x2A, 0, 80}, {"Ins", 34, 0x52, 0x49, 24}, {"Hom", 35, 0x47, 0x4A}, {"PgU", 36, 0x49, 0x4B} },
+        { {"Tab", 3, 0xF, 0x2B, 0, 60}, {"Q", 37, 0x10, 0x14}, {"W", 38, 0x11, 0x1A}, {"E", 39, 0x12, 0x08}, {"R", 40, 0x13, 0x15}, {"T", 41, 0x14, 0x17}, {"Y", 42, 0x15, 0x1C}, {"U", 43, 0x16, 0x18}, {"I", 44, 0x17, 0x0C}, {"O", 45, 0x18, 0x12}, {"P", 46, 0x19, 0x13}, {"[", 47, 0x1A, 0x2F}, {"]", 48, 0x1B, 0x30}, {"|", 49, 0x2B, 0x31, 0, 60}, {"Del", 50, 0x53, 0x4C, 24}, {"End", 51, 0x4F, 0x4D}, {"PgD", 52, 0x51, 0x4E} },
+        { {"Caps Lock", 53, 0x3A, 0x39, 0, 80}, {"A", 54, 0x1E, 0x04}, {"S", 55, 0x1F, 0x16}, {"D", 56, 0x20, 0x07}, {"F", 57, 0x21, 0x09}, {"G", 58, 0x22, 0x0A}, {"H", 59, 0x23, 0x0B}, {"J", 60, 0x24, 0x0D}, {"K", 61, 0x25, 0x0E}, {"L", 62, 0x26, 0x0F}, {";", 63, 0x27, 0x33}, {"'", 64, 0x28, 0x34}, {"Ret", 65, 0x1C, 0X28, 0, 84} },
+        { {"Shift", 2, 0x2A, 0xE1, 0, 104}, {"Z", 66, 0x2C, 0x1D}, {"X", 67, 0x2D, 0x1B}, {"C", 68, 0x2E, 0x06}, {"V", 69, 0x2F, 0x19}, {"B", 70, 0x30, 0x05}, {"N", 71, 0x31, 0x11}, {"M", 72, 0x32, 0x10}, {",", 73, 0x33, 0x36}, {".", 74, 0x34, 0x37}, {"/", 75, 0x35, 0x38}, {"Shift", 2, 0x2A, 0xE5, 0, 104}, {"Up", 76, 0x48, 0x52, 68} },
+        { {"Ctrl", 0, 0x1D, 0xE0, 0, 60}, {"Alt", 1, 0x38, 0xE2, 68, 60}, {"Space", 77, 0x39, 0X2c, 0, 260}, {"Alt", 1, 0x38, 0xE6, 0, 60}, {"Ctrl", 0, 0x1D, 0xE4, 68, 60}, {"Left", 78, 0x4B, 0x50, 24}, {"Down", 79, 0x50, 0x51}, {"Right", 80, 0x4D, 0x52} }
+    };
+
+    static const Key& GetKeyForScanCode(unsigned int scancode)
+    {
+        for (unsigned int y = 0; y < 6; y++)
+        {
+            int x = 0;
+            while (Keys[y][x].lib)
+            {
+#ifdef SDL_h_
+                if (Keys[y][x].scanCodePage7 == scancode)
+#elif WIN32
+                if (Keys[y][x].scanCodePage1 == scancode)
+#else
+#error
+#endif
+                    return Keys[y][x];
+                x++;
+            }
+        }
+        return Keys[0][0];
+    }
+
+    static unsigned int GetOrderedScanCodes(unsigned char scanCodes[4], unsigned char order[4])
+    {
+        for (int pass = 0; pass < 2; pass++)
+        {
+            for (int o = 0; o < 3; o++)
+            {
+                if (order[o] > order[o + 1])
+                {
+                    ImSwap(order[o], order[o + 1]); ImSwap(scanCodes[o], scanCodes[o + 1]);
+                }
+            }
+        }
+        return (scanCodes[3] << 24) + (scanCodes[2] << 16) + (scanCodes[1] << 8) + scanCodes[0];
+    }
+
+    static void HotKeySPrintf(char* buffer, size_t bufferSize, const char* fmt, ...)
+    {
+        va_list args;
+        va_start(args, fmt);
+        ImFormatStringV(buffer, bufferSize, fmt, args);
+        va_end(args);
+    }
+
+    static void GetHotKeyLib(unsigned int functionKeys, char* buffer, size_t bufferSize, const char *functionLib = nullptr)
+    {
+        static const char* str[4] = { "%s", "%s + %s", "%s + %s +%s", "%s + %s + %s + %s" };
+        static const char* strLib[4] = { "%s (%s)", "%s (%s + %s)", "%s (%s + %s +%s)", "%s (%s + %s + %s + %s)" };
+        static const char* lib[4];
+        int scanCodeCount = 0;
+        for (int i = 0; i < 4; i++)
+        {
+            unsigned char scanCode = (unsigned char)(functionKeys >> i * 8);
+            if (scanCode == 0xFF)
+            {
+                continue;
+            }
+            lib[scanCodeCount] = GetKeyForScanCode(scanCode).lib;
+            scanCodeCount++;
+        }
+        if (!scanCodeCount)
+        {
+            buffer[0] = 0;
+            return;
+        }
+        
+        if (functionLib)
+        {
+            const char* fmt = strLib[scanCodeCount - 1];
+            HotKeySPrintf(buffer, bufferSize, fmt, functionLib, lib[0], lib[1], lib[2], lib[3]);
+        }
+        else
+        {
+            const char* fmt = str[scanCodeCount - 1];
+            HotKeySPrintf(buffer, bufferSize, fmt, lib[0], lib[1], lib[2], lib[3]);
+        }
+    }
+
+    static void Edit(HotKey *hotkey, size_t hotkeyCount, const char *popupModal)
+    {
+        static int editingHotkey = -1;
+        if (!hotkeyCount)
+            return;
+        static bool keyDown[512] = {};
+
+        ImGui::SetNextWindowSize(ImVec2(1060, 400));
+        if (!ImGui::BeginPopupModal(popupModal, NULL, ImGuiWindowFlags_NoResize))
+            return;
+
+        ImGui::BeginChildFrame(127, ImVec2(220, -1));
+        for(size_t i = 0;i< hotkeyCount;i++)
+        {
+            char hotKeyLib[128];
+            GetHotKeyLib(hotkey[i].functionKeys, hotKeyLib, sizeof(hotKeyLib), hotkey[i].functionName);
+            if (ImGui::Selectable(hotKeyLib, editingHotkey == int(i)) || editingHotkey == -1)
+            {
+                editingHotkey = int(i);
+                memset(keyDown, 0, sizeof(keyDown));
+                for (int j = 0; j < 4; j++)
+                {
+                    int scan = (hotkey[editingHotkey].functionKeys >> (8 * j)) & 0xFF;
+                    if (scan != 0xFF)
+                    {
+                        keyDown[scan] = true;
+                    }
+                }
+            }
+        }
+        ImGui::EndChildFrame();
+        ImGui::SameLine();
+        ImGui::BeginGroup();
+
+        for (int i = ImGuiKey_NamedKey_BEGIN; i < ImGuiKey_NamedKey_END; i++)
+        {
+            if (ImGui::IsKeyPressed(ImGuiKey(i), false))
+            {
+                int imKey;
+#ifdef SDL_h_
+                imKey = i;
+#elif WIN32
+                imKey = MapVirtualKeyA(i, MAPVK_VK_TO_VSC);
+#else
+                imKey = i;
+#endif
+                keyDown[imKey - ImGuiKey_NamedKey_BEGIN] = !keyDown[imKey - ImGuiKey_NamedKey_BEGIN];
+            }
+        }
+        for (unsigned int y = 0; y < 6; y++)
+        {
+            int x = 0;
+            ImGui::BeginGroup();
+            while (Keys[y][x].lib)
+            {
+                const Key& key = Keys[y][x];
+                const float ofs = key.offset + (x?4.f:0.f);
+
+                const float width = key.width;
+                if (x)
+                {
+                    ImGui::SameLine(0.f, ofs);
+                }
+                else
+                {
+                    if (ofs >= 1.f)
+                    {
+                        ImGui::Indent(ofs);
+                    }
+                }
+#ifdef SDL_h_
+                bool& butSwtch = keyDown[key.scanCodePage7];
+#elif WIN32
+                bool& butSwtch = keyDown[key.scanCodePage1];
+#else
+#error
+#endif
+                ImGui::PushStyleColor(ImGuiCol_Button, butSwtch ? 0xFF1040FF : 0x80000000);
+                if (ImGui::Button(Keys[y][x].lib, ImVec2(width, 40)))
+                {
+                    butSwtch = !butSwtch;
+                }
+                ImGui::PopStyleColor();
+                x++;
+            }
+            ImGui::EndGroup();
+        }
+        ImGui::InvisibleButton("space", ImVec2(10, 55));
+        ImGui::BeginChildFrame(18, ImVec2(540, 40));
+        ImGui::Text("%s :", hotkey[editingHotkey].functionName);
+        ImGui::SameLine();
+        ImGui::TextWrapped("%s", hotkey[editingHotkey].functionLib);
+        ImGui::EndChildFrame();
+        ImGui::SameLine();
+        int keyDownCount = 0;
+        for (auto d : keyDown)
+        {
+            keyDownCount += d ? 1 : 0;
+        }
+        if (ImGui::Button("Clear", ImVec2(80, 40)))
+        {
+            memset(keyDown, 0, sizeof(keyDown));
+        }
+        ImGui::SameLine();
+        if (keyDownCount && keyDownCount < 5)
+        {
+            if (ImGui::Button("Set", ImVec2(80, 40)))
+            {
+                unsigned char scanCodes[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
+                unsigned char order[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
+                int scanCodeCount = 0;
+                hotkey[editingHotkey].functionKeys = 0;
+                for (int i = 1; i < sizeof(keyDown); i++)
+                {
+                    if (keyDown[i])
+                    {
+                        scanCodes[scanCodeCount] = (unsigned char)i;
+                        order[scanCodeCount] = (unsigned char)GetKeyForScanCode(i).order;
+                        scanCodeCount++;
+                    }
+                }
+
+                hotkey[editingHotkey].functionKeys = GetOrderedScanCodes(scanCodes, order);
+            }
+            ImGui::SameLine(0.f, 20.f);
+        }
+        else
+        {
+            ImGui::SameLine(0.f, 100.f);
+        }
+        
+        if (ImGui::Button("Done", ImVec2(80, 40))) { ImGui::CloseCurrentPopup(); }
+        ImGui::EndGroup();
+        ImGui::EndPopup();
+    }
+
+    static int GetHotKey(HotKey *hotkey, size_t hotkeyCount)
+    {
+        static unsigned int lastHotKey = 0xFFFFFFFF;
+        unsigned char scanCodes[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
+        unsigned char order[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
+        int scanCodeCount = 0;
+        for (int i = ImGuiKey_Aliases_BEGIN; i < ImGuiKey_Aliases_END; i++)
+        {
+            if (ImGui::IsKeyDown(ImGuiKey(i)))
+            {
+                int imKey;
+#ifdef SDL_h_
+                imKey = i - ImGuiKey_NamedKey_BEGIN;
+#elif WIN32
+                imKey = MapVirtualKeyA(i, MAPVK_VK_TO_VSC);
+#else
+                imKey = i;
+#endif
+                scanCodes[scanCodeCount] = (unsigned char)imKey;
+                order[scanCodeCount] = (unsigned char)GetKeyForScanCode(imKey).order;
+                scanCodeCount++;
+                if (scanCodeCount == 4)
+                    break;
+            }
+        }
+
+        unsigned int newHotKey = GetOrderedScanCodes(scanCodes, order);
+
+        if (scanCodeCount)
+        {
+            if (newHotKey != lastHotKey)
+            {
+                for (size_t i = 0; i < hotkeyCount; i++)
+                {
+                    if (hotkey[i].functionKeys == newHotKey)
+                    {
+                        lastHotKey = newHotKey;
+                        return int(i);
+                    }
+                }
+                lastHotKey = 0xFFFFFFFF;
+            }
+            return -1;
+        }
+        lastHotKey = 0xFFFFFFFF;
+        return -1;
+    }
+};

include/td/render/renderer/TowerRenderer.h

@@ -3,8 +3,6 @@
 #include <td/render/Renderer.h>
 #include <td/render/shader/EntityShader.h>
 #include <td/game/World.h>
-#include <raylib-cpp/Model.hpp>
-#include <raylib-cpp/Texture.hpp>
 
 namespace td {
 namespace render {
@@ -12,11 +10,10 @@ namespace render {
 class TowerRenderer : public Renderer<shader::EntityShader> {
   private:
 	game::WorldPtr m_World;
-	raylib::Model m_TowerModel;
-	raylib::Texture2D m_TowerTexture;
+	std::unique_ptr<GL::VertexArray> m_EntityVao;
 
   public:
-	TowerRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
+	TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~TowerRenderer();
 
 	virtual void Render(float a_Lerp) override;

include/td/render/renderer/WorldRenderer.h

@@ -4,23 +4,19 @@
 #include <td/render/Renderer.h>
 #include <td/render/loader/GLLoader.h>
 #include <td/render/shader/WorldShader.h>
-#include <raylib-cpp/Model.hpp>
 
 namespace td {
 namespace render {
 
 class WorldRenderer : public Renderer<shader::WorldShader> {
   private:
-	std::unique_ptr<raylib::Model> m_WorldModel;
+	std::unique_ptr<GL::VertexArray> m_WorldVao;
 
   public:
-	WorldRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World);
+	WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~WorldRenderer();
 
 	virtual void Render(float a_Lerp) override;
-
-  private:
-	void UpdateControls();
 };
 
 }  // namespace render

include/td/render/shader/CameraShaderProgram.h

@@ -1,17 +1,16 @@
 #pragma once
 
-#include <td/Maths.h>
+#include <td/render/shader/ShaderProgram.h>
 
 namespace td {
 namespace shader {
 
-class CameraShaderProgram {
+class CameraShaderProgram : public ShaderProgram {
   private:
 	unsigned int m_LocationProjection = 0, m_LocationView = 0;
 
   public:
-	CameraShaderProgram() {
-	}
+	CameraShaderProgram() {}
 
 	void SetProjectionMatrix(const Mat4f& proj) const;
 	void SetViewMatrix(const Mat4f& view) const;

include/td/render/shader/ShaderProgram.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+#include <td/Maths.h>
+#include <td/render/OpenGL.h>
+
+namespace td {
+namespace shader {
+
+class ShaderProgram {
+  public:
+	ShaderProgram();
+	virtual ~ShaderProgram();
+
+	void Start() const;
+	void Stop() const;
+
+  protected:
+	void LoadProgramFile(const std::string& vertexFile, const std::string& fragmentFile);
+	void LoadProgram(const std::string& vertexSource, const std::string& fragmentSource);
+
+	virtual void GetAllUniformLocation() = 0;
+	int GetUniformLocation(const std::string& uniformName) const;
+
+	void LoadFloat(unsigned int location, float value) const;
+	void LoadInt(unsigned int location, int value) const;
+	void LoadVector(unsigned int location, const Vec2f& vector) const;
+	void LoadVector(unsigned int location, const Vec3f& vector) const;
+	void LoadBoolean(unsigned int location, bool value) const;
+	void LoadMat4(unsigned int location, const Mat4f& mat) const;
+	void CleanUp() const;
+
+  private:
+	unsigned int m_ProgramID;
+	unsigned int m_VertexShaderID;
+	unsigned int m_FragmentShaderID;
+
+	unsigned int LoadShaderFromFile(const std::string& file, GLenum type);
+	unsigned int LoadShader(const std::string& source, GLenum type);
+};
+
+}  // namespace shader
+}  // namespace td

src/client/state/GameState.cpp

@@ -1,19 +1,15 @@
 #include <client/state/GameState.h>
 
-
 namespace td {
 namespace client {
 
-GameState::GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime,
-	const std::vector<protocol::LockStep> a_FirstSteps) :
+GameState::GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps) :
 	ClientState(a_Client), m_World(a_World), m_Simulation(a_World, a_StepTime, a_FirstSteps) {
 	m_Simulation.OnMissingLockSteps.Connect([this](const std::vector<td::StepTime>& a_MissingSteps) {
 		SendPacket(protocol::packets::LockStepRequestPacket(a_MissingSteps));
 	});
 }
 
-GameState::~GameState() {}
-
 void GameState::Handle(const protocol::packets::LockStepsPacket& a_LockStep) {
 	m_Simulation.Handle(a_LockStep);
 }
@@ -24,7 +20,6 @@ void GameState::Handle(const protocol::packets::LockStepResponsePacket& a_LockSt
 
 void GameState::Update(float a_Delta) {
 	m_CurrentLerp = m_Simulation.Update(a_Delta);
-	m_ElapsedTime += a_Delta;
 }
 
 }  // namespace client

src/main.cpp

@@ -1,11 +1,12 @@
-#include <td/display/state/MainMenuState.h>
+#include <chrono>
+#include <td/display/state/DebugWorldState.h>
 #include <td/misc/Time.h>
 
 int main(int argc, char** argv) {
 	// init GL context
 	td::Display display(1920, 1080, "Tower-Defense 2");
 
-	display.ChangeState<td::MainMenuState>();
+	display.ChangeState<td::DebugWorldState>();
 
 	td::Timer timer;
 	while (!display.IsCloseRequested()) {

src/server/state/GameState.cpp

@@ -25,8 +25,8 @@ void GameState::Update(float a_Delta) {
 	// TODO: don't make STEP_TIME constant
 	static const float stepTimeSecond = static_cast<float>(STEP_TIME) / 1000.0f;
 	m_Time += a_Delta;
-	while (m_Time > stepTimeSecond) {
-		m_Time -= stepTimeSecond;
+	if (m_Time > stepTimeSecond) {
+		m_Time = std::fmod(m_Time, stepTimeSecond);
 		auto lockStepPacket = m_Simulation.Update();
 		BroadcastPacket(lockStepPacket);
 	}

src/td/display/Display.cpp

@@ -1,34 +1,133 @@
 #include <td/display/Display.h>
 
-#include <td/display/ImGuiTheme.h>
+#include <GL/glew.h>
+#include <SDL3/SDL.h>
+#include <imgui.h>
+#include <imgui_impl_opengl3.h>
+#include <imgui_impl_sdl3.h>
+
 #include <td/misc/Format.h>
 #include <td/misc/Log.h>
-
-#include <raylib-cpp/raylib.hpp>
-#include <td/render/RayGui.h>
+#include <td/display/ImGuiTheme.h>
 
 namespace td {
 
 Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
 	m_LastWidth(0), m_LastHeight(0), m_AspectRatio(1), m_ShouldClose(false) {
+	if (!SDL_Init(SDL_INIT_VIDEO)) {
+		utils::LOGE(utils::Format("Could not initialize SDL! SDL error: %s", SDL_GetError()));
+	}
 
-	InitWindow(a_Width, a_Height, a_Title.c_str());
+	m_Window = SDL_CreateWindow(a_Title.c_str(), a_Width, a_Height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
 
 	m_LastWidth = a_Width;
 	m_LastHeight = a_Height;
 	m_AspectRatio = (float)m_LastWidth / m_LastHeight;
 
+	// Prepare and create context
+#ifdef __ANDROID__
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+#else
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+#endif
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
+
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 8);
+
+	m_GLContext = SDL_GL_CreateContext(m_Window);
+
+	if (!m_GLContext) {
+		utils::LOGE(utils::Format("Could not create context! SDL error: %s", SDL_GetError()));
+	}
+
+	int major, minor, mask;
+	int r, g, b, a, depth;
+	int mBuffers, mSamples;
+
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &mask);
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
+	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
+
+	SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
+	SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
+	SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
+	SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &a);
+
+	SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &depth);
+
+	SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &mBuffers);
+	SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &mSamples);
+
+	const char* mask_desc;
+
+	if (mask & SDL_GL_CONTEXT_PROFILE_CORE) {
+		mask_desc = "core";
+	} else if (mask & SDL_GL_CONTEXT_PROFILE_COMPATIBILITY) {
+		mask_desc = "compatibility";
+	} else if (mask & SDL_GL_CONTEXT_PROFILE_ES) {
+		mask_desc = "es";
+	} else {
+		mask_desc = "?";
+	}
+
+	utils::LOG(utils::Format(
+		"GL Context : %i.%i %s, Color : R:%i G:%i B:%i A:%i, Depth bits : %i", major, minor, mask_desc, r, g, b, a, depth));
+
+	utils::LOG(utils::Format("MultiSamples : Buffers : %i, Samples : %i", mBuffers, mSamples));
+
+	SDL_GL_MakeCurrent(m_Window, m_GLContext);
+
+	GLenum error = glewInit();
+	if (error) {
+		utils::LOGE(utils::Format("Error initializing glew : %s", glewGetErrorString(error)));
+	}
+
 	// WindowResizeEvent(WindowWidth, WindowHeight);
 
 	// vsync
-	SetTargetFPS(60);
+	SDL_GL_SetSwapInterval(1);
 
-	rlImGuiSetup(true);
+	// Setup Dear ImGui context
+	IMGUI_CHECKVERSION();
+	ImGui::CreateContext();
+	ImGuiIO& io = ImGui::GetIO();
+	(void)io;
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;   // Enable Gamepad Controls
 
-	float main_scale = 1.5f;
+	// Setup Dear ImGui style
+	ImGui::StyleColorsDark();
+	// ImGui::StyleColorsLight();
 
-	ImGui::GetStyle().FontScaleMain = main_scale;
+	// Setup scaling
+	float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+	// ImGuiStyle& style = ImGui::GetStyle();
+	// style.ScaleAllSizes(main_scale);  // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing
+	// this
+	// 								  // requires resetting Style + calling this again)
+	// style.FontSizeBase = 13 * main_scale;  // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We
+	// leave
+	// 								  // both here for documentation purpose)
 
+
+	ImFontConfig cfg;
+	cfg.SizePixels = 13 * main_scale * 2;
+	io.Fonts->AddFontDefault(&cfg);
+
+	// Setup Platform/Renderer backends
+	ImGui_ImplSDL3_InitForOpenGL(m_Window, m_GLContext);
+	ImGui_ImplOpenGL3_Init("#version 330");
 	LoadTheme();
 }
 
@@ -37,66 +136,62 @@ void Display::Close() {
 }
 
 void Display::PollEvents() {
-	// PollInputEvents();
-	// SDL_Event event;
-	// while (SDL_PollEvent(&event)) {
-	// 	switch (event.type) {
-	// 		case SDL_EVENT_QUIT:
-	// 		case SDL_EVENT_WINDOW_CLOSE_REQUESTED: {
-	// 			m_ShouldClose = true;
-	// 			break;
-	// 		}
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		switch (event.type) {
+			case SDL_EVENT_QUIT:
+			case SDL_EVENT_WINDOW_CLOSE_REQUESTED: {
+				m_ShouldClose = true;
+				break;
+			}
 
-	// 		case SDL_EVENT_WINDOW_RESIZED: {
-	// 			m_LastWidth = event.window.data1;
-	// 			m_LastHeight = event.window.data2;
-	// 			m_AspectRatio = (float)m_LastWidth / m_LastHeight;
-	// 			OnAspectRatioChange(m_AspectRatio);
-	// 			break;
-	// 		}
+			case SDL_EVENT_WINDOW_RESIZED: {
+				m_LastWidth = event.window.data1;
+				m_LastHeight = event.window.data2;
+				m_AspectRatio = (float)m_LastWidth / m_LastHeight;
+				OnAspectRatioChange(m_AspectRatio);
+				break;
+			}
 
-	// 		case SDL_EVENT_KEY_DOWN: {
-	// 			if (!event.key.repeat)
-	// 				OnKeyDown(event.key.key);
-	// 			break;
-	// 		}
+			case SDL_EVENT_KEY_DOWN: {
+				if (!event.key.repeat)
+					OnKeyDown(event.key.key);
+				break;
+			}
 
-	// 		default:
-	// 			break;
-	// 	}
-	// 	ImGui_ImplSDL3_ProcessEvent(&event);
-	// }
-	// // Start the Dear ImGui frame
-	// ImGui_ImplOpenGL3_NewFrame();
-	// ImGui_ImplSDL3_NewFrame();
-	// ImGui::NewFrame();
-	if (WindowShouldClose())
-		m_ShouldClose = true;
-	BeginDrawing();
-	rlImGuiBegin();
+			default:
+				break;
+		}
+		ImGui_ImplSDL3_ProcessEvent(&event);
+	}
+	// Start the Dear ImGui frame
+	ImGui_ImplOpenGL3_NewFrame();
+	ImGui_ImplSDL3_NewFrame();
+	ImGui::NewFrame();
 }
 
 void Display::Update(float a_Delta) {
 	StateMachine::Update(a_Delta);
-	#ifndef NDEBUG
-		ImGui::ShowDemoWindow();
-	#endif
+#ifndef NDEBUG
+	ImGui::ShowDemoWindow();
+#endif
 	ImGui::Render();
-	rlImGuiEnd();
-	EndDrawing();
-	ClearBackground(DARKGRAY);
-	// 	ImGuiIO& io = ImGui::GetIO();
-	// 	glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
-	// 	// glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
-	// 	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-	// 	SDL_GL_SwapWindow(m_Window);
-	// 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	ImGuiIO& io = ImGui::GetIO();
+	glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
+	// glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
+	ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+	SDL_GL_SwapWindow(m_Window);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 
 
 Display::~Display() {
-	rlImGuiShutdown();
-	CloseWindow();
+	ImGui_ImplOpenGL3_Shutdown();
+	ImGui_ImplSDL3_Shutdown();
+	ImGui::DestroyContext();
+	SDL_GL_DestroyContext(m_GLContext);
+	SDL_DestroyWindow(m_Window);
+	SDL_Quit();
 }
 
 }  // namespace td

src/td/display/ImGuiTheme.cpp

@@ -1,10 +1,11 @@
 #include <td/display/ImGuiTheme.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 
 namespace td {
 
 void LoadTheme() {
+
 	static const bool bStyleDark_ = true;
 	static const float alpha_ = 0.8f;
 

src/td/display/menu/CreatePartyMenu.cpp

@@ -1,6 +1,6 @@
 #include <td/display/menu/CreatePartyMenu.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 
 namespace td {
 

src/td/display/menu/JoinPartyMenu.cpp

@@ -1,6 +1,6 @@
 #include <td/display/menu/JoinPartyMenu.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 
 namespace td {
 

src/td/display/menu/MainMenu.cpp

@@ -1,6 +1,6 @@
 #include <td/display/menu/MainMenu.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 #include <td/display/menu/CreatePartyMenu.h>
 #include <td/display/menu/JoinPartyMenu.h>
 #include <td/display/menu/SettingsMenu.h>

src/td/display/menu/SettingsMenu.cpp

@@ -1,6 +1,6 @@
 #include <td/display/menu/SettingsMenu.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 
 namespace td {
 

src/td/display/state/DebugWorldState.cpp

@@ -1,12 +1,13 @@
 #include <td/display/state/DebugWorldState.h>
 
-#include <td/display/Display.h>
-#include <td/display/state/DebugWorldState.h>
+#include <chrono>
+#include <iostream>
+
 #include <td/game/World.h>
 #include <td/protocol/packet/Packets.h>
 #include <td/render/renderer/EntityRenderer.h>
+#include <td/render/renderer/HotkeysRenderer.h>
 #include <td/render/renderer/PlayerListRenderer.h>
-#include <td/render/renderer/TimerRenderer.h>
 #include <td/render/renderer/TowerRenderer.h>
 #include <td/render/renderer/WorldRenderer.h>
 
@@ -19,9 +20,14 @@
 #include <client/state/GameState.h>
 #include <client/state/LoggingState.h>
 
+#include <td/display/Display.h>
+#include <td/display/state/DebugWorldState.h>
+
+#include <imgui.h>
+
 namespace td {
 
-DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display), m_ClientState(nullptr) {
+DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
 	// server
 	m_ServerSocket = std::make_shared<server::FakeSocket>();
 	m_Server = std::make_unique<server::Server>(m_ServerSocket);
@@ -35,12 +41,12 @@ DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display),
 		if (auto gameState = dynamic_cast<client::GameState*>(&a_State)) {
 			// render
 			auto clientWorld = gameState->GetWorld();
-			m_Renderer.AddRenderer<render::WorldRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
-			m_Renderer.AddRenderer<render::EntityRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
-			m_Renderer.AddRenderer<render::TowerRenderer>(static_cast<raylib::Camera&>(m_Camera), clientWorld);
-			m_Renderer.AddRenderer<render::TimerRenderer, client::GameState&>(*gameState);
+			m_Renderer.AddRenderer<render::WorldRenderer>(m_Camera, clientWorld);
+			m_Renderer.AddRenderer<render::EntityRenderer>(m_Camera, clientWorld);
+			m_Renderer.AddRenderer<render::TowerRenderer>(m_Camera, clientWorld);
+			m_Renderer.AddRenderer<render::HotkeysRenderer>();
 
-			auto& list = m_Renderer.AddRenderer<render::PlayerListRenderer, const td::client::PlayerManager&>(m_Client->GetPlayers());
+			auto& list = m_Renderer.AddRenderer<render::PlayerListRenderer>(m_Client->GetPlayers());
 
 			list.OnPlayerCreate.Connect([this]() {
 				auto newSocket = client::FakeSocket::Connect(m_ServerSocket);
@@ -66,52 +72,35 @@ DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display),
 	m_Client->ChangeState<client::LoggingState>("Player0");
 
 	// camera
-	// m_Camera = Camera{{0}};
-	m_Camera.position = (Vector3){77.0f, 7.0f, 13.0f};  // Camera position
-	m_Camera.target = (Vector3){0.0f, 1.0f, -1.0f};	  // Camera looking at point
-	m_Camera.up = (Vector3){0.0f, 1.0f, 0.0f};		  // Camera up vector (rotation towards target)
-	m_Camera.fovy = 45.0f;							  // Camera field-of-view Y
-	m_Camera.projection = CAMERA_PERSPECTIVE;		  // Camera projection type
-
-	// m_Camera.SetCamPos({77, 7, 13});
-	// m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
+	m_Camera.SetCamPos({77, 7, 13});
+	m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
 }
 
 void DebugWorldState::Update(float a_Delta) {
-	m_Server->Update(a_Delta * m_PlaySpeed);
-	m_Client->Update(a_Delta * m_PlaySpeed);
-	UpdateCamera(&m_Camera, CAMERA_FREE);
-
-	if (m_ClientState) {
-		float lerp = m_ClientState->GetCurrentLerp();
-		BeginMode3D(m_Camera);
-		m_Renderer.Render(lerp);
-		EndMode3D();
-	}
-
-	constexpr int SECONDS = 10;
-	if (IsKeyPressed(KEY_Q)) {
-		m_Client->SendPacket(td::protocol::packets::SpawnTroopPacket(td::EntityType::Zombie, 1));
-	}
-
-	if (IsKeyPressed(KEY_Z))
-		m_Client->SendPacket(td::protocol::packets::PlaceTowerPacket(td::TowerType::Archer, td::TowerCoords(77, 13)));
-
-	if (IsKeyPressed(KEY_F)) {
-		m_Server->Update(SECONDS);
-		m_Client->Update(SECONDS);
-	}
-
-	if (IsKeyPressed(KEY_P))
-		m_PlaySpeed = 1 - m_PlaySpeed;
+	m_Server->Update(a_Delta);
+	m_Client->Update(a_Delta);
+	if (m_ClientState)
+		m_Renderer.Render(m_ClientState->GetCurrentLerp());
 }
 
 void DebugWorldState::OnAspectRatioChange(float a_Ratio) {
-	// m_Camera.UpdatePerspective(a_Ratio);
+	m_Camera.UpdatePerspective(a_Ratio);
 }
 
-void DebugWorldState::OnKeyDown(int a_Key) {
+void DebugWorldState::OnKeyDown(SDL_Keycode a_Key) {
 	// temporary tests
+	switch (a_Key) {
+		case SDLK_A:
+			m_Client->SendPacket(td::protocol::packets::SpawnTroopPacket(td::EntityType::Zombie, 1));
+			break;
+
+		case SDLK_Z:
+			m_Client->SendPacket(td::protocol::packets::PlaceTowerPacket(td::TowerType::Archer, td::TowerCoords(77, 13)));
+			break;
+
+		default:
+			break;
+	}
 }
 
 DebugWorldState::~DebugWorldState() {}

src/td/display/state/MainMenuState.cpp

@@ -1,6 +1,6 @@
 #include <td/display/state/MainMenuState.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 #include <td/display/menu/MainMenu.h>
 #include <td/display/state/DebugWorldState.h>
 
@@ -34,8 +34,8 @@ void MainMenuState::RenderBackButton() {
 		PopState();
 }
 
-void MainMenuState::OnKeyDown(int a_Key) {
-	if (a_Key == KEY_ESCAPE)
+void MainMenuState::OnKeyDown(SDL_Keycode a_Key) {
+	if (a_Key == SDLK_ESCAPE)
 		PopState();
 }
 

src/td/game/World.cpp

@@ -1,10 +1,7 @@
-#include <cassert>
-#include <td/Maths.h>
 #include <td/game/World.h>
-#include <td/game/WorldTypes.h>
 
-#include <td/protocol/packet/PacketSerialize.h>
 #include <td/simulation/WorldTicker.h>
+#include <td/protocol/packet/PacketSerialize.h>
 
 namespace td {
 namespace game {
@@ -92,14 +89,5 @@ void World::ResetSnapshots(std::shared_ptr<sim::WorldSnapshot>& a_Current, std::
 	m_NextState = a_Next;
 }
 
-TilePtr World::GetTile(std::int32_t x, std::int32_t y) const {
-	ChunkCoord coords{static_cast<std::int16_t>(x / Chunk::ChunkWidth), static_cast<std::int16_t>(y / Chunk::ChunkHeight)};
-	auto it = m_Chunks.find(coords);
-	assert(it != m_Chunks.end());
-	auto chunk = it->second;
-	Vec2i inchunkCoords{x % Chunk::ChunkWidth, y % Chunk::ChunkHeight};
-	return GetTilePtr(chunk->GetTileIndex(inchunkCoords.y * Chunk::ChunkWidth + inchunkCoords.x));
-}
-
 }  // namespace game
 }  // namespace td

src/td/render/Camera.cpp

@@ -0,0 +1,28 @@
+#include <td/render/Camera.h>
+
+#include <cmath>
+
+namespace td {
+namespace render {
+
+void Camera::UpdatePerspective(float a_AspectRatio) {
+	m_ProjectionMatrix = maths::Perspective(80.0f / 180.0f * PI, a_AspectRatio, 0.1f, 160.0f);
+	m_InvProjectionMatrix = maths::Inverse(m_ProjectionMatrix);
+	OnPerspectiveChange();
+}
+
+void Camera::SetCamPos(const Vec3f& a_NewPos) {
+	Vec3f front = {
+		std::cos(m_Yaw) * std::cos(m_Pitch),
+		std::sin(m_Pitch),
+		std::sin(m_Yaw) * std::cos(m_Pitch)
+	};
+
+	m_CamPos = a_NewPos;
+	m_ViewMatrix = maths::Look(m_CamPos, front, { 0, 1, 0 });
+	m_InvViewMatrix = maths::Transpose(maths::Inverse(m_ViewMatrix));  // why transpose ? I don't know
+	OnViewChange();
+}
+
+}  // namespace render
+}  // namespace td

src/td/render/Renderer.cpp

@@ -1,23 +1,25 @@
 #include <td/render/Renderer.h>
 
+#include <td/render/OpenGL.h>
+
 namespace td {
 namespace render {
 
 void BasicRenderer::Render(const GL::VertexArray& a_Vao) {
 	a_Vao.Bind();
-	// rlDrawArrays(RL_TRIANGLES, 0, a_Vao.GetVertexCount());
-	// rlDrawElements(RL_TRIANrlES, a_Vao.GetVertexCount(), RL_UNSIGNED_INT, nullptr);
+	glDrawArrays(GL_TRIANGLES, 0, a_Vao.GetVertexCount());
+	// glDrawElements(GL_TRIANGLES, a_Vao.GetVertexCount(), GL_UNSIGNED_INT, nullptr);
 	a_Vao.Unbind();
 }
 
 RenderPipeline::RenderPipeline() {
-	// rlEnable(RL_TEXTURE_2D);
-	// rlEnable(RL_BLEND);
-	// rlEnable(RL_DEPTH_TEST);
-	// rlEnable(RL_CULL_FACE);
-	// rlBlendFunc(RL_SRC_ALPHA, RL_ONE_MINUS_SRC_ALPHA);
-	// rlDepthFunc(RL_LESS);
-	// rlFrontFace(RL_CCW);
+	glEnable(GL_TEXTURE_2D);
+	glEnable(GL_BLEND);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glDepthFunc(GL_LESS);
+	glFrontFace(GL_CCW);
 }
 
 }  // namespace render

src/td/render/loader/GLLoader.cpp

@@ -1,26 +1,28 @@
 #include <td/render/loader/GLLoader.h>
 
+#include <td/render/OpenGL.h>
+
 namespace td {
 namespace GL {
 
 VertexArray::~VertexArray() {
-	// if (m_ID != 0)
-		// glDeleteVertexArrays(1, &m_ID);
+	if (m_ID != 0)
+		glDeleteVertexArrays(1, &m_ID);
 }
 
 VertexArray::VertexArray(ElementBuffer&& indicies) : m_ElementBuffer(std::move(indicies)) {
-	// glGenVertexArrays(1, &m_ID);
+	glGenVertexArrays(1, &m_ID);
 	Bind();
 	BindElementArrayBuffer();
 	// Unbind();
 }
 
 void VertexArray::Bind() const {
-	// glBindVertexArray(m_ID);
+	glBindVertexArray(m_ID);
 }
 
 void VertexArray::Unbind() const {
-	// glBindVertexArray(0);
+	glBindVertexArray(0);
 }
 
 void VertexArray::BindVertexBuffer(VertexBuffer&& VertexBuffer) {
@@ -34,24 +36,24 @@ void VertexArray::BindElementArrayBuffer() {
 }
 
 VertexBuffer::~VertexBuffer() {
-	// if (m_ID != 0)
-		// glDeleteBuffers(1, &m_ID);
+	if (m_ID != 0)
+		glDeleteBuffers(1, &m_ID);
 }
 
 VertexBuffer::VertexBuffer(const std::vector<float>& data, unsigned int stride) : m_DataStride(stride) {
-	// glGenBuffers(1, &m_ID);
+	glGenBuffers(1, &m_ID);
 	Bind();
-	// glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(data.size() * sizeof(float)), nullptr, GL_STATIC_DRAW);
-	// glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(data.size() * sizeof(float)), data.data());
+	glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(data.size() * sizeof(float)), nullptr, GL_STATIC_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(data.size() * sizeof(float)), data.data());
 	Unbind();
 }
 
 void VertexBuffer::Bind() const {
-	// glBindBuffer(GL_ARRAY_BUFFER, m_ID);
+	glBindBuffer(GL_ARRAY_BUFFER, m_ID);
 }
 
 void VertexBuffer::Unbind() const {
-	// glBindBuffer(GL_ARRAY_BUFFER, 0);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
 void VertexBuffer::AddVertexAttribPointer(unsigned int index, unsigned int coordinateSize, unsigned int offset) {
@@ -65,32 +67,32 @@ void VertexBuffer::AddVertexAttribPointer(unsigned int index, unsigned int coord
 
 void VertexBuffer::BindVertexAttribs() const {
 	for (const VertexAttribPointer& pointer : m_VertexAttribs) {
-		// glVertexAttribPointer(pointer.m_Index, static_cast<GLint>(pointer.m_Size), GL_FLOAT, false, m_DataStride * sizeof(float),
-		// reinterpret_cast<GLvoid*>(static_cast<std::size_t>(pointer.m_Offset)));
-		// glEnableVertexAttribArray(pointer.m_Index);
+		glVertexAttribPointer(pointer.m_Index, static_cast<GLint>(pointer.m_Size), GL_FLOAT, false, m_DataStride * sizeof(float),
+		reinterpret_cast<GLvoid*>(static_cast<std::size_t>(pointer.m_Offset)));
+		glEnableVertexAttribArray(pointer.m_Index);
 	}
 }
 
 ElementBuffer::ElementBuffer(const std::vector<unsigned int>& indicies) {
 	m_TriangleCount = indicies.size();
-	// glGenBuffers(1, &m_ID);
+	glGenBuffers(1, &m_ID);
 	Bind();
-	// glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), nullptr, GL_STATIC_DRAW);
-	// glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), indicies.data());
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), nullptr, GL_STATIC_DRAW);
+	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, static_cast<GLsizeiptr>(indicies.size() * sizeof(unsigned int)), indicies.data());
 	Unbind();
 }
 
 ElementBuffer::~ElementBuffer() {
-	// if (m_ID != 0)
-		// glDeleteBuffers(1, &m_ID);
+	if (m_ID != 0)
+		glDeleteBuffers(1, &m_ID);
 }
 
 void ElementBuffer::Bind() const {
-	// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ID);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ID);
 }
 
 void ElementBuffer::Unbind() const {
-	// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 }
 
 }  // namespace GL

src/td/render/loader/WorldLoader.cpp

@@ -1,6 +1,8 @@
 #include <td/render/loader/WorldLoader.h>
 
-#include <cstring>
+#include <iostream>
+#include <string.h>
+
 #include <td/game/World.h>
 
 namespace td {
@@ -9,12 +11,11 @@ namespace render {
 namespace WorldLoader {
 
 const static int POSITION_VERTEX_SIZE = 3;
-const static int COLOR_VERTEX_SIZE = 4;
+// const static int TEXTURE_VERTEX_SIZE = 2;
 
-Mesh LoadWorldModel(const td::game::World* world) {
-	Mesh mesh = {0};
+GL::VertexArray LoadWorldModel(const td::game::World* world) {
 	std::vector<float> positions;
-	std::vector<unsigned char> colors;
+	std::vector<float> colors;
 
 	for (const auto& [coords, chunk] : world->GetChunks()) {
 		std::int32_t chunkX = coords.x * td::game::Chunk::ChunkWidth;
@@ -41,10 +42,15 @@ Mesh LoadWorldModel(const td::game::World* world) {
 				const td::Color* tileColor = world->GetTileColor(tile);
 
 				for (int i = 0; i < 6; i++) {
-					colors.push_back(tileColor->r);
-					colors.push_back(tileColor->g);
-					colors.push_back(tileColor->b);
-					colors.push_back(255);
+					int color = 255;
+					color |= tileColor->r << 24;
+					color |= tileColor->g << 16;
+					color |= tileColor->b << 8;
+
+					int newColorIndex = colors.size();
+					colors.push_back(0);
+
+					memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
 				}
 			}
 		}
@@ -58,10 +64,15 @@ Mesh LoadWorldModel(const td::game::World* world) {
 		positions.insert(positions.end(), {fromX, 0, fromY, fromX, 0, toY, toX, 0, fromY, fromX, 0, toY, toX, 0, toY, toX, 0, fromY});
 
 		for (int i = 0; i < 6; i++) {
-			colors.push_back(world->GetSpawnColor(TeamColor(spawnColor)).r);
-			colors.push_back(world->GetSpawnColor(TeamColor(spawnColor)).g);
-			colors.push_back(world->GetSpawnColor(TeamColor(spawnColor)).b);
-			colors.push_back(255);
+			int color = 255;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).r << 24;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).g << 16;
+			color |= world->GetSpawnColor(TeamColor(spawnColor)).b << 8;
+
+			int newColorIndex = colors.size();
+			colors.push_back(0);
+
+			memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
 		}
 	}
 
@@ -73,31 +84,162 @@ Mesh LoadWorldModel(const td::game::World* world) {
 		positions.insert(positions.end(), {fromX, 0, fromY, fromX, 0, toY, toX, 0, fromY, fromX, 0, toY, toX, 0, toY, toX, 0, fromY});
 
 		for (int i = 0; i < 6; i++) {
-			colors.push_back(world->GetSpawnColor(TeamColor(castleColor)).r);
-			colors.push_back(world->GetSpawnColor(TeamColor(castleColor)).g);
-			colors.push_back(world->GetSpawnColor(TeamColor(castleColor)).b);
-			colors.push_back(255);
+			int color = 255;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).r << 24;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).g << 16;
+			color |= world->GetSpawnColor(TeamColor(castleColor)).b << 8;
+
+			int newColorIndex = colors.size();
+			colors.push_back(0);
+
+			memcpy(colors.data() + newColorIndex, &color, 1 * sizeof(int));
 		}
 	}
 
-	mesh.vertexCount = positions.size() / 3;
-	mesh.triangleCount = mesh.vertexCount / 3;
+	GL::VertexBuffer positionVBO(positions, POSITION_VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(0, POSITION_VERTEX_SIZE, 0);
+	GL::VertexBuffer colorVBO(colors, 1);
+	colorVBO.AddVertexAttribPointer(1, 1, 0);
 
-	const std::size_t verteciesSize = mesh.vertexCount * POSITION_VERTEX_SIZE * sizeof(float);
-	const std::size_t colorsSize = mesh.vertexCount * COLOR_VERTEX_SIZE * sizeof(unsigned char);
+	std::vector<unsigned int> indexes(positions.size() / 3, 0);
+	for (size_t i = 0; i < indexes.size(); i++) {
+		indexes[i] = i + 1;
+	}
 
-	mesh.vertices = (float*)MemAlloc(verteciesSize);
-	mesh.colors = (unsigned char*)MemAlloc(colorsSize);
+	GL::ElementBuffer indexVBO(indexes);
 
-	std::memcpy(reinterpret_cast<char*>(mesh.vertices), reinterpret_cast<const char*>(positions.data()), verteciesSize);
-	std::memcpy(reinterpret_cast<char*>(mesh.colors), reinterpret_cast<const char*>(colors.data()), colorsSize);
-
-	UploadMesh(&mesh, false);
-
-	return mesh;
+	GL::VertexArray worldVao(std::move(indexVBO));	// each pos = 3 vertecies
+	worldVao.Bind();
+	worldVao.BindVertexBuffer(std::move(positionVBO));
+	worldVao.BindVertexBuffer(std::move(colorVBO));
+	worldVao.Unbind();
+	return worldVao;
 }
 
+GL::VertexArray LoadTileSelectModel() {
+	std::vector<float> positions = {
+		-0.5f,
+		-0.5f,
+		-1.0f,
+
+		0.5f,
+		-0.5f,
+		-1.0f,
+
+		0.0f,
+		0.5f,
+		-1.0f,
+
+		1,
+		.01,
+		1,
+
+		0,
+		.01,
+		1,
+		
+		0,
+		1,
+		1,
+	};
+
+	int color = 255 << 24 | 255 << 16 | 255 << 8 | 150;
+	float colorFloat;
+
+	memcpy(reinterpret_cast<std::uint8_t*>(&colorFloat), &color, sizeof(float));
+
+	std::vector<float> colors(6, colorFloat);
+
+	GL::VertexBuffer positionVBO(positions, POSITION_VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(0, POSITION_VERTEX_SIZE, 0);
+	GL::VertexBuffer colorVBO(colors, 1);
+	colorVBO.AddVertexAttribPointer(1, 1, 0);
+
+	std::vector<unsigned int> indexes(positions.size() / 3, 0);
+	// for (size_t i = 0; i < indexes.size(); i++) {
+	// 	indexes[i] = i + 1;
+	// }
+	GL::ElementBuffer indexVBO(indexes);
+
+	GL::VertexArray tileSelectVao(std::move(indexVBO));
+	tileSelectVao.Bind();
+	tileSelectVao.BindVertexBuffer(std::move(positionVBO));
+	tileSelectVao.BindVertexBuffer(std::move(colorVBO));
+	tileSelectVao.Unbind();
+
+	return tileSelectVao;
+}
+
+RenderData LoadTowerModel(const game::TowerPtr& tower) {
+	RenderData renderData;
+
+	float towerX, towerDX;
+	float towerY, towerDY;
+
+	if (tower->GetSize() == game::TowerSize::Little) {
+		towerX = tower->GetCenterX() - 1.5f;
+		towerDX = tower->GetCenterX() + 1.5f;
+
+		towerY = tower->GetCenterY() - 1.5f;
+		towerDY = tower->GetCenterY() + 1.5f;
+	} else {
+		towerX = tower->GetCenterX() - 2.5f;
+		towerDX = tower->GetCenterX() + 2.5f;
+
+		towerY = tower->GetCenterY() - 2.5f;
+		towerDY = tower->GetCenterY() + 2.5f;
+	}
+	std::vector<float> positions = {towerDX, 0.001, towerY, towerX, 0.001, towerY, towerX, 0.001, towerDY, towerDX, 0.001, towerY,
+		towerX, 0.001, towerDY, towerDX, 0.001, towerDY};
+
+	renderData.positions = positions;
+
+	std::uint8_t towerType = static_cast<std::uint8_t>(tower->GetType());
+	std::uint8_t r = 10 * towerType + 40, g = 5 * towerType + 30, b = 10 * towerType + 20;
+
+	float colorFloat;
+	int color = r << 24 | g << 16 | b << 8 | 255;
+	memcpy(&colorFloat, &color, sizeof(int));
+
+	std::vector<float> colors(6, colorFloat);
+	renderData.colors = colors;
+
+	return renderData;
+}
+
+
+
+GL::VertexArray LoadMobModel() {
+	std::vector<float> positions = {
+		-0.5, 0, -0.5,
+		-0.5, 0, 0.5,
+		0.5, 0, -0.5,
+
+		0.5, 0, -0.5,
+		-0.5, 0, 0.5,
+		0.5, 0, 0.5
+	};
+
+	std::vector<unsigned int> indexes(positions.size() / 3, 0);
+	// for (size_t i = 0; i < indexes.size(); i++) {
+	// 	indexes[i] = i + 1;
+	// }
+	GL::ElementBuffer indexVBO(indexes);
+
+	GL::VertexBuffer positionVBO(positions, POSITION_VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(0, POSITION_VERTEX_SIZE, 0);
+	
+	GL::VertexArray mobVao(std::move(indexVBO)); // each pos = 1 color
+	mobVao.Bind();
+	mobVao.BindVertexBuffer(std::move(positionVBO));
+	mobVao.Unbind();
+	return mobVao;
+}
+
+
+
 }  // namespace WorldLoader
 
+
 }  // namespace render
 }  // namespace td

src/td/render/renderer/EntityRenderer.cpp

@@ -1,4 +1,3 @@
-#include <cassert>
 #include <td/render/renderer/EntityRenderer.h>
 
 #include <td/render/loader/WorldLoader.h>
@@ -6,21 +5,25 @@
 namespace td {
 namespace render {
 
-EntityRenderer::EntityRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World), m_ZombieModel("assets/zombie.glb") {
+EntityRenderer::EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) {
+	m_EntityVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadMobModel());
+	m_Shader->Start();
+	m_Shader->SetColorEffect({1, 0, 1});
 }
 
-EntityRenderer::~EntityRenderer() {
-}
+EntityRenderer::~EntityRenderer() {}
 
 
 
 void EntityRenderer::Render(float a_Lerp) {
+	m_Shader->Start();
 	for (const auto& mob : m_World->GetMobList()) {
 
 		float x = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.x); });
 		float z = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.y); });
 
-		m_ZombieModel.Draw({x, .001, z}, 1.0f, {255, 255, 255, 255});
+		m_Shader->SetModelPos({x, 1, z});
+		Renderer::Render(*m_EntityVao);
 	}
 }
 

src/td/render/renderer/HotkeysRenderer.cpp

@@ -0,0 +1,36 @@
+#include <imgui_internal.h>
+#include <td/render/renderer/HotkeysRenderer.h>
+
+#include <imgui.h>
+#include <optional>
+
+#include <td/render/renderer/ImHotkey.h>
+
+namespace td {
+namespace render {
+
+void HotkeysRenderer::Render(float a_Lerp) {
+	ImGui::Begin("Hotkeys");
+	static std::vector<ImHotKey::HotKey> hotkeys = {{"Layout", "Reorder nodes in a simpler layout", 0xFFFF261D},
+		{"Save", "Save the current graph", 0xFFFF1F1D}, {"Load", "Load an existing graph file", 0xFFFF181D},
+		{"Play/Stop", "Play or stop the animation from the current graph", 0xFFFFFF3F},
+		{"SetKey", "Make a new animation key with the current parameters values at the current time", 0xFFFFFF1F}};
+
+	// The editor is a modal window. bring it with something like that
+	if (ImGui::Button("Edit Hotkeys")) {
+		ImGui::OpenPopup("HotKeys Editor");
+	}
+	ImHotKey::Edit(hotkeys.data(), hotkeys.size(), "HotKeys Editor");
+
+	// ImHotKey also provides a way to retrieve HotKey
+	int hotkey = ImHotKey::GetHotKey(hotkeys.data(), hotkeys.size());
+	if (hotkey != -1) {
+		// handle the hotkey index!
+	}
+	ImGui::End();
+}
+
+HotkeysRenderer::HotkeysRenderer() {}
+
+}  // namespace render
+}  // namespace td

src/td/render/renderer/PlayerListRenderer.cpp

@@ -1,6 +1,6 @@
 #include <td/render/renderer/PlayerListRenderer.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 #include <optional>
 
 namespace td {

src/td/render/renderer/TimerRenderer.cpp

@@ -1,18 +0,0 @@
-#include <client/state/GameState.h>
-#include <td/render/renderer/TimerRenderer.h>
-
-#include <td/render/RayGui.h>
-
-namespace td {
-namespace render {
-
-void TimerRenderer::Render(float a_Lerp) {
-	ImGui::Begin("Timer");
-	ImGui::Text("Time : %02d:%02d", static_cast<int>(m_State.GetElapsedTime()) / 60, static_cast<int>(m_State.GetElapsedTime()) % 60);
-	ImGui::End();
-}
-
-TimerRenderer::TimerRenderer(const client::GameState& a_State) : m_State(a_State) {}
-
-}  // namespace render
-}  // namespace td

src/td/render/renderer/TowerRenderer.cpp

@@ -5,18 +5,21 @@
 namespace td {
 namespace render {
 
-TowerRenderer::TowerRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World), m_TowerModel("assets/turret.obj"), m_TowerTexture("assets/turret_diffuse.png") {
-	m_TowerModel.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = m_TowerTexture;
+TowerRenderer::TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) {
+	m_EntityVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadMobModel());
+	m_Shader->Start();
+	m_Shader->SetColorEffect({0, 0, 1});
 }
 
-TowerRenderer::~TowerRenderer() {
-}
+TowerRenderer::~TowerRenderer() {}
 
 
 
 void TowerRenderer::Render(float a_Lerp) {
+	m_Shader->Start();
 	for (const auto& tower : m_World->GetTowers()) {
-		m_TowerModel.Draw({tower->GetCenterX(), .001, tower->GetCenterY()}, 0.3f, {255, 255, 255, 255});
+		m_Shader->SetModelPos({tower->GetCenterX(), 1, tower->GetCenterY()});
+		Renderer::Render(*m_EntityVao);
 	}
 }
 

src/td/render/renderer/WorldRenderer.cpp

@@ -1,33 +1,21 @@
 #include <td/render/renderer/WorldRenderer.h>
 
-#include <td/Maths.h>
 #include <td/render/loader/WorldLoader.h>
 
-#include <td/render/RayGui.h>
+#include <imgui.h>
 
 namespace td {
 namespace render {
 
-WorldRenderer::WorldRenderer(raylib::Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera) {
-	Mesh mesh = WorldLoader::LoadWorldModel(a_World.get());
-	m_WorldModel = std::make_unique<raylib::Model>(mesh);
+WorldRenderer::WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera) {
+	m_WorldVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadWorldModel(a_World.get()));
 }
 
-WorldRenderer::~WorldRenderer() {
-}
-
-void WorldRenderer::UpdateControls() {
-	if (ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
-		constexpr float sensitivity = 1.0f;
-		float delta = ImGui::GetIO().DeltaTime;
-		auto mouseDelta = ImGui::GetIO().MouseDelta;
-		m_Camera.position.x -= mouseDelta.x * delta * sensitivity;
-		m_Camera.position.z -= mouseDelta.y * delta * sensitivity;
-	}
-}
+WorldRenderer::~WorldRenderer() {}
 
 void WorldRenderer::Render(float a_Lerp) {
-	m_WorldModel->Draw({}, 1.0f, {255, 255, 255, 255});
+	m_Shader->Start();
+	Renderer::Render(*m_WorldVao);
 }
 
 }  // namespace render

src/td/render/shader/CameraShaderProgram.cpp

@@ -4,16 +4,16 @@ namespace td {
 namespace shader {
 
 void CameraShaderProgram::SetProjectionMatrix(const Mat4f& proj) const {
-	// LoadMat4(m_LocationProjection, proj);
+	LoadMat4(m_LocationProjection, proj);
 }
 
 void CameraShaderProgram::SetViewMatrix(const Mat4f& view) const {
-	// LoadMat4(m_LocationView, view);
+	LoadMat4(m_LocationView, view);
 }
 
 void CameraShaderProgram::GetAllUniformLocation() {
-	// m_LocationProjection = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
-	// m_LocationView = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
+	m_LocationProjection = static_cast<unsigned int>(GetUniformLocation("projectionMatrix"));
+	m_LocationView = static_cast<unsigned int>(GetUniformLocation("viewMatrix"));
 }
 
 

src/td/render/shader/EntityShader.cpp

@@ -84,22 +84,22 @@ void main(void){
 #endif
 
 EntityShader::EntityShader() : CameraShaderProgram() {
-	// ShaderProgram::LoadProgram(vertexSource, fragmentSource);
+	ShaderProgram::LoadProgram(vertexSource, fragmentSource);
 }
 
 
 void EntityShader::GetAllUniformLocation() {
-	// CameraShaderProgram::GetAllUniformLocation();
-	// m_LocationColorEffect = static_cast<unsigned int>(GetUniformLocation("ColorEffect"));
-	// m_LocationPosition = static_cast<unsigned int>(GetUniformLocation("modelPosition"));
+	CameraShaderProgram::GetAllUniformLocation();
+	m_LocationColorEffect = static_cast<unsigned int>(GetUniformLocation("ColorEffect"));
+	m_LocationPosition = static_cast<unsigned int>(GetUniformLocation("modelPosition"));
 }
 
 void EntityShader::SetColorEffect(const Vec3f& color) {
-	// LoadVector(m_LocationColorEffect, color);
+	LoadVector(m_LocationColorEffect, color);
 }
 
 void EntityShader::SetModelPos(const Vec3f& pos) const {
-	// LoadVector(m_LocationPosition, pos);
+	LoadVector(m_LocationPosition, pos);
 }
 
 } // namespace shader

src/td/render/shader/ShaderProgram.cpp

@@ -0,0 +1,145 @@
+/*
+ * ShaderProgram.cpp
+ *
+ *  Created on: 31 janv. 2020
+ *      Author: simon
+ */
+
+#include <td/render/shader/ShaderProgram.h>
+#include <td/misc/Log.h>
+#include <td/misc/Format.h>
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+namespace td {
+namespace shader {
+
+ShaderProgram::ShaderProgram() :
+	m_ProgramID(0), m_VertexShaderID(0), m_FragmentShaderID(0) {
+}
+
+ShaderProgram::~ShaderProgram() {
+	CleanUp();
+}
+
+void ShaderProgram::Start() const {
+	glUseProgram(m_ProgramID);
+}
+
+void ShaderProgram::Stop() const {
+	glUseProgram(0);
+}
+
+int ShaderProgram::GetUniformLocation(const std::string& uniformName) const {
+	const int location = glGetUniformLocation(m_ProgramID, uniformName.c_str());
+	if (location == -1) {
+		utils::LOGD(utils::Format("Warning ! Uniform variable %s not found !", uniformName.c_str()));
+	}
+	return location;
+}
+
+void ShaderProgram::LoadFloat(unsigned int location, float value) const {
+	glUniform1f(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadInt(unsigned int location, int value) const {
+	glUniform1i(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadVector(unsigned int location,
+	const Vec2f& vector) const {
+	glUniform2f(static_cast<GLint>(location), vector.x, vector.y);
+}
+
+void ShaderProgram::LoadVector(unsigned int location,
+	const Vec3f& vector) const {
+	glUniform3f(static_cast<GLint>(location), vector.x, vector.y, vector.z);
+}
+
+void ShaderProgram::LoadBoolean(unsigned int location, bool value) const {
+	glUniform1i(static_cast<GLint>(location), value);
+}
+
+void ShaderProgram::LoadMat4(unsigned int location, const Mat4f& mat) const {
+	glUniformMatrix4fv(static_cast<GLint>(location), 1, false, reinterpret_cast<const float*>(&mat));
+}
+
+void ShaderProgram::CleanUp() const {
+	Stop();
+	glDetachShader(m_ProgramID, m_VertexShaderID);
+	glDetachShader(m_ProgramID, m_FragmentShaderID);
+	glDeleteShader(m_VertexShaderID);
+	glDeleteShader(m_FragmentShaderID);
+	glDeleteProgram(m_ProgramID);
+}
+
+void ShaderProgram::LoadProgramFile(const std::string& vertexFile,
+	const std::string& fragmentFile) {
+	m_VertexShaderID = static_cast<unsigned int>(LoadShaderFromFile(vertexFile, GL_VERTEX_SHADER));
+	m_FragmentShaderID = static_cast<unsigned int>(LoadShaderFromFile(fragmentFile, GL_FRAGMENT_SHADER));
+	m_ProgramID = glCreateProgram();
+	glAttachShader(m_ProgramID, m_VertexShaderID);
+	glAttachShader(m_ProgramID, m_FragmentShaderID);
+	glLinkProgram(m_ProgramID);
+	glValidateProgram(m_ProgramID);
+	GetAllUniformLocation();
+}
+
+void ShaderProgram::LoadProgram(const std::string& vertexSource,
+	const std::string& fragmentSource) {
+	m_VertexShaderID = static_cast<unsigned int>(LoadShader(vertexSource, GL_VERTEX_SHADER));
+	m_FragmentShaderID = static_cast<unsigned int>(LoadShader(fragmentSource, GL_FRAGMENT_SHADER));
+	m_ProgramID = glCreateProgram();
+	glAttachShader(m_ProgramID, m_VertexShaderID);
+	glAttachShader(m_ProgramID, m_FragmentShaderID);
+	glLinkProgram(m_ProgramID);
+	glValidateProgram(m_ProgramID);
+	GetAllUniformLocation();
+}
+
+unsigned int ShaderProgram::LoadShader(const std::string& source, GLenum type) {
+	unsigned int shaderID = glCreateShader(type);
+
+	const char* c_str = source.c_str();
+	int* null = 0;
+	glShaderSource(shaderID, 1, &c_str, null); // @suppress("Function cannot be resolved")
+	glCompileShader(shaderID);
+	GLint compilesuccessful;
+	glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compilesuccessful);
+	if (!compilesuccessful) {
+		GLsizei size;
+		glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &size);
+		std::vector<char> shaderError(static_cast<std::size_t>(size));
+		glGetShaderInfoLog(shaderID, size, &size, shaderError.data());
+
+		utils::LOGE("Could not compile shader !");
+
+		utils::LOGE(shaderError.data());
+
+		utils::LOGD(utils::Format("\nShader source : \n"
+			"------------------------------------------------------------------------------------------------------------------------------------\n"
+			"%s\n"
+			"------------------------------------------------------------------------------------------------------------------------------------\n"
+		, source.c_str()));
+	}
+	return shaderID;
+}
+
+unsigned int ShaderProgram::LoadShaderFromFile(const std::string& file, GLenum type) {
+	std::stringstream stream;
+	std::ifstream fileStream(file);
+
+	if (fileStream) {
+		stream << fileStream.rdbuf();
+	} else {
+		return 0;
+	}
+
+	return LoadShader(stream.str(), type);
+}
+
+} // namespace shader
+} // namespace td

src/td/render/shader/WorldShader.cpp

@@ -82,7 +82,7 @@ void main(void){
 #endif
 
 WorldShader::WorldShader() : CameraShaderProgram() {
-	// ShaderProgram::LoadProgram(vertexSource, fragmentSource);
+	ShaderProgram::LoadProgram(vertexSource, fragmentSource);
 }
 
 } // namespace shader

src/td/simulation/ClientSimulation.cpp

@@ -51,8 +51,8 @@ float ClientSimulation::Update(float a_Delta) {
 	// TODO: handle freezes (m_CurrentTime > 2 * m_StepTime)
 	static const float stepTimeSecond = static_cast<float>(m_StepTime) / 1000.0f;
 	m_CurrentTime += a_Delta;
-	while (m_CurrentTime > stepTimeSecond) {
-		m_CurrentTime -= stepTimeSecond;
+	if (m_CurrentTime > stepTimeSecond) {
+		m_CurrentTime = std::fmod(m_CurrentTime, stepTimeSecond);
 		Step();
 	}
 	return (float)m_CurrentTime / stepTimeSecond;

src/td/simulation/CommandApply.cpp

@@ -1,4 +1,3 @@
-#include <td/Types.h>
 #include <td/simulation/CommandApply.h>
 
 namespace td {
@@ -7,7 +6,7 @@ namespace sim {
 CommandApply::CommandApply(const game::World& a_World, WorldSnapshot& a_Snapshot) : m_World(a_World), m_Snapshot(a_Snapshot) {}
 
 void CommandApply::Handle(const protocol::commands::EndCommand& a_End) {
-	(void)m_World;
+	(void) m_World;
 }
 
 void CommandApply::Handle(const protocol::commands::PlaceTowerCommand& a_PlaceTower) {
@@ -25,10 +24,6 @@ void CommandApply::Handle(const protocol::commands::PlayerJoinCommand& a_PlayerJ
 void CommandApply::Handle(const protocol::commands::SpawnTroopCommand& a_SpawnTroop) {
 	auto zombie = std::make_shared<game::Zombie>();
 	zombie->m_Position = a_SpawnTroop->m_Position;
-
-	// TODO: make it spawn dependant
-	zombie->m_Direction = Direction::PositiveY;
-
 	m_Snapshot.m_Mobs.push_back(zombie);
 }
 

src/td/simulation/system/EntityMove.cpp

@@ -1,66 +1,11 @@
-#include <td/Maths.h>
-#include <td/Types.h>
-#include <td/game/WorldTypes.h>
 #include <td/simulation/system/EntityMove.h>
 
-#include <td/game/World.h>
-
 namespace td {
 namespace sim {
 
-static Vec2i GetUnitDirection(Direction a_Direction) {
-	switch (a_Direction) {
-		case Direction::PositiveX:
-			return {1, 0};
-		case Direction::NegativeX:
-			return {-1, 0};
-		case Direction::PositiveY:
-			return {0, 1};
-		case Direction::NegativeY:
-			return {0, -1};
-	}
-	return {0, 0};
-}
-
-class DirectionTileVisitor : public game::TileHandler {
-  private:
-	Direction m_Direction;
-
-  public:
-	DirectionTileVisitor() {}
-
-	virtual void Handle(const game::EmptyTile& a_Tile) override {}
-
-	virtual void Handle(const game::TowerTile& a_Tile) override {}
-
-	virtual void Handle(const game::DecorationTile& a_Tile) override {}
-
-	virtual void Handle(const game::WalkableTile& a_Tile) override {
-		m_Direction = a_Tile->m_Direction;
-	}
-
-	const Direction GetDirection() {
-		return m_Direction;
-	}
-};
-
 void EntityMove::Tick(const game::World& a_World, WorldSnapshot& a_State, FpFloat a_Delta) {
 	for (auto& mob : a_State.m_Mobs) {
-		if (mob->m_HasReachedCastle)
-			continue;
-
-		auto tile = a_World.GetTile(static_cast<std::int32_t>(mob->m_Position.x), static_cast<std::int32_t>(mob->m_Position.y));
-		Direction direction = mob->m_Direction;
-		if (tile) {
-			DirectionTileVisitor visitor;
-			tile->Dispatch(visitor);
-			direction = visitor.GetDirection();
-		}
-		auto directVector = GetUnitDirection(direction);
-		mob->m_Position.x += directVector.x * a_Delta;
-		mob->m_Position.y += directVector.y * a_Delta;
-
-		
+		mob->m_Position.x += a_Delta;
 	}
 }
 

xmake.lua

@@ -2,7 +2,8 @@ add_rules("mode.debug", "mode.release")
 
 add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git")
 
-add_requires("rlimgui", "raylib-cpp", "splib 2.3.2", "zlib", "fpm", "enet6")
+add_requires("imgui 1.92.0", {configs = {sdl3 = true, opengl3 = true}})
+add_requires("libsdl3 3.2.16", "splib 2.3.2", "zlib", "glew", "fpm", "enet6")
 
 set_languages("c++20")
 
@@ -20,8 +21,9 @@ target("Tower-Defense2")
     add_includedirs("include", {public = true})
     set_kind("binary")
     add_files("src/**.cpp")
-    add_packages("rlimgui", "raylib-cpp", "splib", "zlib", "fpm", "enet6", {public = true})
+    add_packages("libsdl3", "imgui", "glew", "splib", "zlib", "fpm", "enet6", {public = true})
     set_rundir(".")
+    add_defines("TD_GL_LOADER_GLEW")
 
 
 -- Tests