1 files changed, 130 insertions, 160 deletions

diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 20bb030..d6e3159 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -19,7 +19,7 @@
 #include "../api/Color.h"
 #include "../api/Config.h"
 #include "../api/Sprite.h"
-#include "../util/Log.h"
+#include "../util/dbg.h"
 #include "manager/Mediator.h"
 
 #include "SDLContext.h"
@@ -35,10 +35,10 @@ SDLContext::SDLContext(Mediator & mediator) {
 		throw runtime_error(format("SDLContext: SDL_Init error: {}", SDL_GetError()));
 	}
 
-	auto & cfg = Config::get_instance().window_settings;
+	auto & cfg = Config::get_instance().window;
 	SDL_Window * tmp_window
-		= SDL_CreateWindow(cfg.window_title.c_str(), SDL_WINDOWPOS_CENTERED,
-						   SDL_WINDOWPOS_CENTERED, cfg.default_size.x, cfg.default_size.y, 0);
+		= SDL_CreateWindow(cfg.title.c_str(), SDL_WINDOWPOS_CENTERED,
+						   SDL_WINDOWPOS_CENTERED, cfg.size.x, cfg.size.y, 0);
 	if (!tmp_window) {
 		throw runtime_error(format("SDLContext: SDL_Window error: {}", SDL_GetError()));
 	}
@@ -75,118 +75,22 @@ SDLContext::~SDLContext() {
 	SDL_Quit();
 }
 
-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);
-
-		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) {
+Keycode SDLContext::sdl_to_keycode(SDL_Scancode sdl_key) {
+	if (!LOOKUP_TABLE.contains(sdl_key))
 		return Keycode::NONE;
-	}
 
-	return LOOKUP_TABLE[sdl_key];
+	return LOOKUP_TABLE.at(sdl_key);
+}
+void SDLContext::update_keyboard_state() {
+	// Array to hold the key states (true if pressed, false if not)
+	SDL_PumpEvents();
+	const Uint8 * current_state = SDL_GetKeyboardState(nullptr);
+
+	for (int i = 0; i < SDL_NUM_SCANCODES; ++i) {
+		Keycode key = sdl_to_keycode(static_cast<SDL_Scancode>(i));
+		if (key == Keycode::NONE) continue;
+		this->keyboard_state[key] = current_state[i] != 0;
+	}
 }
 
 MouseButton SDLContext::sdl_to_mousebutton(Uint8 sdl_button) {
@@ -279,13 +183,13 @@ void SDLContext::draw(const RenderContext & ctx) {
 }
 
 void SDLContext::update_camera_view(const Camera & cam, const vec2 & new_pos) {
-
 	const Camera::Data & cam_data = cam.data;
+	const Config & config = Config::get_instance();
 	// resize window
 	int w, h;
 	SDL_GetWindowSize(this->game_window.get(), &w, &h);
-	if (w != cam.screen.x || h != cam.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
+	if (w != config.window.size.x || h != config.window.size.y) {
+		SDL_SetWindowSize(this->game_window.get(), config.window.size.x, config.window.size.y);
 	}
 
 	vec2 & zoomed_viewport = this->cam_aux_data.zoomed_viewport;
@@ -294,28 +198,28 @@ void SDLContext::update_camera_view(const Camera & cam, const vec2 & new_pos) {
 	this->cam_aux_data.cam_pos = new_pos;
 
 	zoomed_viewport = cam.viewport_size * cam_data.zoom;
-	float screen_aspect = static_cast<float>(cam.screen.x) / cam.screen.y;
+	float screen_aspect = static_cast<float>(config.window.size.x) / config.window.size.y;
 	float viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		float scale = cam.screen.y / zoomed_viewport.y;
+		float scale = config.window.size.y / zoomed_viewport.y;
 		float adj_width = zoomed_viewport.x * scale;
-		float bar_width = (cam.screen.x - adj_width) / 2;
-		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		float bar_width = (config.window.size.x - adj_width) / 2;
+		this->black_bars[0] = {0, 0, bar_width, (float) config.window.size.y};
+		this->black_bars[1] = {(config.window.size.x - bar_width), 0, bar_width, (float) config.window.size.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		float scale = cam.screen.x / (cam.viewport_size.x * cam_data.zoom);
+		float scale = config.window.size.x / (cam.viewport_size.x * cam_data.zoom);
 		float adj_height = cam.viewport_size.y * scale;
-		float bar_height = (cam.screen.y - adj_height) / 2;
-		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		float bar_height = (config.window.size.y - adj_height) / 2;
+		this->black_bars[0] = {0, 0, (float) config.window.size.x, bar_height};
 		this->black_bars[1]
-			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
+			= {0, (config.window.size.y - bar_height), (float) config.window.size.x, bar_height};
 
 		bar_size = {0, bar_height};
 		render_scale.x = render_scale.y = scale;
@@ -327,8 +231,8 @@ void SDLContext::update_camera_view(const Camera & cam, const vec2 & new_pos) {
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = cam.screen.x,
-		.h = cam.screen.y,
+		.w = config.window.size.x,
+		.h = config.window.size.y,
 	};
 
 	// fill bg color
@@ -375,61 +279,127 @@ std::vector<SDLContext::EventData> SDLContext::get_events() {
 		mouse_pos.y = (event.button.y - cam.bar_size.y) / cam.render_scale.y;
 		switch (event.type) {
 			case SDL_QUIT:
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::SHUTDOWN,
-				});
+				event_list.push_back({.event_type = SDLContext::EventType::SHUTDOWN});
 				break;
-			case SDL_KEYDOWN:
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::KEYDOWN,
+			case SDL_KEYDOWN: {
+				this->update_keyboard_state();
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::KEYDOWN;
+				transfer_event.data.key_data = KeyData{
 					.key = sdl_to_keycode(event.key.keysym.scancode),
-					.key_repeat = (event.key.repeat != 0),
-				});
+					.key_repeat = event.key.repeat != 0,
+				};
+				event_list.push_back(transfer_event);
 				break;
-			case SDL_KEYUP:
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::KEYUP,
+			}
+
+			case SDL_KEYUP: {
+				this->update_keyboard_state();
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::KEYUP;
+				transfer_event.data.key_data = KeyData{
 					.key = sdl_to_keycode(event.key.keysym.scancode),
-				});
+					.key_repeat = false,
+				};
+				event_list.push_back(transfer_event);
 				break;
-			case SDL_MOUSEBUTTONDOWN:
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::MOUSEDOWN,
+			}
+
+			case SDL_MOUSEBUTTONDOWN: {
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::MOUSEDOWN;
+				transfer_event.data.mouse_data = MouseData{
 					.mouse_button = sdl_to_mousebutton(event.button.button),
 					.mouse_position = mouse_pos,
-				});
+				};
+				event_list.push_back(transfer_event);
 				break;
