wip(surface): winapi event handling

modules/CMakeLists.txt

@@ -274,3 +274,7 @@ target_link_libraries(
 
 # add_executable_module(mirror entrypoint/mirror.cpp)
 # target_link_libraries(mirror PRIVATE libmirror input)
+
+if(ENABLE_SANDBOX)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/sandbox/)
+endif()

modules/input_codes/input_codes.cppm

@@ -2,172 +2,288 @@ export module input.codes;
 import std;
 
 export enum class Key: std::uint16_t {
-	/* digits */
+	none = 0,
-	D0 = 48,
+
-	D1 = 49,
+	left_mouse_button,
-	D2 = 50,
+	right_mouse_button,
-	D3 = 51,
+	middle_mouse_button,
-	D4 = 52,
+
-	D5 = 53,
+	left_mouse = left_mouse_button,
-	D6 = 54,
+	right_mouse = right_mouse_button,
-	D7 = 55,
+	middle_mouse = middle_mouse_button,
-	D8 = 56,
+
-	D9 = 57,
+	l_mouse = left_mouse_button,
-	Semicolon = 59, // ;
+	r_mouse = right_mouse_button,
-	Equal = 61,     // =
+	m_mouse = middle_mouse_button,
+
+	backspace,
+	tab,
+	capslock,
+	enter,
+	space,
+	delete_,
+
+	shift,
+	left_shit = shift,
+	l_shift = shift,
+
+	right_shift,
+	r_shift = right_shift,
+
+	control,
+	left_control = control,
+	l_control = control,
+	ctrl = control,
+	left_ctrl = control,
+	l_ctrl = control,
+
+	right_control,
+	r_control = right_control,
+	right_ctrl = right_control,
+	r_ctrl = right_control,
+
+	alt,
+	left_alt = alt,
+	l_alt = alt,
+
+	right_alt,
+	r_alt = right_alt,
+
+	pageup,
+	pagedown,
+	home,
+	end,
+
+	left_arrow,
+	l_arrow = left_arrow,
+
+	up_arrow,
+	u_arrow = up_arrow,
+
+	right_arrow,
+	r_arrow = right_arrow,
+
+	down_arrow,
+	d_arrow = down_arrow,
+
+	cancel,
+	pause,
+	select,
+	print,
+	snapshot, // aka. print-screen
+	insert,
+	help,
+	sleep,
+	eep = sleep,
+
+	digit_0,
+	digit_1,
+	digit_2,
+	digit_3,
+	digit_4,
+	digit_5,
+	digit_6,
+	digit_7,
+	digit_8,
+	digit_9,
 
 	/* letters */
-	A = 65,
+	a,
-	B = 66,
+	b,
-	C = 67,
+	c,
-	D = 68,
+	d,
-	E = 69,
+	e,
-	F = 70,
+	f,
-	G = 71,
+	g,
-	H = 72,
+	h,
-	I = 73,
+	i,
-	J = 74,
+	j,
-	K = 75,
+	k,
-	L = 76,
+	l,
-	M = 77,
+	m,
-	N = 78,
+	n,
-	O = 79,
+	o,
-	P = 80,
+	p,
-	Q = 81,
+	q,
-	R = 82,
+	r,
-	S = 83,
+	s,
-	t = 84,
+	t,
-	U = 85,
+	u,
-	V = 86,
+	v,
-	W = 87,
+	w,
-	X = 88,
+	x,
-	Y = 89,
+	y,
-	Z = 90,
+	z,
 
-	/* brackets */
+	super,
-	LeftBracket = 91,        // [
+	left_super = super,
-	LBracket = LeftBracket,  // [
+	l_super = super,
-	RightBracket = 93,       // ]
-	RBracket = RightBracket, // ]
 
-	/* arrow */
+	right_super,
-	Right = 262,
+	r_super = right_super,
-	RightArrow = Right,
-	RArrow = Right,
-	Left = 263,
-	LeftArrow = Left,
-	LArrow = Left,
-	Down = 264,
-	DownArrow = Down,
-	DArrow = Down,
-	Up = 265,
-	UpArrow = Up,
-	UArrow = Up,
 
-	/* page */
+	kp_0,
-	PageUp = 266,
+	kp_1,
-	PageDown = 267,
+	kp_2,
-
+	kp_3,
-	/* home/end */
+	kp_4,
-	Home = 268,
+	kp_5,
-	end = 269,
+	kp_6,
-
+	kp_7,
-	/* toggles */
+	kp_8,
-	CapsLock = 280,
+	kp_9,
-	ScrollLock = 281,
+	kp_decimal,
-	NumLock = 282,
+	kp_divide,
-	NumberLock = NumLock,
+	kp_multiply,
+	kp_subtract,
+	kp_add,
+	kp_enter,
+	kp_equal,
 
 	/* function */
-	F1 = 290,
+	f1,
-	F2 = 291,
+	f2,
-	F3 = 292,
+	f3,
-	F4 = 293,
+	f4,
-	F5 = 294,
+	f5,
-	F6 = 295,
+	f6,
-	F7 = 296,
+	f7,
-	F8 = 297,
+	f8,
-	F9 = 298,
+	f9,
-	F10 = 299,
+	f10,
-	F11 = 300,
+	f11,
-	F12 = 301,
+	f12,
-	F13 = 302,
-	F14 = 303,
-	F15 = 304,
-	F16 = 305,
-	F17 = 306,
-	F18 = 307,
-	F19 = 308,
-	F20 = 309,
-	F21 = 310,
-	F22 = 311,
-	F23 = 312,
-	F24 = 313,
-	F25 = 314,
 
-	/* keypad */
+	unknown,
-	Kp0 = 320,
+};
-	Kp1 = 321,
+
-	Kp2 = 322,
+export [[nodiscard]] constexpr auto to_string(Key key) -> std::string
-	Kp3 = 323,
+{
-	Kp4 = 324,
+	using enum Key;
-	Kp5 = 325,
+	switch (key)
-	Kp6 = 326,
+	{
-	Kp7 = 327,
+	case none: return "<none>";
-	Kp8 = 328,
+
-	Kp9 = 329,
+	/* mouse */
-	KpDecimal = 330,
+	case left_mouse_button: return "left_mouse_button";
-	KpDivide = 331,
+	case right_mouse_button: return "right_mouse_button";
-	KpMultiply = 332,
+	case middle_mouse_button: return "middle_mouse_button";
-	KpSubstract = 333,
+
-	KpAdd = 334,
+	/* editing / control */
-	KpEnter = 335,
+	case backspace: return "backspace";
-	KpEqual = 336,
+	case tab: return "tab";
+	case capslock: return "capslock";
+	case enter: return "enter";
+	case space: return "space";
+	case delete_: return "delete";
 
 	/* modifiers */
-	LeftShift = 340,
+	case shift: return "shift";
-	LShift = LeftShift,
+	case control: return "control";
-	LeftControl = 341,
+	case right_control: return "right_control";
-	LControl = LeftControl,
+	case alt: return "alt";
-	LeftAlt = 342,
+	case right_alt: return "right_alt";
-	LAlt = LeftAlt,
-	LeftSuper = 343,
-	LSuper = LeftSuper,
-	RightShift = 344,
-	RShift = 344,
-	RightControl = 345,
-	RControl = 345,
-	RightAlt = 346,
-	RAlt = 346,
-	RightSuper = 347,
-	RSuper = 347,
 
-	/* misc */
+	/* navigation */
-	Space = 32,
+	case pageup: return "pageup";
-	Apostrophe = 39, // '
+	case pagedown: return "pagedown";
-	Quote = Apostrophe,
+	case home: return "home";
+	case end: return "end";
 
-	Comma = 44,           // ,
+	case left_arrow: return "left_arrow";
-	Minus = 45,           // -
+	case up_arrow: return "up_arrow";
-	Period = 46,          // .
+	case right_arrow: return "right_arrow";
-	Slash = 47,           // /
+	case down_arrow: return "down_arrow";
-	ForwardSlash = Slash, // /
-	BackSlash = 92,       // \
 
-	GraveAccent = 96,     // `
+	/* system */
-	Console = GraveAccent,
+	case cancel: return "cancel";
-	World1 = 161, // non-US #1
+	case pause: return "pause";
-	World2 = 162, // non-US #2
+	case select: return "select";
-	Escape = 256,
+	case print: return "print";
-	Esc = Escape,
+	case snapshot: return "snapshot";
-	Enter = 257,
+	case insert: return "insert";
-	Tab = 258,
+	case help: return "help";
-	BackSpace = 259,
+	case sleep: return "sleep";
-	Insert = 260,
-	Delete = 261,
 
-	PrintScreen = 283,
+	/* digits */
-	Pause = 284,
+	case digit_0: return "0";
+	case digit_1: return "1";
+	case digit_2: return "2";
+	case digit_3: return "3";
+	case digit_4: return "4";
+	case digit_5: return "5";
+	case digit_6: return "6";
+	case digit_7: return "7";
+	case digit_8: return "8";
+	case digit_9: return "9";
 
-	Menu = 348,
+	/* letters */
-};
+	case a: return "a";
+	case b: return "b";
+	case c: return "c";
+	case d: return "d";
+	case e: return "e";
+	case f: return "f";
+	case g: return "g";
+	case h: return "h";
+	case i: return "i";
+	case j: return "j";
+	case k: return "k";
+	case l: return "l";
+	case m: return "m";
+	case n: return "n";
+	case o: return "o";
+	case p: return "p";
+	case q: return "q";
+	case r: return "r";
+	case s: return "s";
+	case t: return "t";
+	case u: return "u";
+	case v: return "v";
+	case w: return "w";
+	case x: return "x";
+	case y: return "y";
+	case z: return "z";
+
+	/* super / meta */
+	case super: return "super";
+	case right_super: return "right_super";
+
+	/* keypad */
+	case kp_0: return "kp_0";
+	case kp_1: return "kp_1";
+	case kp_2: return "kp_2";
+	case kp_3: return "kp_3";
+	case kp_4: return "kp_4";
+	case kp_5: return "kp_5";
+	case kp_6: return "kp_6";
+	case kp_7: return "kp_7";
+	case kp_8: return "kp_8";
+	case kp_9: return "kp_9";
+	case kp_decimal: return "kp_decimal";
+	case kp_divide: return "kp_divide";
+	case kp_multiply: return "kp_multiply";
+	case kp_subtract: return "kp_subtract";
+	case kp_add: return "kp_add";
+	case kp_enter: return "kp_enter";
+	case kp_equal: return "kp_equal";
+
+	/* function keys */
+	case f1: return "f1";
+	case f2: return "f2";
+	case f3: return "f3";
+	case f4: return "f4";
+	case f5: return "f5";
+	case f6: return "f6";
+	case f7: return "f7";
+	case f8: return "f8";
+	case f9: return "f9";
+	case f10: return "f10";
+	case f11: return "f11";
+	case f12: return "f12";
+
+	case unknown: return "<unknown>";
+	}
+
+	return "<invalid>";
+}

