make format

5 files changed, 256 insertions, 228 deletions

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 265e925..d3e99af 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -39,7 +39,7 @@ public:
 class MousePressEvent : public Event {
 public:
 	//! mouse position
-	ivec2 mouse_pos = {0,0};
+	ivec2 mouse_pos = {0, 0};
 
 	//! The mouse button that was pressed.
 	MouseButton button = MouseButton::NONE;
@@ -51,7 +51,7 @@ public:
 class MouseClickEvent : public Event {
 public:
 	//! mouse position
-	ivec2 mouse_pos = {0,0};
+	ivec2 mouse_pos = {0, 0};
 
 	//! The mouse button that was clicked.
 	MouseButton button = MouseButton::NONE;
@@ -63,7 +63,7 @@ public:
 class MouseReleaseEvent : public Event {
 public:
 	//! mouse position
-	ivec2 mouse_pos = {0,0};
+	ivec2 mouse_pos = {0, 0};
 
 	//! The mouse button that was released.
 	MouseButton button = MouseButton::NONE;
@@ -75,9 +75,9 @@ public:
 class MouseMoveEvent : public Event {
 public:
 	//! new mouse position
-	ivec2 mouse_pos = {0,0};
+	ivec2 mouse_pos = {0, 0};
 	//! The change in mouse position relative to the last position (in pixels).
-	ivec2 mouse_delta = {0,0};
+	ivec2 mouse_delta = {0, 0};
 };
 
 /**
@@ -86,7 +86,7 @@ public:
 class MouseScrollEvent : public Event {
 public:
 	//! mouse position when the scroll happened.
-	ivec2 mouse_pos = {0,0};
+	ivec2 mouse_pos = {0, 0};
 	//! scroll direction (-1 = down, 1 = up)
 	int scroll_direction = 0;
 	//! scroll amount in y axis (from and away from the person).
@@ -112,35 +112,35 @@ class ShutDownEvent : public Event {};
  * 
  * When two windows overlap the bottom window gets distorted and that window has to be redrawn.
  */
-class WindowExposeEvent : public Event{};
+class WindowExposeEvent : public Event {};
 
 /**
  * \brief Event triggered to indicate the window is resized.
  */
-class WindowResizeEvent : public Event{
-	public:
+class WindowResizeEvent : public Event {
+public:
 	//! new window dimensions
-	ivec2 dimensions = {0,0};
+	ivec2 dimensions = {0, 0};
 };
 
 /**
  * \brief Event triggered to indicate the window is moved.
  */
-class WindowMoveEvent : public Event{
-	public:
+class WindowMoveEvent : public Event {
+public:
 	//! The change in position relative to the last position (in pixels).
-	ivec2 delta_move = {0,0};
+	ivec2 delta_move = {0, 0};
 };
 
 /**
  * \brief Event triggered to indicate the window is minimized.
  */
-class WindowMinimizeEvent : public Event{};
+class WindowMinimizeEvent : public Event {};
 
 /**
  * \brief Event triggered to indicate the window is maximized
  */
-class WindowMaximizeEvent : public Event{};
+class WindowMaximizeEvent : public Event {};
 
 /**
  * \brief Event triggered to indicate the window gained focus
@@ -148,7 +148,7 @@ class WindowMaximizeEvent : public Event{};
  * This event is triggered when the window receives focus, meaning it becomes the active window
  * for user interaction.
  */
-class WindowFocusGainEvent : public Event{};
+class WindowFocusGainEvent : public Event {};
 
 /**
  * \brief Event triggered to indicate the window lost focus
@@ -156,6 +156,6 @@ class WindowFocusGainEvent : public Event{};
  * This event is triggered when the window loses focus, meaning it is no longer the active window
  * for user interaction.
  */
-class WindowFocusLostEvent : public Event{};
+class WindowFocusLostEvent : public Event {};
 
 } // namespace crepe
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index 78407ee..b63acaf 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -14,9 +14,9 @@ namespace crepe {
 class Transform : public Component {
 public:
 	//! Specifies the coordinate space for transformations.
-	enum Space { 
+	enum Space {
 		//! coordinates are relative to the active camera
-		HUD, 
+		HUD,
 		//! coordinates are relative to the game world
 		WORLD,
 	};
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index ce8218a..722c165 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -81,128 +81,128 @@ SDLContext::~SDLContext() {
 // Function that uses the shared table
 Keycode SDLContext::sdl_to_keycode(SDL_Keycode sdl_key) {
 	static const std::array<Keycode, SDL_NUM_SCANCODES> LOOKUP_TABLE = [] {
-        std::array<Keycode, SDL_NUM_SCANCODES> table{};
-        table.fill(Keycode::NONE);
-
-        // Map all SDL scancodes to Keycodes
-        table[SDL_SCANCODE_SPACE] = Keycode::SPACE;
-        table[SDL_SCANCODE_APOSTROPHE] = Keycode::APOSTROPHE;
-        table[SDL_SCANCODE_COMMA] = Keycode::COMMA;
-        table[SDL_SCANCODE_MINUS] = Keycode::MINUS;
-        table[SDL_SCANCODE_PERIOD] = Keycode::PERIOD;
-        table[SDL_SCANCODE_SLASH] = Keycode::SLASH;
-        table[SDL_SCANCODE_0] = Keycode::D0;
-        table[SDL_SCANCODE_1] = Keycode::D1;
-        table[SDL_SCANCODE_2] = Keycode::D2;
-        table[SDL_SCANCODE_3] = Keycode::D3;
-        table[SDL_SCANCODE_4] = Keycode::D4;
-        table[SDL_SCANCODE_5] = Keycode::D5;
-        table[SDL_SCANCODE_6] = Keycode::D6;
-        table[SDL_SCANCODE_7] = Keycode::D7;
-        table[SDL_SCANCODE_8] = Keycode::D8;
-        table[SDL_SCANCODE_9] = Keycode::D9;
-        table[SDL_SCANCODE_SEMICOLON] = Keycode::SEMICOLON;
-        table[SDL_SCANCODE_EQUALS] = Keycode::EQUAL;
-        table[SDL_SCANCODE_A] = Keycode::A;
-        table[SDL_SCANCODE_B] = Keycode::B;
-        table[SDL_SCANCODE_C] = Keycode::C;
-        table[SDL_SCANCODE_D] = Keycode::D;
-        table[SDL_SCANCODE_E] = Keycode::E;
-        table[SDL_SCANCODE_F] = Keycode::F;
-        table[SDL_SCANCODE_G] = Keycode::G;
-        table[SDL_SCANCODE_H] = Keycode::H;
-        table[SDL_SCANCODE_I] = Keycode::I;
-        table[SDL_SCANCODE_J] = Keycode::J;
-        table[SDL_SCANCODE_K] = Keycode::K;
-        table[SDL_SCANCODE_L] = Keycode::L;
-        table[SDL_SCANCODE_M] = Keycode::M;
-        table[SDL_SCANCODE_N] = Keycode::N;
-        table[SDL_SCANCODE_O] = Keycode::O;
-        table[SDL_SCANCODE_P] = Keycode::P;
-        table[SDL_SCANCODE_Q] = Keycode::Q;
-        table[SDL_SCANCODE_R] = Keycode::R;
-        table[SDL_SCANCODE_S] = Keycode::S;
-        table[SDL_SCANCODE_T] = Keycode::T;
-        table[SDL_SCANCODE_U] = Keycode::U;
-        table[SDL_SCANCODE_V] = Keycode::V;
-        table[SDL_SCANCODE_W] = Keycode::W;
-        table[SDL_SCANCODE_X] = Keycode::X;
-        table[SDL_SCANCODE_Y] = Keycode::Y;
-        table[SDL_SCANCODE_Z] = Keycode::Z;
-        table[SDL_SCANCODE_LEFTBRACKET] = Keycode::LEFT_BRACKET;
-        table[SDL_SCANCODE_BACKSLASH] = Keycode::BACKSLASH;
-        table[SDL_SCANCODE_RIGHTBRACKET] = Keycode::RIGHT_BRACKET;
-        table[SDL_SCANCODE_GRAVE] = Keycode::GRAVE_ACCENT;
-        table[SDL_SCANCODE_ESCAPE] = Keycode::ESCAPE;
-        table[SDL_SCANCODE_RETURN] = Keycode::ENTER;
-        table[SDL_SCANCODE_TAB] = Keycode::TAB;
-        table[SDL_SCANCODE_BACKSPACE] = Keycode::BACKSPACE;
-        table[SDL_SCANCODE_INSERT] = Keycode::INSERT;
-        table[SDL_SCANCODE_DELETE] = Keycode::DELETE;
-        table[SDL_SCANCODE_RIGHT] = Keycode::RIGHT;
-        table[SDL_SCANCODE_LEFT] = Keycode::LEFT;
-        table[SDL_SCANCODE_DOWN] = Keycode::DOWN;
-        table[SDL_SCANCODE_UP] = Keycode::UP;
-        table[SDL_SCANCODE_PAGEUP] = Keycode::PAGE_UP;
-        table[SDL_SCANCODE_PAGEDOWN] = Keycode::PAGE_DOWN;
-        table[SDL_SCANCODE_HOME] = Keycode::HOME;
-        table[SDL_SCANCODE_END] = Keycode::END;
-        table[SDL_SCANCODE_CAPSLOCK] = Keycode::CAPS_LOCK;
-        table[SDL_SCANCODE_SCROLLLOCK] = Keycode::SCROLL_LOCK;
-        table[SDL_SCANCODE_NUMLOCKCLEAR] = Keycode::NUM_LOCK;
-        table[SDL_SCANCODE_PRINTSCREEN] = Keycode::PRINT_SCREEN;
-        table[SDL_SCANCODE_PAUSE] = Keycode::PAUSE;
-        table[SDL_SCANCODE_F1] = Keycode::F1;
-        table[SDL_SCANCODE_F2] = Keycode::F2;
-        table[SDL_SCANCODE_F3] = Keycode::F3;
-        table[SDL_SCANCODE_F4] = Keycode::F4;
-        table[SDL_SCANCODE_F5] = Keycode::F5;
-        table[SDL_SCANCODE_F6] = Keycode::F6;
-        table[SDL_SCANCODE_F7] = Keycode::F7;
-        table[SDL_SCANCODE_F8] = Keycode::F8;
-        table[SDL_SCANCODE_F9] = Keycode::F9;
-        table[SDL_SCANCODE_F10] = Keycode::F10;
-        table[SDL_SCANCODE_F11] = Keycode::F11;
-        table[SDL_SCANCODE_F12] = Keycode::F12;
-        table[SDL_SCANCODE_KP_0] = Keycode::KP0;
-        table[SDL_SCANCODE_KP_1] = Keycode::KP1;
-        table[SDL_SCANCODE_KP_2] = Keycode::KP2;
-        table[SDL_SCANCODE_KP_3] = Keycode::KP3;
-        table[SDL_SCANCODE_KP_4] = Keycode::KP4;
-        table[SDL_SCANCODE_KP_5] = Keycode::KP5;
-        table[SDL_SCANCODE_KP_6] = Keycode::KP6;
-        table[SDL_SCANCODE_KP_7] = Keycode::KP7;
-        table[SDL_SCANCODE_KP_8] = Keycode::KP8;
-        table[SDL_SCANCODE_KP_9] = Keycode::KP9;
-        table[SDL_SCANCODE_LSHIFT] = Keycode::LEFT_SHIFT;
-        table[SDL_SCANCODE_LCTRL] = Keycode::LEFT_CONTROL;
-        table[SDL_SCANCODE_LALT] = Keycode::LEFT_ALT;
-        table[SDL_SCANCODE_LGUI] = Keycode::LEFT_SUPER;
-        table[SDL_SCANCODE_RSHIFT] = Keycode::RIGHT_SHIFT;
-        table[SDL_SCANCODE_RCTRL] = Keycode::RIGHT_CONTROL;
-        table[SDL_SCANCODE_RALT] = Keycode::RIGHT_ALT;
-        table[SDL_SCANCODE_RGUI] = Keycode::RIGHT_SUPER;
-        table[SDL_SCANCODE_MENU] = Keycode::MENU;
-
-        return table;
-    }();
-    if (sdl_key < 0 || sdl_key >= SDL_NUM_SCANCODES) {
-        return Keycode::NONE;
-    }
-    return LOOKUP_TABLE[sdl_key];
+		std::array<Keycode, SDL_NUM_SCANCODES> table{};
+		table.fill(Keycode::NONE);
+
+		// Map all SDL scancodes to Keycodes
+		table[SDL_SCANCODE_SPACE] = Keycode::SPACE;
+		table[SDL_SCANCODE_APOSTROPHE] = Keycode::APOSTROPHE;
+		table[SDL_SCANCODE_COMMA] = Keycode::COMMA;
+		table[SDL_SCANCODE_MINUS] = Keycode::MINUS;
+		table[SDL_SCANCODE_PERIOD] = Keycode::PERIOD;
+		table[SDL_SCANCODE_SLASH] = Keycode::SLASH;
+		table[SDL_SCANCODE_0] = Keycode::D0;
+		table[SDL_SCANCODE_1] = Keycode::D1;
+		table[SDL_SCANCODE_2] = Keycode::D2;
+		table[SDL_SCANCODE_3] = Keycode::D3;
+		table[SDL_SCANCODE_4] = Keycode::D4;
+		table[SDL_SCANCODE_5] = Keycode::D5;
+		table[SDL_SCANCODE_6] = Keycode::D6;
+		table[SDL_SCANCODE_7] = Keycode::D7;
+		table[SDL_SCANCODE_8] = Keycode::D8;
+		table[SDL_SCANCODE_9] = Keycode::D9;
+		table[SDL_SCANCODE_SEMICOLON] = Keycode::SEMICOLON;
+		table[SDL_SCANCODE_EQUALS] = Keycode::EQUAL;
+		table[SDL_SCANCODE_A] = Keycode::A;
+		table[SDL_SCANCODE_B] = Keycode::B;
+		table[SDL_SCANCODE_C] = Keycode::C;
+		table[SDL_SCANCODE_D] = Keycode::D;
+		table[SDL_SCANCODE_E] = Keycode::E;
+		table[SDL_SCANCODE_F] = Keycode::F;
+		table[SDL_SCANCODE_G] = Keycode::G;
+		table[SDL_SCANCODE_H] = Keycode::H;
+		table[SDL_SCANCODE_I] = Keycode::I;
+		table[SDL_SCANCODE_J] = Keycode::J;
+		table[SDL_SCANCODE_K] = Keycode::K;
+		table[SDL_SCANCODE_L] = Keycode::L;
+		table[SDL_SCANCODE_M] = Keycode::M;
+		table[SDL_SCANCODE_N] = Keycode::N;
+		table[SDL_SCANCODE_O] = Keycode::O;
+		table[SDL_SCANCODE_P] = Keycode::P;
+		table[SDL_SCANCODE_Q] = Keycode::Q;
+		table[SDL_SCANCODE_R] = Keycode::R;
+		table[SDL_SCANCODE_S] = Keycode::S;
+		table[SDL_SCANCODE_T] = Keycode::T;
+		table[SDL_SCANCODE_U] = Keycode::U;
+		table[SDL_SCANCODE_V] = Keycode::V;
+		table[SDL_SCANCODE_W] = Keycode::W;
+		table[SDL_SCANCODE_X] = Keycode::X;
+		table[SDL_SCANCODE_Y] = Keycode::Y;
+		table[SDL_SCANCODE_Z] = Keycode::Z;
+		table[SDL_SCANCODE_LEFTBRACKET] = Keycode::LEFT_BRACKET;
+		table[SDL_SCANCODE_BACKSLASH] = Keycode::BACKSLASH;
+		table[SDL_SCANCODE_RIGHTBRACKET] = Keycode::RIGHT_BRACKET;
+		table[SDL_SCANCODE_GRAVE] = Keycode::GRAVE_ACCENT;
+		table[SDL_SCANCODE_ESCAPE] = Keycode::ESCAPE;
+		table[SDL_SCANCODE_RETURN] = Keycode::ENTER;
+		table[SDL_SCANCODE_TAB] = Keycode::TAB;
+		table[SDL_SCANCODE_BACKSPACE] = Keycode::BACKSPACE;
+		table[SDL_SCANCODE_INSERT] = Keycode::INSERT;
+		table[SDL_SCANCODE_DELETE] = Keycode::DELETE;
+		table[SDL_SCANCODE_RIGHT] = Keycode::RIGHT;
+		table[SDL_SCANCODE_LEFT] = Keycode::LEFT;
+		table[SDL_SCANCODE_DOWN] = Keycode::DOWN;
+		table[SDL_SCANCODE_UP] = Keycode::UP;
+		table[SDL_SCANCODE_PAGEUP] = Keycode::PAGE_UP;
+		table[SDL_SCANCODE_PAGEDOWN] = Keycode::PAGE_DOWN;
+		table[SDL_SCANCODE_HOME] = Keycode::HOME;
+		table[SDL_SCANCODE_END] = Keycode::END;
+		table[SDL_SCANCODE_CAPSLOCK] = Keycode::CAPS_LOCK;
+		table[SDL_SCANCODE_SCROLLLOCK] = Keycode::SCROLL_LOCK;
+		table[SDL_SCANCODE_NUMLOCKCLEAR] = Keycode::NUM_LOCK;
+		table[SDL_SCANCODE_PRINTSCREEN] = Keycode::PRINT_SCREEN;
+		table[SDL_SCANCODE_PAUSE] = Keycode::PAUSE;
+		table[SDL_SCANCODE_F1] = Keycode::F1;
+		table[SDL_SCANCODE_F2] = Keycode::F2;
+		table[SDL_SCANCODE_F3] = Keycode::F3;
+		table[SDL_SCANCODE_F4] = Keycode::F4;
+		table[SDL_SCANCODE_F5] = Keycode::F5;
+		table[SDL_SCANCODE_F6] = Keycode::F6;
+		table[SDL_SCANCODE_F7] = Keycode::F7;
+		table[SDL_SCANCODE_F8] = Keycode::F8;
+		table[SDL_SCANCODE_F9] = Keycode::F9;
+		table[SDL_SCANCODE_F10] = Keycode::F10;
+		table[SDL_SCANCODE_F11] = Keycode::F11;
+		table[SDL_SCANCODE_F12] = Keycode::F12;
+		table[SDL_SCANCODE_KP_0] = Keycode::KP0;
+		table[SDL_SCANCODE_KP_1] = Keycode::KP1;
+		table[SDL_SCANCODE_KP_2] = Keycode::KP2;
+		table[SDL_SCANCODE_KP_3] = Keycode::KP3;
+		table[SDL_SCANCODE_KP_4] = Keycode::KP4;
+		table[SDL_SCANCODE_KP_5] = Keycode::KP5;
+		table[SDL_SCANCODE_KP_6] = Keycode::KP6;
+		table[SDL_SCANCODE_KP_7] = Keycode::KP7;
+		table[SDL_SCANCODE_KP_8] = Keycode::KP8;
+		table[SDL_SCANCODE_KP_9] = Keycode::KP9;
+		table[SDL_SCANCODE_LSHIFT] = Keycode::LEFT_SHIFT;
+		table[SDL_SCANCODE_LCTRL] = Keycode::LEFT_CONTROL;
+		table[SDL_SCANCODE_LALT] = Keycode::LEFT_ALT;
+		table[SDL_SCANCODE_LGUI] = Keycode::LEFT_SUPER;
+		table[SDL_SCANCODE_RSHIFT] = Keycode::RIGHT_SHIFT;
+		table[SDL_SCANCODE_RCTRL] = Keycode::RIGHT_CONTROL;
+		table[SDL_SCANCODE_RALT] = Keycode::RIGHT_ALT;
+		table[SDL_SCANCODE_RGUI] = Keycode::RIGHT_SUPER;
+		table[SDL_SCANCODE_MENU] = Keycode::MENU;
+
+		return table;
+	}();
+	if (sdl_key < 0 || sdl_key >= SDL_NUM_SCANCODES) {
+		return Keycode::NONE;
+	}
+	return LOOKUP_TABLE[sdl_key];
 }
 std::array<bool, Keycode::NUM_KEYCODES> SDLContext::get_keyboard_state() {
-    // Array to hold the key states (true if pressed, false if not)
-    std::array<bool, SDL_NUM_SCANCODES> keyState;
+	// Array to hold the key states (true if pressed, false if not)
+	std::array<bool, SDL_NUM_SCANCODES> keyState;
 
-    const Uint8* current_state = SDL_GetKeyboardState(nullptr);
+	const Uint8 * current_state = SDL_GetKeyboardState(nullptr);
 
-    for (int i = 0; i < SDL_NUM_SCANCODES; ++i) {
-        // Set true if the key is pressed, false if not
-        keyState[i] = current_state[i] != 0;
-    }
+	for (int i = 0; i < SDL_NUM_SCANCODES; ++i) {
+		// Set true if the key is pressed, false if not
+		keyState[i] = current_state[i] != 0;
+	}
 
-    return keyState;
+	return keyState;
 }
 
 MouseButton SDLContext::sdl_to_mousebutton(Uint8 sdl_button) {
@@ -389,83 +389,104 @@ ivec2 SDLContext::get_size(const Texture & ctx) {
 void SDLContext::delay(int ms) const { SDL_Delay(ms); }
 
 std::vector<SDLContext::EventData> SDLContext::get_events() {
-    std::vector<SDLContext::EventData> event_list;
-    SDL_Event event;
-
-    // Handle general SDL events
-    while (SDL_PollEvent(&event)) {
-        switch (event.type) {
-            case SDL_QUIT:
-                event_list.push_back({SDLContext::EventType::SHUTDOWN, {}, {}, {}});
-                break;
-            case SDL_KEYDOWN:
-                event_list.push_back({SDLContext::EventType::KEYDOWN, 
-                                      {sdl_to_keycode(event.key.keysym.scancode), event.key.repeat != 0}, {}, {}});
-                break;
-            case SDL_KEYUP:
-                event_list.push_back({SDLContext::EventType::KEYUP, 
-                                      {sdl_to_keycode(event.key.keysym.scancode), false}, {}, {}});
-                break;
-            case SDL_MOUSEBUTTONDOWN:
-                event_list.push_back({SDLContext::EventType::MOUSEDOWN, {}, 
-                                      {sdl_to_mousebutton(event.button.button), {event.button.x, event.button.y}}, {}});
-                break;
-            case SDL_MOUSEBUTTONUP:
-                event_list.push_back({SDLContext::EventType::MOUSEUP, {}, 
-                                      {sdl_to_mousebutton(event.button.button), {event.button.x, event.button.y}}, {}});
-                break;
-            case SDL_MOUSEMOTION:
-                event_list.push_back({SDLContext::EventType::MOUSEMOVE, {}, 
-                                      {{}, {event.motion.x, event.motion.y}, -1, INFINITY, {event.motion.xrel, event.motion.yrel}}, {}});
-                break;
-            case SDL_MOUSEWHEEL:
-                event_list.push_back({SDLContext::EventType::MOUSEWHEEL, {}, 
-                                      {{}, {}, event.wheel.y < 0 ? -1 : 1, event.wheel.preciseY, {}}, {}});
-                break;
-
-            // Forward window events for further processing
-            case SDL_WINDOWEVENT:
-                this->handle_window_event(event.window, event_list);
-                break;
-        }
-    }
-
-    return event_list;
+	std::vector<SDLContext::EventData> event_list;
+	SDL_Event event;
+
+	// Handle general SDL events
+	while (SDL_PollEvent(&event)) {
+		switch (event.type) {
+			case SDL_QUIT:
+				event_list.push_back({SDLContext::EventType::SHUTDOWN, {}, {}, {}});
+				break;
+			case SDL_KEYDOWN:
+				event_list.push_back(
+					{SDLContext::EventType::KEYDOWN,
+					 {sdl_to_keycode(event.key.keysym.scancode), event.key.repeat != 0},
+					 {},
+					 {}});
+				break;
+			case SDL_KEYUP:
+				event_list.push_back({SDLContext::EventType::KEYUP,
+									  {sdl_to_keycode(event.key.keysym.scancode), false},
+									  {},
+									  {}});
+				break;
+			case SDL_MOUSEBUTTONDOWN:
+				event_list.push_back({SDLContext::EventType::MOUSEDOWN,
+									  {},
+									  {sdl_to_mousebutton(event.button.button),
+									   {event.button.x, event.button.y}},
+									  {}});
+				break;
+			case SDL_MOUSEBUTTONUP:
+				event_list.push_back({SDLContext::EventType::MOUSEUP,
+									  {},
+									  {sdl_to_mousebutton(event.button.button),
+									   {event.button.x, event.button.y}},
+									  {}});
+				break;
+			case SDL_MOUSEMOTION:
+				event_list.push_back({SDLContext::EventType::MOUSEMOVE,
+									  {},
+									  {{},
+									   {event.motion.x, event.motion.y},
+									   -1,
+									   INFINITY,
+									   {event.motion.xrel, event.motion.yrel}},
+									  {}});
+				break;
+			case SDL_MOUSEWHEEL:
+				event_list.push_back(
+					{SDLContext::EventType::MOUSEWHEEL,
+					 {},
+					 {{}, {}, event.wheel.y < 0 ? -1 : 1, event.wheel.preciseY, {}},
+					 {}});
+				break;
+
+			// Forward window events for further processing
+			case SDL_WINDOWEVENT:
+				this->handle_window_event(event.window, event_list);
+				break;
+		}
+	}
+
+	return event_list;
 }
 
 // Separate function for SDL_WINDOWEVENT subtypes
-void SDLContext::handle_window_event(const SDL_WindowEvent& window_event,
-                                     std::vector<SDLContext::EventData>& event_list) {
-    switch (window_event.event) {
-        case SDL_WINDOWEVENT_EXPOSED:
-            event_list.push_back({SDLContext::EventType::WINDOW_EXPOSE, {}, {}, {}});
-            break;
-        case SDL_WINDOWEVENT_RESIZED:
-            event_list.push_back({SDLContext::EventType::WINDOW_RESIZE, {}, {}, 
-                                  {{}, {window_event.data1, window_event.data2}}});
-            break;
-        case SDL_WINDOWEVENT_MOVED:
-            event_list.push_back({SDLContext::EventType::WINDOW_MOVE, {}, {}, 
-                                  {{window_event.data1, window_event.data2}, {}}});
-            break;
-        case SDL_WINDOWEVENT_MINIMIZED:
-            event_list.push_back({SDLContext::EventType::WINDOW_MINIMIZE, {}, {}, {}});
-            break;
-        case SDL_WINDOWEVENT_MAXIMIZED:
-            event_list.push_back({SDLContext::EventType::WINDOW_MAXIMIZE, {}, {}, {}});
-            break;
-        case SDL_WINDOWEVENT_FOCUS_GAINED:
-            event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_GAIN, {}, {}, {}});
-            break;
-        case SDL_WINDOWEVENT_FOCUS_LOST:
-            event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_LOST, {}, {}, {}});
-            break;
-    }
+void SDLContext::handle_window_event(const SDL_WindowEvent & window_event,
+									 std::vector<SDLContext::EventData> & event_list) {
+	switch (window_event.event) {
+		case SDL_WINDOWEVENT_EXPOSED:
+			event_list.push_back({SDLContext::EventType::WINDOW_EXPOSE, {}, {}, {}});
+			break;
+		case SDL_WINDOWEVENT_RESIZED:
+			event_list.push_back({SDLContext::EventType::WINDOW_RESIZE,
+								  {},
+								  {},
+								  {{}, {window_event.data1, window_event.data2}}});
+			break;
+		case SDL_WINDOWEVENT_MOVED:
+			event_list.push_back({SDLContext::EventType::WINDOW_MOVE,
+								  {},
+								  {},
+								  {{window_event.data1, window_event.data2}, {}}});
+			break;
+		case SDL_WINDOWEVENT_MINIMIZED:
+			event_list.push_back({SDLContext::EventType::WINDOW_MINIMIZE, {}, {}, {}});
+			break;
+		case SDL_WINDOWEVENT_MAXIMIZED:
+			event_list.push_back({SDLContext::EventType::WINDOW_MAXIMIZE, {}, {}, {}});
+			break;
+		case SDL_WINDOWEVENT_FOCUS_GAINED:
+			event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_GAIN, {}, {}, {}});
+			break;
+		case SDL_WINDOWEVENT_FOCUS_LOST:
+			event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_LOST, {}, {}, {}});
+			break;
+	}
 }
 
-
-
-
 void SDLContext::set_color_texture(const Texture & texture, const Color & color) {
 	SDL_SetTextureColorMod(texture.texture.get(), color.r, color.g, color.b);
 	SDL_SetTextureAlphaMod(texture.texture.get(), color.a);
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 21d17c7..b65ba9c 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -5,11 +5,11 @@
 #include <SDL2/SDL_rect.h>
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_video.h>
+#include <array>
 #include <cmath>
 #include <functional>
 #include <memory>
 #include <string>
-#include <array>
 
 #include "api/Camera.h"
 #include "api/Color.h"
@@ -88,18 +88,18 @@ public:
 		WINDOW_RESIZE,
 		WINDOW_EXPOSE,
 	};
-	struct KeyData{
+	struct KeyData {
 		Keycode key = Keycode::NONE;
 		bool key_repeat = false;
 	};
-	struct MouseData{
+	struct MouseData {
 		MouseButton mouse_button = MouseButton::NONE;
 		ivec2 mouse_position = {-1, -1};
 		int scroll_direction = -1;
 		float scroll_delta = INFINITY;
 		ivec2 rel_mouse_move = {-1, -1};
 	};
-	struct WindowData{
+	struct WindowData {
 		ivec2 move_delta;
 		ivec2 resize_dimension;
 	};
@@ -110,7 +110,7 @@ public:
 		MouseData mouse_data;
 		WindowData window_data;
 	};
-	
+
 	/**
 	 * \brief Gets the singleton instance of SDLContext.
 	 * \return Reference to the SDLContext instance.
@@ -141,8 +141,8 @@ private:
 	 * This method checks if any window events are triggered and adds them to the event_list.
 	 *
 	 */
-	void handle_window_event(const SDL_WindowEvent& window_event,
-                                     std::vector<SDLContext::EventData>& event_list);
+	void handle_window_event(const SDL_WindowEvent & window_event,
+							 std::vector<SDLContext::EventData> & event_list);
 	/**
 	 * \brief Converts an SDL key code to the custom Keycode type.
 	 *
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index dd45821..f5d8536 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -30,13 +30,13 @@ void InputSystem::update() {
 
 	ivec2 camera_origin;
 	camera_origin.y = cam_transform.position.y + current_cam.data.postion_offset.y
-						  - (current_cam.viewport_size.y / 2);
+					  - (current_cam.viewport_size.y / 2);
 	camera_origin.x = cam_transform.position.x + current_cam.data.postion_offset.x
-						  - (current_cam.viewport_size.x / 2);
+					  - (current_cam.viewport_size.x / 2);
 
 	for (const SDLContext::EventData & event : event_list) {
 		// Only calculate mouse coordinates for relevant events
-		if (event.event_type == SDLContext::EventType::MOUSEDOWN 
+		if (event.event_type == SDLContext::EventType::MOUSEDOWN
 			|| event.event_type == SDLContext::EventType::MOUSEUP
 			|| event.event_type == SDLContext::EventType::MOUSEMOVE
 			|| event.event_type == SDLContext::EventType::MOUSEWHEEL) {
@@ -45,10 +45,11 @@ void InputSystem::update() {
 			int adjusted_mouse_y = event.mouse_data.mouse_position.y + camera_origin.y;
 
 			// Check if the mouse is within the viewport
-			bool mouse_in_viewport = !(adjusted_mouse_x < camera_origin.x
-				|| adjusted_mouse_x > camera_origin.x + current_cam.viewport_size.x
-				|| adjusted_mouse_y < camera_origin.y
-				|| adjusted_mouse_y > camera_origin.y + current_cam.viewport_size.y);
+			bool mouse_in_viewport
+				= !(adjusted_mouse_x < camera_origin.x
+					|| adjusted_mouse_x > camera_origin.x + current_cam.viewport_size.x
+					|| adjusted_mouse_y < camera_origin.y
+					|| adjusted_mouse_y > camera_origin.y + current_cam.viewport_size.y);
 
 			if (!mouse_in_viewport) continue;
 
@@ -78,7 +79,8 @@ void InputSystem::update() {
 							.mouse_pos = {adjusted_mouse_x, adjusted_mouse_y},
 							.button = event.mouse_data.mouse_button,
 						});
-						this->handle_click(event.mouse_data.mouse_button, adjusted_mouse_x, adjusted_mouse_y);
+						this->handle_click(event.mouse_data.mouse_button, adjusted_mouse_x,
+										   adjusted_mouse_y);
 					}
 					break;
 				}
@@ -106,7 +108,8 @@ void InputSystem::update() {
 			// Handle non-mouse events
 			switch (event.event_type) {
 				case SDLContext::EventType::KEYDOWN:
-					event_mgr.queue_event<KeyPressEvent>({.repeat = event.key_data.key_repeat, .key = event.key_data.key});
+					event_mgr.queue_event<KeyPressEvent>(
+						{.repeat = event.key_data.key_repeat, .key = event.key_data.key});
 					break;
 				case SDLContext::EventType::KEYUP:
 					event_mgr.queue_event<KeyReleaseEvent>({.key = event.key_data.key});
@@ -118,10 +121,12 @@ void InputSystem::update() {
 					event_mgr.queue_event<WindowExposeEvent>({});
 					break;
 				case SDLContext::EventType::WINDOW_RESIZE:
-					event_mgr.queue_event<WindowResizeEvent>(WindowResizeEvent{.dimensions = event.window_data.resize_dimension});
+					event_mgr.queue_event<WindowResizeEvent>(
+						WindowResizeEvent{.dimensions = event.window_data.resize_dimension});
 					break;
 				case SDLContext::EventType::WINDOW_MOVE:
-					event_mgr.queue_event<WindowMoveEvent>({.delta_move = event.window_data.move_delta});
+					event_mgr.queue_event<WindowMoveEvent>(
+						{.delta_move = event.window_data.move_delta});
 					break;
 				case SDLContext::EventType::WINDOW_MINIMIZE:
 					event_mgr.queue_event<WindowMinimizeEvent>({});
@@ -155,7 +160,8 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data,
 
 		bool was_hovering = button.hover;
 		if (button.active
-			&& this->is_mouse_inside_button(adjusted_mouse_x, adjusted_mouse_y, button, transform)) {
+			&& this->is_mouse_inside_button(adjusted_mouse_x, adjusted_mouse_y, button,
+											transform)) {
 			button.hover = true;
 			if (!was_hovering && button.on_mouse_enter) {
 				button.on_mouse_enter();
@@ -182,7 +188,8 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const int adjus
 		Transform & transform = transform_vec.front().get();
 
 		if (button.active
-			&& this->is_mouse_inside_button(adjusted_mouse_x, adjusted_mouse_y, button, transform)) {
+			&& this->is_mouse_inside_button(adjusted_mouse_x, adjusted_mouse_y, button,
+											transform)) {
 			this->handle_button_press(button);
 		}
 	}