Some code style refactoring #11

AnKi/Input/Input.h

@@ -102,7 +102,7 @@ public:
 	template<typename TFunc>
 	void iteratePressedKeys(TFunc func) const
 	{
-		for(KeyCode i = KeyCode::FIRST; i < KeyCode::COUNT; ++i)
+		for(const KeyCode i : EnumIterable<KeyCode>())
 		{
 			if(m_keys[i] > 0)
 			{
@@ -142,10 +142,10 @@ protected:
 	/// - 0 times: unpressed
 	/// - 1 times: pressed once
 	/// - >1 times: Kept pressed 'n' times continuously
-	Array<U32, U(KeyCode::COUNT)> m_keys;
+	Array<U32, U(KeyCode::kCount)> m_keys;
 
 	/// Mouse btns. Supporting 3 btns & wheel. @see keys
-	Array<U32, U(MouseButton::COUNT)> m_mouseBtns;
+	Array<U32, U(MouseButton::kCount)> m_mouseBtns;
 	Vec2 m_mousePosNdc;
 	UVec2 m_mousePosWin;
 
@@ -156,7 +156,7 @@ protected:
 	Array<U8, U(InputEvent::COUNT)> m_events;
 
 	/// The keybord input as ascii.
-	Array<char, U(KeyCode::COUNT)> m_textInput;
+	Array<char, U(KeyCode::kCount)> m_textInput;
 
 	Bool m_lockCurs = false;
 

AnKi/Input/InputSdl.cpp

@@ -13,18 +13,18 @@ namespace anki {
 
 static MouseButton sdlMouseButtonToAnKi(const U32 sdl)
 {
-	MouseButton out = MouseButton::COUNT;
+	MouseButton out = MouseButton::kCount;
 
 	switch(sdl)
 	{
 	case SDL_BUTTON_LEFT:
-		out = MouseButton::LEFT;
+		out = MouseButton::kLeft;
 		break;
 	case SDL_BUTTON_RIGHT:
-		out = MouseButton::RIGHT;
+		out = MouseButton::kRight;
 		break;
 	case SDL_BUTTON_MIDDLE:
-		out = MouseButton::MIDDLE;
+		out = MouseButton::kMiddle;
 		break;
 	}
 
@@ -106,246 +106,9 @@ Error InputSdl::init()
 {
 	ANKI_ASSERT(m_nativeWindow);
 
-// impl
-#define MAP(sdl, ak) m_sdlToAnki[sdl] = KeyCode::ak
-
-	MAP(SDLK_RETURN, RETURN);
-	MAP(SDLK_ESCAPE, ESCAPE);
-	MAP(SDLK_BACKSPACE, BACKSPACE);
-	MAP(SDLK_TAB, TAB);
-	MAP(SDLK_SPACE, SPACE);
-	MAP(SDLK_EXCLAIM, EXCLAIM);
-	MAP(SDLK_QUOTEDBL, QUOTEDBL);
-	MAP(SDLK_HASH, HASH);
-	MAP(SDLK_PERCENT, PERCENT);
-	MAP(SDLK_DOLLAR, DOLLAR);
-	MAP(SDLK_AMPERSAND, AMPERSAND);
-	MAP(SDLK_QUOTE, QUOTE);
-	MAP(SDLK_LEFTPAREN, LEFTPAREN);
-	MAP(SDLK_RIGHTPAREN, RIGHTPAREN);
-	MAP(SDLK_ASTERISK, ASTERISK);
-	MAP(SDLK_PLUS, PLUS);
-	MAP(SDLK_COMMA, COMMA);
-	MAP(SDLK_MINUS, MINUS);
-	MAP(SDLK_PERIOD, PERIOD);
-	MAP(SDLK_SLASH, SLASH);
-	MAP(SDLK_0, _0);
-	MAP(SDLK_1, _1);
-	MAP(SDLK_2, _2);
-	MAP(SDLK_3, _3);
-	MAP(SDLK_4, _4);
-	MAP(SDLK_5, _5);
-	MAP(SDLK_6, _6);
-	MAP(SDLK_7, _7);
-	MAP(SDLK_8, _8);
-	MAP(SDLK_9, _9);
-	MAP(SDLK_COLON, COLON);
-	MAP(SDLK_SEMICOLON, SEMICOLON);
-	MAP(SDLK_LESS, LESS);
-	MAP(SDLK_EQUALS, EQUALS);
-	MAP(SDLK_GREATER, GREATER);
-	MAP(SDLK_QUESTION, QUESTION);
-	MAP(SDLK_AT, AT);
-	MAP(SDLK_LEFTBRACKET, LEFTBRACKET);
-	MAP(SDLK_BACKSLASH, BACKSLASH);
-	MAP(SDLK_RIGHTBRACKET, RIGHTBRACKET);
-	MAP(SDLK_CARET, CARET);
-	MAP(SDLK_UNDERSCORE, UNDERSCORE);
-	MAP(SDLK_BACKQUOTE, BACKQUOTE);
-	MAP(SDLK_a, A);
-	MAP(SDLK_b, B);
-	MAP(SDLK_c, C);
-	MAP(SDLK_d, D);
-	MAP(SDLK_e, E);
-	MAP(SDLK_f, F);
-	MAP(SDLK_g, G);
-	MAP(SDLK_h, H);
-	MAP(SDLK_i, I);
-	MAP(SDLK_j, J);
-	MAP(SDLK_k, K);
-	MAP(SDLK_l, L);
-	MAP(SDLK_m, M);
-	MAP(SDLK_n, N);
-	MAP(SDLK_o, O);
-	MAP(SDLK_p, P);
-	MAP(SDLK_q, Q);
-	MAP(SDLK_r, R);
-	MAP(SDLK_s, S);
-	MAP(SDLK_t, T);
-	MAP(SDLK_u, U);
-	MAP(SDLK_v, V);
-	MAP(SDLK_w, W);
-	MAP(SDLK_x, X);
-	MAP(SDLK_y, Y);
-	MAP(SDLK_z, Z);
-	MAP(SDLK_CAPSLOCK, CAPSLOCK);
-	MAP(SDLK_F1, F1);
-	MAP(SDLK_F2, F2);
-	MAP(SDLK_F3, F3);
-	MAP(SDLK_F4, F4);
-	MAP(SDLK_F5, F5);
-	MAP(SDLK_F6, F6);
-	MAP(SDLK_F7, F7);
-	MAP(SDLK_F8, F8);
-	MAP(SDLK_F9, F9);
-	MAP(SDLK_F10, F10);
-	MAP(SDLK_F11, F11);
-	MAP(SDLK_F12, F12);
-	MAP(SDLK_PRINTSCREEN, PRINTSCREEN);
-	MAP(SDLK_SCROLLLOCK, SCROLLLOCK);
-	MAP(SDLK_PAUSE, PAUSE);
-	MAP(SDLK_INSERT, INSERT);
-	MAP(SDLK_HOME, HOME);
-	MAP(SDLK_PAGEUP, PAGEUP);
-	MAP(SDLK_DELETE, DELETE);
-	MAP(SDLK_END, END);
-	MAP(SDLK_PAGEDOWN, PAGEDOWN);
-	MAP(SDLK_RIGHT, RIGHT);
-	MAP(SDLK_LEFT, LEFT);
-	MAP(SDLK_DOWN, DOWN);
-	MAP(SDLK_UP, UP);
-	MAP(SDLK_NUMLOCKCLEAR, NUMLOCKCLEAR);
-	MAP(SDLK_KP_DIVIDE, KP_DIVIDE);
-	MAP(SDLK_KP_MULTIPLY, KP_MULTIPLY);
-	MAP(SDLK_KP_MINUS, KP_MINUS);
-	MAP(SDLK_KP_PLUS, KP_PLUS);
-	MAP(SDLK_KP_ENTER, KP_ENTER);
-	MAP(SDLK_KP_1, KP_1);
-	MAP(SDLK_KP_2, KP_2);
-	MAP(SDLK_KP_3, KP_3);
-	MAP(SDLK_KP_4, KP_4);
-	MAP(SDLK_KP_5, KP_5);
-	MAP(SDLK_KP_6, KP_6);
-	MAP(SDLK_KP_7, KP_7);
-	MAP(SDLK_KP_8, KP_8);
-	MAP(SDLK_KP_9, KP_9);
-	MAP(SDLK_KP_0, KP_0);
-	MAP(SDLK_KP_PERIOD, KP_PERIOD);
-	MAP(SDLK_APPLICATION, APPLICATION);
-	MAP(SDLK_POWER, POWER);
-	MAP(SDLK_KP_EQUALS, KP_EQUALS);
-	MAP(SDLK_F13, F13);
-	MAP(SDLK_F14, F14);
-	MAP(SDLK_F15, F15);
-	MAP(SDLK_F16, F16);
-	MAP(SDLK_F17, F17);
-	MAP(SDLK_F18, F18);
-	MAP(SDLK_F19, F19);
-	MAP(SDLK_F20, F20);
-	MAP(SDLK_F21, F21);
-	MAP(SDLK_F22, F22);
-	MAP(SDLK_F23, F23);
-	MAP(SDLK_F24, F24);
-	MAP(SDLK_EXECUTE, EXECUTE);
-	MAP(SDLK_HELP, HELP);
-	MAP(SDLK_MENU, MENU);
-	MAP(SDLK_SELECT, SELECT);
-	MAP(SDLK_STOP, STOP);
-	MAP(SDLK_AGAIN, AGAIN);
-	MAP(SDLK_UNDO, UNDO);
-	MAP(SDLK_CUT, CUT);
-	MAP(SDLK_COPY, COPY);
-	MAP(SDLK_PASTE, PASTE);
-	MAP(SDLK_FIND, FIND);
-	MAP(SDLK_MUTE, MUTE);
-	MAP(SDLK_VOLUMEUP, VOLUMEUP);
-	MAP(SDLK_VOLUMEDOWN, VOLUMEDOWN);
-	MAP(SDLK_KP_COMMA, KP_COMMA);
-	MAP(SDLK_KP_EQUALSAS400, KP_EQUALSAS400);
-	MAP(SDLK_ALTERASE, ALTERASE);
-	MAP(SDLK_SYSREQ, SYSREQ);
-	MAP(SDLK_CANCEL, CANCEL);
-	MAP(SDLK_CLEAR, CLEAR);
-	MAP(SDLK_PRIOR, PRIOR);
-	MAP(SDLK_RETURN2, RETURN2);
-	MAP(SDLK_SEPARATOR, SEPARATOR);
-	MAP(SDLK_OUT, OUT);
-	MAP(SDLK_OPER, OPER);
-	MAP(SDLK_CLEARAGAIN, CLEARAGAIN);
-	MAP(SDLK_CRSEL, CRSEL);
-	MAP(SDLK_EXSEL, EXSEL);
-	MAP(SDLK_KP_00, KP_00);
-	MAP(SDLK_KP_000, KP_000);
-	MAP(SDLK_THOUSANDSSEPARATOR, THOUSANDSSEPARATOR);
-	MAP(SDLK_DECIMALSEPARATOR, DECIMALSEPARATOR);
-	MAP(SDLK_CURRENCYUNIT, CURRENCYUNIT);
-	MAP(SDLK_CURRENCYSUBUNIT, CURRENCYSUBUNIT);
-	MAP(SDLK_KP_LEFTPAREN, KP_LEFTPAREN);
-	MAP(SDLK_KP_RIGHTPAREN, KP_RIGHTPAREN);
-	MAP(SDLK_KP_LEFTBRACE, KP_LEFTBRACE);
-	MAP(SDLK_KP_RIGHTBRACE, KP_RIGHTBRACE);
-	MAP(SDLK_KP_TAB, KP_TAB);
-	MAP(SDLK_KP_BACKSPACE, KP_BACKSPACE);
-	MAP(SDLK_KP_A, KP_A);
-	MAP(SDLK_KP_B, KP_B);
-	MAP(SDLK_KP_C, KP_C);
-	MAP(SDLK_KP_D, KP_D);
-	MAP(SDLK_KP_E, KP_E);
-	MAP(SDLK_KP_F, KP_F);
-	MAP(SDLK_KP_XOR, KP_XOR);
-	MAP(SDLK_KP_POWER, KP_POWER);
-	MAP(SDLK_KP_PERCENT, KP_PERCENT);
-	MAP(SDLK_KP_LESS, KP_LESS);
-	MAP(SDLK_KP_GREATER, KP_GREATER);
-	MAP(SDLK_KP_AMPERSAND, KP_AMPERSAND);
-	MAP(SDLK_KP_DBLAMPERSAND, KP_DBLAMPERSAND);
-	MAP(SDLK_KP_VERTICALBAR, KP_VERTICALBAR);
-	MAP(SDLK_KP_DBLVERTICALBAR, KP_DBLVERTICALBAR);
-	MAP(SDLK_KP_COLON, KP_COLON);
-	MAP(SDLK_KP_HASH, KP_HASH);
-	MAP(SDLK_KP_SPACE, KP_SPACE);
-	MAP(SDLK_KP_AT, KP_AT);
-	MAP(SDLK_KP_EXCLAM, KP_EXCLAM);
-	MAP(SDLK_KP_MEMSTORE, KP_MEMSTORE);
-	MAP(SDLK_KP_MEMRECALL, KP_MEMRECALL);
-	MAP(SDLK_KP_MEMCLEAR, KP_MEMCLEAR);
-	MAP(SDLK_KP_MEMADD, KP_MEMADD);
-	MAP(SDLK_KP_MEMSUBTRACT, KP_MEMSUBTRACT);
-	MAP(SDLK_KP_MEMMULTIPLY, KP_MEMMULTIPLY);
-	MAP(SDLK_KP_MEMDIVIDE, KP_MEMDIVIDE);
-	MAP(SDLK_KP_PLUSMINUS, KP_PLUSMINUS);
-	MAP(SDLK_KP_CLEAR, KP_CLEAR);
-	MAP(SDLK_KP_CLEARENTRY, KP_CLEARENTRY);
-	MAP(SDLK_KP_BINARY, KP_BINARY);
-	MAP(SDLK_KP_OCTAL, KP_OCTAL);
-	MAP(SDLK_KP_DECIMAL, KP_DECIMAL);
-	MAP(SDLK_KP_HEXADECIMAL, KP_HEXADECIMAL);
-	MAP(SDLK_LCTRL, LCTRL);
-	MAP(SDLK_LSHIFT, LSHIFT);
-	MAP(SDLK_LALT, LALT);
-	MAP(SDLK_LGUI, LGUI);
-	MAP(SDLK_RCTRL, RCTRL);
-	MAP(SDLK_RSHIFT, RSHIFT);
-	MAP(SDLK_RALT, RALT);
-	MAP(SDLK_RGUI, RGUI);
-	MAP(SDLK_MODE, MODE);
-	MAP(SDLK_AUDIONEXT, AUDIONEXT);
-	MAP(SDLK_AUDIOPREV, AUDIOPREV);
-	MAP(SDLK_AUDIOSTOP, AUDIOSTOP);
-	MAP(SDLK_AUDIOPLAY, AUDIOPLAY);
-	MAP(SDLK_AUDIOMUTE, AUDIOMUTE);
-	MAP(SDLK_MEDIASELECT, MEDIASELECT);
-	MAP(SDLK_WWW, WWW);
-	MAP(SDLK_MAIL, MAIL);
-	MAP(SDLK_CALCULATOR, CALCULATOR);
-	MAP(SDLK_COMPUTER, COMPUTER);
-	MAP(SDLK_AC_SEARCH, AC_SEARCH);
-	MAP(SDLK_AC_HOME, AC_HOME);
-	MAP(SDLK_AC_BACK, AC_BACK);
-	MAP(SDLK_AC_FORWARD, AC_FORWARD);
-	MAP(SDLK_AC_STOP, AC_STOP);
-	MAP(SDLK_AC_REFRESH, AC_REFRESH);
-	MAP(SDLK_AC_BOOKMARKS, AC_BOOKMARKS);
-	MAP(SDLK_BRIGHTNESSDOWN, BRIGHTNESSDOWN);
-	MAP(SDLK_BRIGHTNESSUP, BRIGHTNESSUP);
-	MAP(SDLK_DISPLAYSWITCH, DISPLAYSWITCH);
-	MAP(SDLK_KBDILLUMTOGGLE, KBDILLUMTOGGLE);
-	MAP(SDLK_KBDILLUMDOWN, KBDILLUMDOWN);
-	MAP(SDLK_KBDILLUMUP, KBDILLUMUP);
-	MAP(SDLK_EJECT, EJECT);
-	MAP(SDLK_SLEEP, SLEEP);
-
-#undef MAP
+#define ANKI_KEY_CODE(ak, sdl) m_sdlToAnki[SDLK_##sdl] = KeyCode::k##ak;
+#include <AnKi/Input/KeyCode.defs.h>
+#undef ANKI_KEY_CODE
 
 	// Call once to clear first events
 	return handleEvents();
@@ -391,7 +154,7 @@ Error InputSdl::handleEventsInternal()
 		case SDL_MOUSEBUTTONDOWN:
 		{
 			MouseButton mb = sdlMouseButtonToAnKi(event.button.button);
-			if(mb != MouseButton::COUNT)
+			if(mb != MouseButton::kCount)
 			{
 				m_mouseBtns[mb] = 1;
 			}
@@ -400,15 +163,15 @@ Error InputSdl::handleEventsInternal()
 		case SDL_MOUSEBUTTONUP:
 		{
 			MouseButton mb = sdlMouseButtonToAnKi(event.button.button);
-			if(mb != MouseButton::COUNT)
+			if(mb != MouseButton::kCount)
 			{
 				m_mouseBtns[mb] = 0;
 			}
 			break;
 		}
 		case SDL_MOUSEWHEEL:
-			m_mouseBtns[MouseButton::SCROLL_UP] = event.wheel.y > 0;
-			m_mouseBtns[MouseButton::SCROLL_DOWN] = event.wheel.y < 0;
+			m_mouseBtns[MouseButton::kScrollUp] = event.wheel.y > 0;
+			m_mouseBtns[MouseButton::kScrollDown] = event.wheel.y < 0;
 			break;
 		case SDL_MOUSEMOTION:
 			m_mousePosWin.x() = event.button.x;

AnKi/Input/KeyCode.defs.h

@@ -0,0 +1,240 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+ANKI_KEY_CODE(Return, RETURN)
+ANKI_KEY_CODE(Escape, ESCAPE)
+ANKI_KEY_CODE(Backspace, BACKSPACE)
+ANKI_KEY_CODE(Tab, TAB)
+ANKI_KEY_CODE(Space, SPACE)
+ANKI_KEY_CODE(Exclaim, EXCLAIM)
+ANKI_KEY_CODE(QuotedBL, QUOTEDBL)
+ANKI_KEY_CODE(Hash, HASH)
+ANKI_KEY_CODE(Percent, PERCENT)
+ANKI_KEY_CODE(Dollar, DOLLAR)
+ANKI_KEY_CODE(Ampersand, AMPERSAND)
+ANKI_KEY_CODE(Quote, QUOTE)
+ANKI_KEY_CODE(LeftParen, LEFTPAREN)
+ANKI_KEY_CODE(RightParen, RIGHTPAREN)
+ANKI_KEY_CODE(Asterisk, ASTERISK)
+ANKI_KEY_CODE(Plus, PLUS)
+ANKI_KEY_CODE(Comma, COMMA)
+ANKI_KEY_CODE(Minus, MINUS)
+ANKI_KEY_CODE(Period, PERIOD)
+ANKI_KEY_CODE(Slack, SLASH)
+ANKI_KEY_CODE(0, 0)
+ANKI_KEY_CODE(1, 1)
+ANKI_KEY_CODE(2, 2)
+ANKI_KEY_CODE(3, 3)
+ANKI_KEY_CODE(4, 4)
+ANKI_KEY_CODE(5, 5)
+ANKI_KEY_CODE(6, 6)
+ANKI_KEY_CODE(7, 7)
+ANKI_KEY_CODE(8, 8)
+ANKI_KEY_CODE(9, 9)
+ANKI_KEY_CODE(Colon, COLON)
+ANKI_KEY_CODE(Semicolon, SEMICOLON)
+ANKI_KEY_CODE(Less, LESS)
+ANKI_KEY_CODE(Equals, EQUALS)
+ANKI_KEY_CODE(Greater, GREATER)
+ANKI_KEY_CODE(Question, QUESTION)
+ANKI_KEY_CODE(At, AT)
+ANKI_KEY_CODE(LeftBracket, LEFTBRACKET)
+ANKI_KEY_CODE(Backslash, BACKSLASH)
+ANKI_KEY_CODE(RightBracket, RIGHTBRACKET)
+ANKI_KEY_CODE(Caret, CARET)
+ANKI_KEY_CODE(Underscore, UNDERSCORE)
+ANKI_KEY_CODE(Backquote, BACKQUOTE)
+ANKI_KEY_CODE(A, a)
+ANKI_KEY_CODE(B, b)
+ANKI_KEY_CODE(C, c)
+ANKI_KEY_CODE(D, d)
+ANKI_KEY_CODE(E, e)
+ANKI_KEY_CODE(F, f)
+ANKI_KEY_CODE(G, g)
+ANKI_KEY_CODE(H, h)
+ANKI_KEY_CODE(I, i)
+ANKI_KEY_CODE(J, j)
+ANKI_KEY_CODE(K, k)
+ANKI_KEY_CODE(L, l)
+ANKI_KEY_CODE(M, m)
+ANKI_KEY_CODE(N, n)
+ANKI_KEY_CODE(O, o)
+ANKI_KEY_CODE(P, p)
+ANKI_KEY_CODE(Q, q)
+ANKI_KEY_CODE(R, r)
+ANKI_KEY_CODE(S, s)
+ANKI_KEY_CODE(T, t)
+ANKI_KEY_CODE(U, u)
+ANKI_KEY_CODE(V, v)
+ANKI_KEY_CODE(W, w)
+ANKI_KEY_CODE(X, x)
+ANKI_KEY_CODE(Y, y)
+ANKI_KEY_CODE(Z, z)
+ANKI_KEY_CODE(Capslock, CAPSLOCK)
+ANKI_KEY_CODE(F1, F1)
+ANKI_KEY_CODE(F2, F2)
+ANKI_KEY_CODE(F3, F3)
+ANKI_KEY_CODE(F4, F4)
+ANKI_KEY_CODE(F5, F5)
+ANKI_KEY_CODE(F6, F6)
+ANKI_KEY_CODE(F7, F7)
+ANKI_KEY_CODE(F8, F8)
+ANKI_KEY_CODE(F9, F9)
+ANKI_KEY_CODE(F10, F10)
+ANKI_KEY_CODE(F11, F11)
+ANKI_KEY_CODE(F12, F12)
+ANKI_KEY_CODE(PrintScreen, PRINTSCREEN)
+ANKI_KEY_CODE(ScrollLock, SCROLLLOCK)
+ANKI_KEY_CODE(Pause, PAUSE)
+ANKI_KEY_CODE(Insert, INSERT)
+ANKI_KEY_CODE(Home, HOME)
+ANKI_KEY_CODE(PageUp, PAGEUP)
+ANKI_KEY_CODE(Delete, DELETE)
+ANKI_KEY_CODE(End, END)
+ANKI_KEY_CODE(PageDown, PAGEDOWN)
+ANKI_KEY_CODE(Right, RIGHT)
+ANKI_KEY_CODE(Left, LEFT)
+ANKI_KEY_CODE(Down, DOWN)
+ANKI_KEY_CODE(Up, UP)
+ANKI_KEY_CODE(NumLockClear, NUMLOCKCLEAR)
+ANKI_KEY_CODE(KpDivide, KP_DIVIDE)
+ANKI_KEY_CODE(KpMultiply, KP_MULTIPLY)
+ANKI_KEY_CODE(KpMinus, KP_MINUS)
+ANKI_KEY_CODE(KpPlus, KP_PLUS)
+ANKI_KEY_CODE(KpEnter, KP_ENTER)
+ANKI_KEY_CODE(Kp1, KP_1)
+ANKI_KEY_CODE(Kp2, KP_2)
+ANKI_KEY_CODE(Kp3, KP_3)
+ANKI_KEY_CODE(Kp4, KP_4)
+ANKI_KEY_CODE(Kp5, KP_5)
+ANKI_KEY_CODE(Kp6, KP_6)
+ANKI_KEY_CODE(Kp7, KP_7)
+ANKI_KEY_CODE(Kp8, KP_8)
+ANKI_KEY_CODE(Kp9, KP_9)
+ANKI_KEY_CODE(Kp0, KP_0)
+ANKI_KEY_CODE(KpPeriod, KP_PERIOD)
+ANKI_KEY_CODE(Application, APPLICATION)
+ANKI_KEY_CODE(Power, POWER)
+ANKI_KEY_CODE(KpEquals, KP_EQUALS)
+ANKI_KEY_CODE(F13, F13)
+ANKI_KEY_CODE(F14, F14)
+ANKI_KEY_CODE(F15, F15)
+ANKI_KEY_CODE(F16, F16)
+ANKI_KEY_CODE(F17, F17)
+ANKI_KEY_CODE(F18, F18)
+ANKI_KEY_CODE(F19, F19)
+ANKI_KEY_CODE(F20, F20)
+ANKI_KEY_CODE(F21, F21)
+ANKI_KEY_CODE(F22, F22)
+ANKI_KEY_CODE(F23, F23)
+ANKI_KEY_CODE(F24, F24)
+ANKI_KEY_CODE(kExecute, EXECUTE)
+ANKI_KEY_CODE(Help, HELP)
+ANKI_KEY_CODE(Menu, MENU)
+ANKI_KEY_CODE(Select, SELECT)
+ANKI_KEY_CODE(Stop, STOP)
+ANKI_KEY_CODE(Again, AGAIN)
+ANKI_KEY_CODE(Undo, UNDO)
+ANKI_KEY_CODE(Cut, CUT)
+ANKI_KEY_CODE(Copy, COPY)
+ANKI_KEY_CODE(Paste, PASTE)
+ANKI_KEY_CODE(Find, FIND)
+ANKI_KEY_CODE(Mute, MUTE)
+ANKI_KEY_CODE(VolumeUp, VOLUMEUP)
+ANKI_KEY_CODE(VolumeDown, VOLUMEDOWN)
+ANKI_KEY_CODE(KpComma, KP_COMMA)
+ANKI_KEY_CODE(KpEqualsAS400, KP_EQUALSAS400)
+ANKI_KEY_CODE(AltErase, ALTERASE)
+ANKI_KEY_CODE(SysReq, SYSREQ)
+ANKI_KEY_CODE(Cancel, CANCEL)
+ANKI_KEY_CODE(Clear, CLEAR)
+ANKI_KEY_CODE(Prior, PRIOR)
+ANKI_KEY_CODE(Return2, RETURN2)
+ANKI_KEY_CODE(Separator, SEPARATOR)
+ANKI_KEY_CODE(Out, OUT)
+ANKI_KEY_CODE(Oper, OPER)
+ANKI_KEY_CODE(ClearAgain, CLEARAGAIN)
+ANKI_KEY_CODE(CrSel, CRSEL)
+ANKI_KEY_CODE(ExSel, EXSEL)
+ANKI_KEY_CODE(Kp00, KP_00)
+ANKI_KEY_CODE(Kp000, KP_000)
+ANKI_KEY_CODE(ThousandsSeparator, THOUSANDSSEPARATOR)
+ANKI_KEY_CODE(DecimalSeparator, DECIMALSEPARATOR)
+ANKI_KEY_CODE(CurrencyUnit, CURRENCYUNIT)
+ANKI_KEY_CODE(CurrencySubUnit, CURRENCYSUBUNIT)
+ANKI_KEY_CODE(KpLeftParen, KP_LEFTPAREN)
+ANKI_KEY_CODE(KpRightParen, KP_RIGHTPAREN)
+ANKI_KEY_CODE(KpLeftBrace, KP_LEFTBRACE)
+ANKI_KEY_CODE(KpRightBrace, KP_RIGHTBRACE)
+ANKI_KEY_CODE(KpTab, KP_TAB)
+ANKI_KEY_CODE(KpBackspace, KP_BACKSPACE)
+ANKI_KEY_CODE(KpA, KP_A)
+ANKI_KEY_CODE(KpB, KP_B)
+ANKI_KEY_CODE(KpC, KP_C)
+ANKI_KEY_CODE(KpD, KP_D)
+ANKI_KEY_CODE(KpE, KP_E)
+ANKI_KEY_CODE(KpF, KP_F)
+ANKI_KEY_CODE(KpXor, KP_XOR)
+ANKI_KEY_CODE(KpPower, KP_POWER)
+ANKI_KEY_CODE(KpPercent, KP_PERCENT)
+ANKI_KEY_CODE(KpLess, KP_LESS)
+ANKI_KEY_CODE(KpGreater, KP_GREATER)
+ANKI_KEY_CODE(KpAmpersand, KP_AMPERSAND)
+ANKI_KEY_CODE(KpDoubleAmpersand, KP_DBLAMPERSAND)
+ANKI_KEY_CODE(KpVerticalBar, KP_VERTICALBAR)
+ANKI_KEY_CODE(KpDoubleVerticalBar, KP_DBLVERTICALBAR)
+ANKI_KEY_CODE(KpColon, KP_COLON)
+ANKI_KEY_CODE(KpHash, KP_HASH)
+ANKI_KEY_CODE(KpSpace, KP_SPACE)
+ANKI_KEY_CODE(KpAt, KP_AT)
+ANKI_KEY_CODE(KpExclam, KP_EXCLAM)
+ANKI_KEY_CODE(KpMemStore, KP_MEMSTORE)
+ANKI_KEY_CODE(KpMemRecall, KP_MEMRECALL)
+ANKI_KEY_CODE(KpMemClear, KP_MEMCLEAR)
+ANKI_KEY_CODE(KpMemAdd, KP_MEMADD)
+ANKI_KEY_CODE(KpMemSubtract, KP_MEMSUBTRACT)
+ANKI_KEY_CODE(KpMemMultiply, KP_MEMMULTIPLY)
+ANKI_KEY_CODE(KpMemDivide, KP_MEMDIVIDE)
+ANKI_KEY_CODE(KpPlusMinus, KP_PLUSMINUS)
+ANKI_KEY_CODE(KpClear, KP_CLEAR)
+ANKI_KEY_CODE(KpClearEntry, KP_CLEARENTRY)
+ANKI_KEY_CODE(KpBinary, KP_BINARY)
+ANKI_KEY_CODE(KpOctal, KP_OCTAL)
+ANKI_KEY_CODE(KpDecimal, KP_DECIMAL)
+ANKI_KEY_CODE(KpHexadecimal, KP_HEXADECIMAL)
+ANKI_KEY_CODE(LeftCtrl, LCTRL)
+ANKI_KEY_CODE(LeftShift, LSHIFT)
+ANKI_KEY_CODE(LeftAlt, LALT)
+ANKI_KEY_CODE(LeftGui, LGUI)
+ANKI_KEY_CODE(RightCtrl, RCTRL)
+ANKI_KEY_CODE(RightShift, RSHIFT)
+ANKI_KEY_CODE(RightAlt, RALT)
+ANKI_KEY_CODE(RightGui, RGUI)
+ANKI_KEY_CODE(Mode, MODE)
+ANKI_KEY_CODE(AudioNext, AUDIONEXT)
+ANKI_KEY_CODE(AudioPrev, AUDIOPREV)
+ANKI_KEY_CODE(AudioStop, AUDIOSTOP)
+ANKI_KEY_CODE(AudioPlay, AUDIOPLAY)
+ANKI_KEY_CODE(AudioMute, AUDIOMUTE)
+ANKI_KEY_CODE(MediaSelect, MEDIASELECT)
+ANKI_KEY_CODE(Www, WWW)
+ANKI_KEY_CODE(Mail, MAIL)
+ANKI_KEY_CODE(Calculator, CALCULATOR)
+ANKI_KEY_CODE(Computer, COMPUTER)
+ANKI_KEY_CODE(AcSearch, AC_SEARCH)
+ANKI_KEY_CODE(AcHome, AC_HOME)
+ANKI_KEY_CODE(AcBack, AC_BACK)
+ANKI_KEY_CODE(AcForward, AC_FORWARD)
+ANKI_KEY_CODE(AcStop, AC_STOP)
+ANKI_KEY_CODE(AcRefresh, AC_REFRESH)
+ANKI_KEY_CODE(AcBookmarks, AC_BOOKMARKS)
+ANKI_KEY_CODE(BrighnessDown, BRIGHTNESSDOWN)
+ANKI_KEY_CODE(BrighnessUp, BRIGHTNESSUP)
+ANKI_KEY_CODE(DisplaySwitch, DISPLAYSWITCH)
+ANKI_KEY_CODE(KbdIlluminationToggle, KBDILLUMTOGGLE)
+ANKI_KEY_CODE(KdbIlluminationDown, KBDILLUMDOWN)
+ANKI_KEY_CODE(KdbIlluminationUp, KBDILLUMUP)
+ANKI_KEY_CODE(kEject, EJECT)
+ANKI_KEY_CODE(kSleep, SLEEP)

AnKi/Input/KeyCode.h

@@ -12,294 +12,50 @@ namespace anki {
 /// Keyboard scancodes taken from SDL
 enum class KeyCode
 {
-	UNKNOWN = 0,
+	kUnknown = 0,
 
-	RETURN,
-	ESCAPE,
-	BACKSPACE,
-	TAB,
-	SPACE,
-	EXCLAIM,
-	QUOTEDBL,
-	HASH,
-	PERCENT,
-	DOLLAR,
-	AMPERSAND,
-	QUOTE,
-	LEFTPAREN,
-	RIGHTPAREN,
-	ASTERISK,
-	PLUS,
-	COMMA,
-	MINUS,
-	PERIOD,
-	SLASH,
-	_0,
-	_1,
-	_2,
-	_3,
-	_4,
-	_5,
-	_6,
-	_7,
-	_8,
-	_9,
-	COLON,
-	SEMICOLON,
-	LESS,
-	EQUALS,
-	GREATER,
-	QUESTION,
-	AT,
+#define ANKI_KEY_CODE(ak, sdl) k##ak,
+#include <AnKi/Input/KeyCode.defs.h>
+#undef ANKI_KEY_CODE
 
-	LEFTBRACKET,
-	BACKSLASH,
-	RIGHTBRACKET,
-	CARET,
-	UNDERSCORE,
-	BACKQUOTE,
-	A,
-	B,
-	C,
-	D,
-	E,
-	F,
-	G,
-	H,
-	I,
-	J,
-	K,
-	L,
-	M,
-	N,
-	O,
-	P,
-	Q,
-	R,
-	S,
-	T,
-	U,
-	V,
-	W,
-	X,
-	Y,
-	Z,
-
-	CAPSLOCK,
-
-	F1,
-	F2,
-	F3,
-	F4,
-	F5,
-	F6,
-	F7,
-	F8,
-	F9,
-	F10,
-	F11,
-	F12,
-
-	PRINTSCREEN,
-	SCROLLLOCK,
-	PAUSE,
-	INSERT,
-	HOME,
-	PAGEUP,
-	DELETE,
-	END,
-	PAGEDOWN,
-	RIGHT,
-	LEFT,
-	DOWN,
-	UP,
-
-	NUMLOCKCLEAR,
-	KP_DIVIDE,
-	KP_MULTIPLY,
-	KP_MINUS,
-	KP_PLUS,
-	KP_ENTER,
-	KP_1,
-	KP_2,
-	KP_3,
-	KP_4,
-	KP_5,
-	KP_6,
-	KP_7,
-	KP_8,
-	KP_9,
-	KP_0,
-	KP_PERIOD,
-
-	APPLICATION,
-	POWER,
-	KP_EQUALS,
-	F13,
-	F14,
-	F15,
-	F16,
-	F17,
-	F18,
-	F19,
-	F20,
-	F21,
-	F22,
-	F23,
-	F24,
-	EXECUTE,
-	HELP,
-	MENU,
-	SELECT,
-	STOP,
-	AGAIN,
-	UNDO,
-	CUT,
-	COPY,
-	PASTE,
-	FIND,
-	MUTE,
-	VOLUMEUP,
-	VOLUMEDOWN,
-	KP_COMMA,
-	KP_EQUALSAS400,
-
-	ALTERASE,
-	SYSREQ,
-	CANCEL,
-	CLEAR,
-	PRIOR,
-	RETURN2,
-	SEPARATOR,
-	OUT,
-	OPER,
-	CLEARAGAIN,
-	CRSEL,
-	EXSEL,
-
-	KP_00,
-	KP_000,
-	THOUSANDSSEPARATOR,
-	DECIMALSEPARATOR,
-	CURRENCYUNIT,
-	CURRENCYSUBUNIT,
-	KP_LEFTPAREN,
-	KP_RIGHTPAREN,
-	KP_LEFTBRACE,
-	KP_RIGHTBRACE,
-	KP_TAB,
-	KP_BACKSPACE,
-	KP_A,
-	KP_B,
-	KP_C,
-	KP_D,
-	KP_E,
-	KP_F,
-	KP_XOR,
-	KP_POWER,
-	KP_PERCENT,
-	KP_LESS,
-	KP_GREATER,
-	KP_AMPERSAND,
-	KP_DBLAMPERSAND,
-	KP_VERTICALBAR,
-	KP_DBLVERTICALBAR,
-	KP_COLON,
-	KP_HASH,
-	KP_SPACE,
-	KP_AT,
-	KP_EXCLAM,
-	KP_MEMSTORE,
-	KP_MEMRECALL,
-	KP_MEMCLEAR,
-	KP_MEMADD,
-	KP_MEMSUBTRACT,
-	KP_MEMMULTIPLY,
-	KP_MEMDIVIDE,
-	KP_PLUSMINUS,
-	KP_CLEAR,
-	KP_CLEARENTRY,
-	KP_BINARY,
-	KP_OCTAL,
-	KP_DECIMAL,
-	KP_HEXADECIMAL,
-
-	LCTRL,
-	LSHIFT,
-	LALT,
-	LGUI,
-	RCTRL,
-	RSHIFT,
-	RALT,
-	RGUI,
-
-	MODE,
-
-	AUDIONEXT,
-	AUDIOPREV,
-	AUDIOSTOP,
-	AUDIOPLAY,
-	AUDIOMUTE,
-	MEDIASELECT,
-	WWW,
-	MAIL,
-	CALCULATOR,
-	COMPUTER,
-	AC_SEARCH,
-	AC_HOME,
-	AC_BACK,
-	AC_FORWARD,
-	AC_STOP,
-	AC_REFRESH,
-	AC_BOOKMARKS,
-
-	BRIGHTNESSDOWN,
-	BRIGHTNESSUP,
-	DISPLAYSWITCH,
-	KBDILLUMTOGGLE,
-	KBDILLUMDOWN,
-	KBDILLUMUP,
-	EJECT,
-	SLEEP,
-
-	COUNT,
-	FIRST = 0,
+	kCount,
+	kFirst = 0,
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(KeyCode)
 
 enum class MouseButton : U8
 {
-	LEFT,
-	MIDDLE,
-	RIGHT,
-	SCROLL_UP,
-	SCROLL_DOWN,
+	kLeft,
+	kMiddle,
+	kRight,
+	kScrollUp,
+	kScrollDown,
 
-	COUNT
+	kCount
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(MouseButton)
 
 enum class TouchPointer : U8
 {
-	_0,
-	_1,
-	_2,
-	_3,
-	_4,
-	_5,
-	_6,
-	_7,
-	_8,
-	_9,
-	_10,
-	_11,
-	_12,
-	_13,
-	_14,
-	_15,
+	k0,
+	k1,
+	k2,
+	k3,
+	k4,
+	k5,
+	k6,
+	k7,
+	k8,
+	k9,
+	k10,
+	k11,
+	k12,
+	k13,
+	k14,
+	k15,
 
 	kCount,
-	kFirst = _0
+	kFirst = k0
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TouchPointer)
 

AnKi/Renderer/ShadowMapping.cpp

@@ -425,7 +425,7 @@ TileAllocatorResult ShadowMapping::allocateTilesAndScratchTiles(U64 lightUuid, U
 		if(res == TileAllocatorResult::ALLOCATION_FAILED)
 		{
 			ANKI_R_LOGW("There is not enough space in the shadow atlas for more shadow maps. "
-						"Increase the r_shadowMappingTileCountPerRowOrColumn or decrease the scene's shadow casters");
+						"Increase the RShadowMappingTileCountPerRowOrColumn or decrease the scene's shadow casters");
 
 			// Invalidate cache entries for what we already allocated
 			for(U j = 0; j < i; ++j)
@@ -459,7 +459,7 @@ TileAllocatorResult ShadowMapping::allocateTilesAndScratchTiles(U64 lightUuid, U
 		if(res == TileAllocatorResult::ALLOCATION_FAILED)
 		{
 			ANKI_R_LOGW("Don't have enough space in the scratch shadow mapping buffer. "
-						"If you see this message too often increase r_shadowMappingScratchTileCountX/Y");
+						"If you see this message too often increase RShadowMappingScratchTileCountX/Y");
 
 			// Invalidate atlas tiles
 			for(U j = 0; j < faceCount; ++j)

AnKi/Scene/PlayerNode.cpp

@@ -86,22 +86,22 @@ public:
 		const F32 speed = 0.5;
 
 		Vec4 moveVec(0.0);
-		if(in.getKey(KeyCode::W))
+		if(in.getKey(KeyCode::kW))
 		{
 			moveVec.z() += 1.0f;
 		}
 
-		if(in.getKey(KeyCode::A))
+		if(in.getKey(KeyCode::kA))
 		{
 			moveVec.x() -= 1.0f;
 		}
 
-		if(in.getKey(KeyCode::S))
+		if(in.getKey(KeyCode::kS))
 		{
 			moveVec.z() -= 1.0f;
 		}
 
-		if(in.getKey(KeyCode::D))
+		if(in.getKey(KeyCode::kD))
 		{
 			moveVec.x() += 1.0f;
 		}

AnKi/Ui/Canvas.cpp

@@ -72,28 +72,28 @@ Error Canvas::init(FontPtr font, U32 fontHeight, U32 width, U32 height)
 
 #define ANKI_HANDLE(ak, im) ImGui::GetIO().KeyMap[im] = static_cast<int>(ak);
 
-	ANKI_HANDLE(KeyCode::TAB, ImGuiKey_Tab)
-	ANKI_HANDLE(KeyCode::LEFT, ImGuiKey_LeftArrow)
-	ANKI_HANDLE(KeyCode::RIGHT, ImGuiKey_RightArrow)
-	ANKI_HANDLE(KeyCode::UP, ImGuiKey_UpArrow)
-	ANKI_HANDLE(KeyCode::DOWN, ImGuiKey_DownArrow)
-	ANKI_HANDLE(KeyCode::PAGEUP, ImGuiKey_PageUp)
-	ANKI_HANDLE(KeyCode::PAGEDOWN, ImGuiKey_PageDown)
-	ANKI_HANDLE(KeyCode::HOME, ImGuiKey_Home)
-	ANKI_HANDLE(KeyCode::END, ImGuiKey_End)
-	ANKI_HANDLE(KeyCode::INSERT, ImGuiKey_Insert)
-	ANKI_HANDLE(KeyCode::DELETE, ImGuiKey_Delete)
-	ANKI_HANDLE(KeyCode::BACKSPACE, ImGuiKey_Backspace)
-	ANKI_HANDLE(KeyCode::SPACE, ImGuiKey_Space)
-	ANKI_HANDLE(KeyCode::RETURN, ImGuiKey_Enter)
+	ANKI_HANDLE(KeyCode::kTab, ImGuiKey_Tab)
+	ANKI_HANDLE(KeyCode::kLeft, ImGuiKey_LeftArrow)
+	ANKI_HANDLE(KeyCode::kRight, ImGuiKey_RightArrow)
+	ANKI_HANDLE(KeyCode::kUp, ImGuiKey_UpArrow)
+	ANKI_HANDLE(KeyCode::kDown, ImGuiKey_DownArrow)
+	ANKI_HANDLE(KeyCode::kPageUp, ImGuiKey_PageUp)
+	ANKI_HANDLE(KeyCode::kPageDown, ImGuiKey_PageDown)
+	ANKI_HANDLE(KeyCode::kHome, ImGuiKey_Home)
+	ANKI_HANDLE(KeyCode::kEnd, ImGuiKey_End)
+	ANKI_HANDLE(KeyCode::kInsert, ImGuiKey_Insert)
+	ANKI_HANDLE(KeyCode::kDelete, ImGuiKey_Delete)
+	ANKI_HANDLE(KeyCode::kBackspace, ImGuiKey_Backspace)
+	ANKI_HANDLE(KeyCode::kSpace, ImGuiKey_Space)
+	ANKI_HANDLE(KeyCode::kReturn, ImGuiKey_Enter)
 	// ANKI_HANDLE(KeyCode::RETURN2, ImGuiKey_Enter)
-	ANKI_HANDLE(KeyCode::ESCAPE, ImGuiKey_Escape)
-	ANKI_HANDLE(KeyCode::A, ImGuiKey_A)
-	ANKI_HANDLE(KeyCode::C, ImGuiKey_C)
-	ANKI_HANDLE(KeyCode::V, ImGuiKey_V)
-	ANKI_HANDLE(KeyCode::X, ImGuiKey_X)
-	ANKI_HANDLE(KeyCode::Y, ImGuiKey_Y)
-	ANKI_HANDLE(KeyCode::Z, ImGuiKey_Z)
+	ANKI_HANDLE(KeyCode::kEscape, ImGuiKey_Escape)
+	ANKI_HANDLE(KeyCode::kA, ImGuiKey_A)
+	ANKI_HANDLE(KeyCode::kC, ImGuiKey_C)
+	ANKI_HANDLE(KeyCode::kV, ImGuiKey_V)
+	ANKI_HANDLE(KeyCode::kX, ImGuiKey_X)
+	ANKI_HANDLE(KeyCode::kY, ImGuiKey_Y)
+	ANKI_HANDLE(KeyCode::kZ, ImGuiKey_Z)
 
 #undef ANKI_HANDLE
 
@@ -121,45 +121,45 @@ void Canvas::handleInput()
 	io.MousePos.x = F32(mousePos.x());
 	io.MousePos.y = F32(mousePos.y());
 
-	io.MouseClicked[0] = in.getMouseButton(MouseButton::LEFT) == 1;
-	io.MouseDown[0] = in.getMouseButton(MouseButton::LEFT) > 0;
+	io.MouseClicked[0] = in.getMouseButton(MouseButton::kLeft) == 1;
+	io.MouseDown[0] = in.getMouseButton(MouseButton::kLeft) > 0;
 
-	if(in.getMouseButton(MouseButton::SCROLL_UP) == 1)
+	if(in.getMouseButton(MouseButton::kScrollUp) == 1)
 	{
-		io.MouseWheel = F32(in.getMouseButton(MouseButton::SCROLL_UP));
+		io.MouseWheel = F32(in.getMouseButton(MouseButton::kScrollUp));
 	}
-	else if(in.getMouseButton(MouseButton::SCROLL_DOWN) == 1)
+	else if(in.getMouseButton(MouseButton::kScrollDown) == 1)
 	{
-		io.MouseWheel = -F32(in.getMouseButton(MouseButton::SCROLL_DOWN));
+		io.MouseWheel = -F32(in.getMouseButton(MouseButton::kScrollDown));
 	}
 
-	io.KeyCtrl = (in.getKey(KeyCode::LCTRL) || in.getKey(KeyCode::RCTRL));
+	io.KeyCtrl = (in.getKey(KeyCode::kLeftCtrl) || in.getKey(KeyCode::kRightCtrl));
 
 // Handle keyboard
-#define ANKI_HANDLE(ak) io.KeysDown[static_cast<int>(ak)] = (in.getKey(ak) == 1);
-
-	ANKI_HANDLE(KeyCode::TAB)
-	ANKI_HANDLE(KeyCode::LEFT)
-	ANKI_HANDLE(KeyCode::RIGHT)
-	ANKI_HANDLE(KeyCode::UP)
-	ANKI_HANDLE(KeyCode::DOWN)
-	ANKI_HANDLE(KeyCode::PAGEUP)
-	ANKI_HANDLE(KeyCode::PAGEDOWN)
-	ANKI_HANDLE(KeyCode::HOME)
-	ANKI_HANDLE(KeyCode::END)
-	ANKI_HANDLE(KeyCode::INSERT)
-	ANKI_HANDLE(KeyCode::DELETE)
-	ANKI_HANDLE(KeyCode::BACKSPACE)
-	ANKI_HANDLE(KeyCode::SPACE)
-	ANKI_HANDLE(KeyCode::RETURN)
+#define ANKI_HANDLE(ak) io.KeysDown[int(ak)] = (in.getKey(ak) == 1);
+
+	ANKI_HANDLE(KeyCode::kTab)
+	ANKI_HANDLE(KeyCode::kLeft)
+	ANKI_HANDLE(KeyCode::kRight)
+	ANKI_HANDLE(KeyCode::kUp)
+	ANKI_HANDLE(KeyCode::kDown)
+	ANKI_HANDLE(KeyCode::kPageUp)
+	ANKI_HANDLE(KeyCode::kPageDown)
+	ANKI_HANDLE(KeyCode::kHome)
+	ANKI_HANDLE(KeyCode::kEnd)
+	ANKI_HANDLE(KeyCode::kInsert)
+	ANKI_HANDLE(KeyCode::kDelete)
+	ANKI_HANDLE(KeyCode::kBackspace)
+	ANKI_HANDLE(KeyCode::kSpace)
+	ANKI_HANDLE(KeyCode::kReturn)
 	// ANKI_HANDLE(KeyCode::RETURN2)
-	ANKI_HANDLE(KeyCode::ESCAPE)
-	ANKI_HANDLE(KeyCode::A)
-	ANKI_HANDLE(KeyCode::C)
-	ANKI_HANDLE(KeyCode::V)
-	ANKI_HANDLE(KeyCode::X)
-	ANKI_HANDLE(KeyCode::Y)
-	ANKI_HANDLE(KeyCode::Z)
+	ANKI_HANDLE(KeyCode::kEscape)
+	ANKI_HANDLE(KeyCode::kA)
+	ANKI_HANDLE(KeyCode::kC)
+	ANKI_HANDLE(KeyCode::kV)
+	ANKI_HANDLE(KeyCode::kX)
+	ANKI_HANDLE(KeyCode::kY)
+	ANKI_HANDLE(KeyCode::kZ)
 
 #undef ANKI_HANDLE
 

Samples/Common/SampleApp.cpp

@@ -50,41 +50,41 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
 	Input& in = getInput();
 
-	if(in.getKey(KeyCode::ESCAPE))
+	if(in.getKey(KeyCode::kEscape))
 	{
 		quit = true;
 		return Error::kNone;
 	}
 
-	if(in.getKey(KeyCode::BACKQUOTE) == 1)
+	if(in.getKey(KeyCode::kBackquote) == 1)
 	{
 		setDisplayDeveloperConsole(!getDisplayDeveloperConsole());
 	}
 
-	if(in.getKey(KeyCode::Y) == 1)
+	if(in.getKey(KeyCode::kY) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget(
 			(renderer.getCurrentDebugRenderTarget() == "GBufferNormals") ? "" : "GBufferNormals");
 	}
 
-	if(in.getKey(KeyCode::U) == 1)
+	if(in.getKey(KeyCode::kU) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget(
 			(renderer.getCurrentDebugRenderTarget() == "IndirectDiffuse") ? "" : "IndirectDiffuse");
 	}
 
-	if(in.getKey(KeyCode::I) == 1)
+	if(in.getKey(KeyCode::kI) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "SSR") ? "" : "SSR");
 	}
 
-	if(in.getKey(KeyCode::O) == 1)
+	if(in.getKey(KeyCode::kO) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "SM_resolve") ? ""
 																									  : "SM_resolve");
 	}
 
-	if(in.getKey(KeyCode::P) == 1)
+	if(in.getKey(KeyCode::kP) == 1)
 	{
 		static U32 idx = 3;
 		++idx;
@@ -107,13 +107,13 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 		}
 	}
 
-	if(in.getKey(KeyCode::L) == 1)
+	if(in.getKey(KeyCode::kL) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget(
 			(renderer.getCurrentDebugRenderTarget() == "LightShading") ? "" : "LightShading");
 	}
 
-	if(in.getKey(KeyCode::H) == 1)
+	if(in.getKey(KeyCode::kH) == 1)
 	{
 		static U32 pressCount = 0;
 		CString rtName;
@@ -136,31 +136,31 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 		pressCount = (pressCount + 1) % 4;
 	}
 
-	if(in.getKey(KeyCode::J) == 1)
+	if(in.getKey(KeyCode::kJ) == 1)
 	{
 		m_config.setRVrs(!m_config.getRVrs());
 	}
 
 	static Vec2 mousePosOn1stClick = in.getMousePosition();
-	if(in.getMouseButton(MouseButton::RIGHT) == 1)
+	if(in.getMouseButton(MouseButton::kRight) == 1)
 	{
 		// Re-init mouse pos
 		mousePosOn1stClick = in.getMousePosition();
 	}
 
-	if(in.getMouseButton(MouseButton::RIGHT) || in.hasTouchDevice())
+	if(in.getMouseButton(MouseButton::kRight) || in.hasTouchDevice())
 	{
 		in.hideCursor(true);
 
 		// move the camera
 		static MoveComponent* mover = &scene.getActiveCameraNode().getFirstComponentOfType<MoveComponent>();
 
-		if(in.getKey(KeyCode::_1) == 1)
+		if(in.getKey(KeyCode::k1) == 1)
 		{
 			mover = &scene.getActiveCameraNode().getFirstComponentOfType<MoveComponent>();
 		}
 
-		if(in.getKey(KeyCode::F1) == 1)
+		if(in.getKey(KeyCode::kF1) == 1)
 		{
 			static U mode = 0;
 			mode = (mode + 1) % 3;
@@ -181,75 +181,75 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 				renderer.getDbg().setDitheredDepthTestEnabled(true);
 			}
 		}
-		if(in.getKey(KeyCode::F2) == 1)
+		if(in.getKey(KeyCode::kF2) == 1)
 		{
 			// renderer.getDbg().flipFlags(DbgFlag::SPATIAL_COMPONENT);
 		}
 
-		if(in.getKey(KeyCode::UP))
+		if(in.getKey(KeyCode::kUp))
 		{
 			mover->rotateLocalX(ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::DOWN))
+		if(in.getKey(KeyCode::kDown))
 		{
 			mover->rotateLocalX(-ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::LEFT))
+		if(in.getKey(KeyCode::kLeft))
 		{
 			mover->rotateLocalY(ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::RIGHT))
+		if(in.getKey(KeyCode::kRight))
 		{
 			mover->rotateLocalY(-ROTATE_ANGLE);
 		}
 
 		static F32 moveDistance = 0.1f;
-		if(in.getMouseButton(MouseButton::SCROLL_UP) == 1)
+		if(in.getMouseButton(MouseButton::kScrollUp) == 1)
 		{
 			moveDistance += 0.1f;
 			moveDistance = min(moveDistance, 10.0f);
 		}
 
-		if(in.getMouseButton(MouseButton::SCROLL_DOWN) == 1)
+		if(in.getMouseButton(MouseButton::kScrollDown) == 1)
 		{
 			moveDistance -= 0.1f;
 			moveDistance = max(moveDistance, 0.1f);
 		}
 
-		if(in.getKey(KeyCode::A))
+		if(in.getKey(KeyCode::kA))
 		{
 			mover->moveLocalX(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::D))
+		if(in.getKey(KeyCode::kD))
 		{
 			mover->moveLocalX(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::Q))
+		if(in.getKey(KeyCode::kQ))
 		{
 			mover->moveLocalY(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::E))
+		if(in.getKey(KeyCode::kE))
 		{
 			mover->moveLocalY(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::W))
+		if(in.getKey(KeyCode::kW))
 		{
 			mover->moveLocalZ(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::S))
+		if(in.getKey(KeyCode::kS))
 		{
 			mover->moveLocalZ(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::F12) == 1 && ANKI_ENABLE_TRACE)
+		if(in.getKey(KeyCode::kF12) == 1 && ANKI_ENABLE_TRACE)
 		{
 			TracerSingleton::get().setEnabled(!TracerSingleton::get().getEnabled());
 		}

Samples/PhysicsPlayground/Main.cpp

@@ -213,18 +213,18 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 	// ANKI_CHECK(SampleApp::userMainLoop(quit));
 	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
 
-	if(getInput().getKey(KeyCode::ESCAPE))
+	if(getInput().getKey(KeyCode::kEscape))
 	{
 		quit = true;
 	}
 
-	if(getInput().getKey(KeyCode::H) == 1)
+	if(getInput().getKey(KeyCode::kH) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "RtShadows") ? ""
 																									 : "RtShadows");
 	}
 
-	if(getInput().getKey(KeyCode::P) == 1)
+	if(getInput().getKey(KeyCode::kP) == 1)
 	{
 		static U32 idx = 3;
 		++idx;
@@ -247,17 +247,17 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 		}
 	}
 
-	if(getInput().getKey(KeyCode::L) == 1)
+	if(getInput().getKey(KeyCode::kL) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "Bloom") ? "" : "Bloom");
 	}
 
-	if(getInput().getKey(KeyCode::J) == 1)
+	if(getInput().getKey(KeyCode::kJ) == 1)
 	{
 		m_config.setRVrs(!m_config.getRVrs());
 	}
 
-	if(getInput().getKey(KeyCode::F1) == 1)
+	if(getInput().getKey(KeyCode::kF1) == 1)
 	{
 		static U mode = 0;
 		mode = (mode + 1) % 3;
@@ -279,13 +279,13 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 		}
 	}
 
-	if(getInput().getKey(KeyCode::R))
+	if(getInput().getKey(KeyCode::kR))
 	{
 		SceneNode& player = getSceneGraph().findSceneNode("player");
 		player.getFirstComponentOfType<PlayerControllerComponent>().moveToPosition(Vec3(0.0f, 2.0f, 0.0f));
 	}
 
-	if(getInput().getMouseButton(MouseButton::LEFT) == 1)
+	if(getInput().getMouseButton(MouseButton::kLeft) == 1)
 	{
 		ANKI_LOGI("Firing a monkey");
 
@@ -318,7 +318,7 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 		ANKI_CHECK(createDestructionEvent(body));
 	}
 
-	if(getInput().getMouseButton(MouseButton::RIGHT) == 1)
+	if(getInput().getMouseButton(MouseButton::kRight) == 1)
 	{
 		Transform camTrf =
 			getSceneGraph().getActiveCameraNode().getFirstComponentOfType<MoveComponent>().getWorldTransform();

Samples/SkeletalAnimation/Main.cpp

@@ -37,7 +37,7 @@ public:
 
 	Error userMainLoop(Bool& quit, Second elapsedTime) override
 	{
-		if(getInput().getKey(KeyCode::Z) == 1)
+		if(getInput().getKey(KeyCode::kZ) == 1)
 		{
 			AnimationPlayInfo animInfo;
 			animInfo.m_startTime = 0.5;

Sandbox/Main.cpp

@@ -93,7 +93,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 	Input& in = getInput();
 	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
 
-	if(in.getKey(KeyCode::ESCAPE))
+	if(in.getKey(KeyCode::kEscape))
 	{
 		quit = true;
 		return Error::kNone;
@@ -102,16 +102,16 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 	// move the camera
 	static MoveComponent* mover = &scene.getActiveCameraNode().getFirstComponentOfType<MoveComponent>();
 
-	if(in.getKey(KeyCode::_1))
+	if(in.getKey(KeyCode::k1))
 	{
 		mover = scene.getActiveCameraNode().tryGetFirstComponentOfType<MoveComponent>();
 	}
-	if(in.getKey(KeyCode::_2))
+	if(in.getKey(KeyCode::k2))
 	{
 		mover = &scene.findSceneNode("Point.018_Orientation").getFirstComponentOfType<MoveComponent>();
 	}
 
-	if(in.getKey(KeyCode::L) == 1)
+	if(in.getKey(KeyCode::kL) == 1)
 	{
 		/*Vec3 origin = mover->getWorldTransform().getOrigin().xyz();
 		printf("%f %f %f\n", origin.x(), origin.y(), origin.z());*/
@@ -119,7 +119,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 		// mover->setLocalRotation(Mat3x4::getIdentity());
 	}
 
-	if(in.getKey(KeyCode::F1) == 1)
+	if(in.getKey(KeyCode::kF1) == 1)
 	{
 		static U mode = 0;
 		mode = (mode + 1) % 3;
@@ -140,49 +140,49 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 			renderer.getDbg().setDitheredDepthTestEnabled(true);
 		}
 	}
-	if(in.getKey(KeyCode::F2) == 1)
+	if(in.getKey(KeyCode::kF2) == 1)
 	{
 		// renderer.getDbg().flipFlags(DbgFlag::SPATIAL_COMPONENT);
 	}
-	if(in.getKey(KeyCode::F3) == 1)
+	if(in.getKey(KeyCode::kF3) == 1)
 	{
 		// renderer.getDbg().flipFlags(DbgFlag::PHYSICS);
 	}
-	if(in.getKey(KeyCode::F4) == 1)
+	if(in.getKey(KeyCode::kF4) == 1)
 	{
 		// renderer.getDbg().flipFlags(DbgFlag::SECTOR_COMPONENT);
 	}
-	if(in.getKey(KeyCode::F6) == 1)
+	if(in.getKey(KeyCode::kF6) == 1)
 	{
 		renderer.getDbg().switchDepthTestEnabled();
 	}
 
-	if(in.getKey(KeyCode::F11) == 1)
+	if(in.getKey(KeyCode::kF11) == 1)
 	{
 		TracerSingleton::get().setEnabled(!TracerSingleton::get().getEnabled());
 	}
 
 #if !PLAYER
 	static Vec2 mousePosOn1stClick = in.getMousePosition();
-	if(in.getMouseButton(MouseButton::RIGHT) == 1)
+	if(in.getMouseButton(MouseButton::kRight) == 1)
 	{
 		// Re-init mouse pos
 		mousePosOn1stClick = in.getMousePosition();
 	}
 
-	if(in.getMouseButton(MouseButton::RIGHT) || in.hasTouchDevice())
+	if(in.getMouseButton(MouseButton::kRight) || in.hasTouchDevice())
 	{
 		constexpr F32 ROTATE_ANGLE = toRad(2.5f);
 		constexpr F32 MOUSE_SENSITIVITY = 5.0f;
 
 		in.hideCursor(true);
 
-		if(in.getKey(KeyCode::_1) == 1)
+		if(in.getKey(KeyCode::k1) == 1)
 		{
 			mover = &scene.getActiveCameraNode().getFirstComponentOfType<MoveComponent>();
 		}
 
-		if(in.getKey(KeyCode::F1) == 1)
+		if(in.getKey(KeyCode::kF1) == 1)
 		{
 			static U mode = 0;
 			mode = (mode + 1) % 3;
@@ -203,75 +203,75 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 				renderer.getDbg().setDitheredDepthTestEnabled(true);
 			}
 		}
-		if(in.getKey(KeyCode::F2) == 1)
+		if(in.getKey(KeyCode::kF2) == 1)
 		{
 			// renderer.getDbg().flipFlags(DbgFlag::SPATIAL_COMPONENT);
 		}
 
-		if(in.getKey(KeyCode::UP))
+		if(in.getKey(KeyCode::kUp))
 		{
 			mover->rotateLocalX(ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::DOWN))
+		if(in.getKey(KeyCode::kDown))
 		{
 			mover->rotateLocalX(-ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::LEFT))
+		if(in.getKey(KeyCode::kLeft))
 		{
 			mover->rotateLocalY(ROTATE_ANGLE);
 		}
 
-		if(in.getKey(KeyCode::RIGHT))
+		if(in.getKey(KeyCode::kRight))
 		{
 			mover->rotateLocalY(-ROTATE_ANGLE);
 		}
 
 		static F32 moveDistance = 0.1f;
-		if(in.getMouseButton(MouseButton::SCROLL_UP) == 1)
+		if(in.getMouseButton(MouseButton::kScrollUp) == 1)
 		{
 			moveDistance += 0.1f;
 			moveDistance = min(moveDistance, 10.0f);
 		}
 
-		if(in.getMouseButton(MouseButton::SCROLL_DOWN) == 1)
+		if(in.getMouseButton(MouseButton::kScrollDown) == 1)
 		{
 			moveDistance -= 0.1f;
 			moveDistance = max(moveDistance, 0.1f);
 		}
 
-		if(in.getKey(KeyCode::A))
+		if(in.getKey(KeyCode::kA))
 		{
 			mover->moveLocalX(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::D))
+		if(in.getKey(KeyCode::kD))
 		{
 			mover->moveLocalX(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::Q))
+		if(in.getKey(KeyCode::kQ))
 		{
 			mover->moveLocalY(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::E))
+		if(in.getKey(KeyCode::kE))
 		{
 			mover->moveLocalY(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::W))
+		if(in.getKey(KeyCode::kW))
 		{
 			mover->moveLocalZ(-moveDistance);
 		}
 
-		if(in.getKey(KeyCode::S))
+		if(in.getKey(KeyCode::kS))
 		{
 			mover->moveLocalZ(moveDistance);
 		}
 
-		if(in.getKey(KeyCode::F12) == 1 && ANKI_ENABLE_TRACE)
+		if(in.getKey(KeyCode::kF12) == 1 && ANKI_ENABLE_TRACE)
 		{
 			TracerSingleton::get().setEnabled(!TracerSingleton::get().getEnabled());
 		}
@@ -354,24 +354,24 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 	}
 #endif
 
-	if(in.getKey(KeyCode::U) == 1)
+	if(in.getKey(KeyCode::kU) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget(
 			(renderer.getCurrentDebugRenderTarget() == "IndirectDiffuse") ? "" : "IndirectDiffuse");
 	}
 
-	if(in.getKey(KeyCode::I) == 1)
+	if(in.getKey(KeyCode::kI) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "SSR") ? "" : "SSR");
 	}
 
-	if(in.getKey(KeyCode::O) == 1)
+	if(in.getKey(KeyCode::kO) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "SM_resolve") ? ""
 																									  : "SM_resolve");
 	}
 