modules/mirror/system.cppm

@@ -176,31 +176,41 @@ public:
 		);
 
 		auto &input = m_editor_registry->add<InputComponent>(m_window, {});
-		auto quit_action_key = input.add_action(input::InputAction {
+		auto quit_action_key = input.add_action(
-		    .name = "quit",
+		    input::InputAction {
-		    .trigger = input::Trigger { .mapped_keycode = Key::Q },
+		        .name = "quit",
-		});
+		        .trigger = input::Trigger { .mapped_keycode = Key::q },
+		    }
+		);
 
 		auto debug_action_keys = std::array<std::size_t, 4ul> {};
-		debug_action_keys[0] = input.add_action(input::InputAction {
+		debug_action_keys[0] = input.add_action(
-		    .name = "debug_1",
+		    input::InputAction {
-		    .trigger = input::Trigger { .mapped_keycode = Key::D1 },
+		        .name = "debug_1",
-		});
+		        .trigger = input::Trigger { .mapped_keycode = Key::digit_1 },
+		    }
+		);
 
-		debug_action_keys[1] = input.add_action(input::InputAction {
+		debug_action_keys[1] = input.add_action(
-		    .name = "debug_2",
+		    input::InputAction {
-		    .trigger = input::Trigger { .mapped_keycode = Key::D2 },
+		        .name = "debug_2",
-		});
+		        .trigger = input::Trigger { .mapped_keycode = Key::digit_2 },
+		    }
+		);
 