+			}
 			case SDL_MOUSEBUTTONUP: {
-				int x, y;
-				SDL_GetMouseState(&x, &y);
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::MOUSEUP,
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::MOUSEUP;
+				transfer_event.data.mouse_data = MouseData{
 					.mouse_button = sdl_to_mousebutton(event.button.button),
 					.mouse_position = mouse_pos,
-				});
-			} break;
+				};
+				event_list.push_back(transfer_event);
+				break;
+			}
 
 			case SDL_MOUSEMOTION: {
-				event_list.push_back(
-					EventData{.event_type = SDLContext::EventType::MOUSEMOVE,
-							  .mouse_position = mouse_pos,
-							  .rel_mouse_move = {event.motion.xrel, event.motion.yrel}});
-			} break;
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::MOUSEMOVE;
+				transfer_event.data.mouse_data = MouseData{
+					.mouse_position = mouse_pos,
+					.rel_mouse_move = {event.motion.xrel, event.motion.yrel},
+				};
+				event_list.push_back(transfer_event);
+				break;
+			}
 
 			case SDL_MOUSEWHEEL: {
-				event_list.push_back(EventData{
-					.event_type = SDLContext::EventType::MOUSEWHEEL,
+				EventData transfer_event;
+				transfer_event.event_type = SDLContext::EventType::MOUSEWHEEL;
+				transfer_event.data.mouse_data = MouseData{
 					.mouse_position = mouse_pos,
-					// TODO: why is this needed?
 					.scroll_direction = event.wheel.y < 0 ? -1 : 1,
 					.scroll_delta = event.wheel.preciseY,
-				});
-			} break;
+				};
+				event_list.push_back(transfer_event);
+				break;
+			}
+			case SDL_WINDOWEVENT:
+				handle_window_event(event.window, event_list);
+				break;
 		}
 	}
+
 	return event_list;
 }
+
+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(EventData{SDLContext::EventType::WINDOW_EXPOSE});
+			break;
+		case SDL_WINDOWEVENT_RESIZED: {
+			EventData transfer_event;
+			transfer_event.event_type = SDLContext::EventType::WINDOW_RESIZE;
+			transfer_event.data.window_data
+				= WindowData{.resize_dimension = {window_event.data1, window_event.data2}};
+			event_list.push_back(transfer_event);
+			break;
+		}
+		case SDL_WINDOWEVENT_MOVED: {
+			EventData transfer_event;
+			transfer_event.event_type = SDLContext::EventType::WINDOW_MOVE;
+			transfer_event.data.window_data
+				= WindowData{.move_delta = {window_event.data1, window_event.data2}};
+			event_list.push_back(transfer_event);
+			break;
+		}
+		case SDL_WINDOWEVENT_MINIMIZED:
+			event_list.push_back(EventData{SDLContext::EventType::WINDOW_MINIMIZE});
+			break;
+		case SDL_WINDOWEVENT_MAXIMIZED:
+			event_list.push_back(EventData{SDLContext::EventType::WINDOW_MAXIMIZE});
+			break;
+		case SDL_WINDOWEVENT_FOCUS_GAINED:
+			event_list.push_back(EventData{SDLContext::EventType::WINDOW_FOCUS_GAIN});
+			break;
+		case SDL_WINDOWEVENT_FOCUS_LOST:
+			event_list.push_back(EventData{SDLContext::EventType::WINDOW_FOCUS_LOST});
+			break;
+	}
+}
+
 void SDLContext::set_color_texture(const Texture & texture, const Color & color) {
 	SDL_SetTextureColorMod(texture.get_img(), color.r, color.g, color.b);
 	SDL_SetTextureAlphaMod(texture.get_img(), color.a);
 }
+
+const keyboard_state_t & SDLContext::get_keyboard_state() const {
+	return this->keyboard_state;
+}
+