-	if(in.getKey(KeyCode::H) == 1)
+	if(in.getKey(KeyCode::kH) == 1)
 	{
 		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "RtShadows") ? ""
 																									 : "RtShadows");
@@ -384,7 +384,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 												 : "MotionVectorsHistoryLength");
 	}*/
 
-	if(in.getKey(KeyCode::P) == 1)
+	if(in.getKey(KeyCode::kP) == 1)
 	{
 		static U32 idx = 3;
 		++idx;
@@ -407,7 +407,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 		}
 	}
 
-	if(in.getKey(KeyCode::J) == 1)
+	if(in.getKey(KeyCode::kJ) == 1)
 	{
 		m_config.setRVrs(!m_config.getRVrs());
 	}

Tests/Ui/Ui.cpp

@@ -98,7 +98,7 @@ ANKI_TEST(Ui, Ui)
 			timer.start();
 
 			canvas->handleInput();
-			if(in->getKey(KeyCode::ESCAPE))
+			if(in->getKey(KeyCode::kEscape))
 			{
 				done = true;
 			}

Tools/Image/ImageViewerMain.cpp

@@ -308,7 +308,7 @@ public:
 	Error userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime) override
 	{
 		Input& input = getInput();
-		if(input.getKey(KeyCode::ESCAPE))
+		if(input.getKey(KeyCode::kEscape))
 		{
 			quit = true;
 		}