-		debug_action_keys[2] = input.add_action(input::InputAction {
+		debug_action_keys[2] = input.add_action(
-		    .name = "debug_3",
+		    input::InputAction {
-		    .trigger = input::Trigger { .mapped_keycode = Key::D3 },
+		        .name = "debug_3",
-		});
+		        .trigger = input::Trigger { .mapped_keycode = Key::digit_3 },
+		    }
+		);
 
-		debug_action_keys[3] = input.add_action(input::InputAction {
+		debug_action_keys[3] = input.add_action(
-		    .name = "debug_4",
+		    input::InputAction {
-		    .trigger = input::Trigger { .mapped_keycode = Key::D4 },
+		        .name = "debug_4",
-		});
+		        .trigger = input::Trigger { .mapped_keycode = Key::digit_4 },
+		    }
+		);
 
 		m_input_system = memory::create_ref<input::System>(m_editor_registry);
 		m_mirror_system = memory::create_ref<MirrorSystem>(

modules/sandbox/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(sandbox sandbox.cpp)
+target_link_libraries(sandbox PRIVATE logger bitwise env memory time test lt_debug math assets app ecs surface renderer input mirror)
+

modules/sandbox/sandbox.cpp

@@ -0,0 +1,45 @@
+import test.test;
+import time;
+import test.expects;
+import surface.system;
+import surface.events;
+import surface.requests;
+import ecs.registry;
+import memory.scope;
+import memory.reference;
+import logger;
+import math.vec2;
+import app.system;
+import std;
+
+constexpr auto title = "TestWindow";
+constexpr auto width = 800u;
+constexpr auto height = 600u;
+constexpr auto vsync = true;
+constexpr auto visible = false;
+
+int main()
+{
+	auto registry = lt::memory::create_ref<lt::ecs::Registry>();
+	auto system = lt::surface::System { registry };
+
+	auto entity = registry->create_entity();
+
+	system.create_surface_component(
+	    entity,
+	    lt::surface::SurfaceComponent::CreateInfo {
+	        .title = title,
+	        .resolution = { width, height },
+	        .vsync = vsync,
+	        .visible = visible,
+	    }
+	);
+
+	auto timer = lt::time::Timer {};
+	lt::log::trace("Ticking for 3 seconds...");
+	while (timer.elapsed_time() < std::chrono::seconds { 3 })
+	{
+		system.tick({});
+	}
+	lt::log::trace("Three seconds passed, quitting...");
+}

modules/surface/system.cppm

@@ -14,6 +14,7 @@ import debug.assertions;
 import app.system;
 import ecs.registry;
 import math.vec2;
+import input.codes;
 import surface.requests;
 import memory.reference;
 import memory.null_on_move;
@@ -725,11 +726,15 @@ void System::handle_events(SurfaceComponent &surface)
 	queue.clear();
 
 	auto message = MSG {};
-	while (PeekMessage(&message, 0, {}, {}, PM_REMOVE))
+	while (PeekMessage(&message, surface.m_native_data.window, {}, {}, PM_REMOVE))
 	{
-		switch (message.message) {}
+		switch (message.message)
+		{
+		}
 
-		log::debug("Window message type: {}", std::uint32_t { message.message });
+		TranslateMessage(&message);
+		DispatchMessage(&message);
+		// log::debug("Window message type: {}", std::uint32_t { message.message });
 	}
 
 	// auto event = XEvent {};
@@ -834,16 +839,15 @@ void System::handle_requests(SurfaceComponent &surface)
 		[&](const ModifyTitleRequest &request) { modify_title(surface, request); },
 		[&](const ModifyResolutionRequest &request) { modify_resolution(surface, request); },
 		[&](const ModifyPositionRequest &request) { modify_position(surface, request); },
-		[&](const ModifyVisibilityRequest &request) { modify_visiblity(surface, request); },
+		[&](const ModifyVisibilityRequest &request) {
-		[&](const auto &) { log::error("Unknown surface request"); },
+		    modify_visiblity(surface, request);
+		}
 	};
 
 	for (const auto &request : surface.peek_requests())
 	{
 		std::visit(visitor, request);
 	}
-
-	surface.m_requests.clear();
 }
 
 void System::modify_title(SurfaceComponent &surface, const ModifyTitleRequest &request)
@@ -1022,8 +1026,127 @@ void ensure_component_sanity(const SurfaceComponent &component)
 
 auto CALLBACK native_window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) -> LRESULT
 {
+	constexpr auto translate_key = [](auto code) -> Key {
+		switch (code)
+		{
+			using enum Key;
+		case VK_LBUTTON: return left_mouse_button;
+		case VK_RBUTTON: return right_mouse_button;
+		case VK_MBUTTON: return middle_mouse_button;
+
+		case VK_BACK: return backspace;
+		case VK_TAB: return tab;
+		case VK_CAPITAL: return capslock;
+		case VK_RETURN: enter;
+		case VK_SPACE: space;
+		case VK_DELETE: return delete_;
+
+		case VK_SHIFT: shift;
+		case VK_RSHIFT: right_shift;
+
+		case VK_CONTROL: control;
+		case VK_RCONTROL: right_control;
+
+		case VK_MENU: alt;
+		case VK_RMENU: right_alt;
+
+		case VK_PRIOR: return pageup;
+		case VK_NEXT: return pagedown;
+		case VK_END: return end;
+		case VK_HOME: return home;
+
+		case VK_LEFT: return left_arrow;
+		case VK_RIGHT: return right_arrow;
+		case VK_DOWN: return down_arrow;
+		case VK_UP: return up_arrow;
+
+		case VK_CANCEL: return cancel;
+		case VK_PAUSE: return pause;
+		case VK_SELECT: return select;
+		case VK_PRINT: return print;
+		case VK_SNAPSHOT: return snapshot;
+		case VK_INSERT: return insert;
+		case VK_HELP: return help;
+		case VK_SLEEP: return sleep;
+
+		case '0': return digit_0;
+		case '1': return digit_1;
+		case '2': return digit_2;
+		case '3': return digit_3;
+		case '4': return digit_4;
+		case '5': return digit_5;
+		case '6': return digit_6;
+		case '7': return digit_7;
+		case '8': return digit_8;
+		case '9': return digit_9;
+
+		case 'A': return a;
+		case 'B': return b;
+		case 'C': return c;
+		case 'D': return d;
+		case 'E': return e;
+		case 'F': return f;
+		case 'G': return g;
+		case 'H': return h;
+		case 'I': return i;
+		case 'J': return j;
+		case 'K': return k;
+		case 'L': return l;
+		case 'M': return m;
+		case 'N': return n;
+		case 'O': return o;
+		case 'P': return p;
+		case 'Q': return q;
+		case 'R': return r;
+		case 'S': return s;
+		case 'T': return t;
+		case 'U': return u;
+		case 'V': return v;
+		case 'W': return w;
+		case 'X': return x;
+		case 'Y': return y;
+		case 'Z': return z;
+
+		case VK_LWIN: return super;
+		case VK_RWIN: return right_super;
+
+		case VK_NUMPAD0: return kp_0;
+		case VK_NUMPAD1: return kp_1;
+		case VK_NUMPAD2: return kp_2;
+		case VK_NUMPAD3: return kp_3;
+		case VK_NUMPAD4: return kp_4;
+		case VK_NUMPAD5: return kp_5;
+		case VK_NUMPAD6: return kp_6;
+		case VK_NUMPAD7: return kp_7;
+		case VK_NUMPAD8: return kp_8;
+		case VK_NUMPAD9: return kp_9;
+
+		case VK_MULTIPLY: return kp_multiply;
+		case VK_ADD: return kp_add;
+		case VK_SUBTRACT: return kp_subtract;
+		case VK_DECIMAL: return kp_decimal;
+
+		case VK_F1: return f1;
+		case VK_F2: return f2;
+		case VK_F3: return f3;
+		case VK_F4: return f4;
+		case VK_F5: return f5;
+		case VK_F6: return f6;
+		case VK_F7: return f7;
+		case VK_F8: return f8;
+		case VK_F9: return f9;
+		case VK_F10: return f10;
+		case VK_F11: return f11;
+		case VK_F12: return f12;
+
+		default: return unknown;
+		}
+	};
+
 	switch (uMsg)
 	{
+	case WM_KEYDOWN: log::debug("Keydown: {}", to_string(translate_key(wParam)));
+	case WM_KEYUP: log::debug("Keyup__: {}", to_string(translate_key(wParam)));
 	case WM_DESTROY:
 	{
 		PostQuitMessage(0);
@@ -1031,6 +1154,9 @@ auto CALLBACK native_window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lPa
 	}
 	}
 
+
+	// log::debug("Window message type (window proc): {}", std::uint32_t { uMsg
+	// });
 	return DefWindowProcA(hwnd, uMsg, wParam, lParam);
 }
 

tools/cmake/options.cmake

@@ -1,3 +1,4 @@
+add_option(ENABLE_SANDBOX "Enables the building of the sandbox module for experimentation")
 add_option(ENABLE_UNIT_TESTS "Enables the building of the unit test modules")
 add_option(ENABLE_FUZZ_TESTS "Enables the building of the fuzz test modules")
 add_option(