Refactoring. Fixing DBG bugs

include/anki/gl/GlJobChain.h

@@ -59,7 +59,7 @@ class GlJobChainInitHints
 	friend class GlJobChain;
 
 private:
-	static const PtrSize m_maxChunkSize = 1024 * 1024; // 1MB
+	static const PtrSize m_maxChunkSize = 4 * 1024 * 1024; // 1MB
 
 	PtrSize m_chunkSize = 1024;
 };

include/anki/input/Input.h

@@ -40,9 +40,9 @@ public:
 
 	/// @name Acessors
 	/// @{
-	U getKey(U32 i) const
+	U getKey(KeyCode i) const
 	{
-		return m_keys[i];
+		return m_keys[static_cast<U>(i)];
 	}
 
 	U getMouseButton(U32 i) const
@@ -101,7 +101,7 @@ private:
 	/// - 0 times: unpressed
 	/// - 1 times: pressed once
 	/// - >1 times: Kept pressed 'n' times continuously
-	Array<U32, KC_COUNT> m_keys;
+	Array<U32, U(KeyCode::COUNT)> m_keys;
 
 	/// Mouse btns. Supporting 3 btns & wheel. @see keys
 	Array<U32, 8> m_mouseBtns;

include/anki/input/InputSdl.h

@@ -13,9 +13,10 @@
 namespace anki {
 
 /// SDL input implementation
-struct InputImpl
+class InputImpl
 {
-	std::unordered_map<SDL_Keycode, KeyCode> m_sdlKeyToAnki;
+public:
+	std::unordered_map<SDL_Keycode, KeyCode> m_sdlToAnki;
 };
 
 } // end namespace anki

include/anki/input/KeyCode.h

@@ -9,259 +9,259 @@
 namespace anki {
 
 /// Keyboard scancodes taken from SDL 
-enum KeyCode
+enum class KeyCode
 {
-	KC_UNKNOWN = 0,
+	UNKNOWN = 0,
 
-	KC_RETURN = '\r',
-	KC_ESCAPE = '\033',
-	KC_BACKSPACE = '\b',
-	KC_TAB = '\t',
-	KC_SPACE = ' ',
-	KC_EXCLAIM = '!',
-	KC_QUOTEDBL = '"',
-	KC_HASH = '#',
-	KC_PERCENT = '%',
-	KC_DOLLAR = '$',
-	KC_AMPERSAND = '&',
-	KC_QUOTE = '\'',
-	KC_LEFTPAREN = '(',
-	KC_RIGHTPAREN = ')',
-	KC_ASTERISK = '*',
-	KC_PLUS = '+',
-	KC_COMMA = ',',
-	KC_MINUS = '-',
-	KC_PERIOD = '.',
-	KC_SLASH = '/',
-	KC_0 = '0',
-	KC_1 = '1',
-	KC_2 = '2',
-	KC_3 = '3',
-	KC_4 = '4',
-	KC_5 = '5',
-	KC_6 = '6',
-	KC_7 = '7',
-	KC_8 = '8',
-	KC_9 = '9',
-	KC_COLON = ':',
-	KC_SEMICOLON = ';',
-	KC_LESS = '<',
-	KC_EQUALS = '=',
-	KC_GREATER = '>',
-	KC_QUESTION = '?',
-	KC_AT = '@',
+	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,
 
-	KC_LEFTBRACKET = '[',
-	KC_BACKSLASH = '\\',
-	KC_RIGHTBRACKET = ']',
-	KC_CARET = '^',
-	KC_UNDERSCORE = '_',
-	KC_BACKQUOTE = '`',
-	KC_A = 'a',
-	KC_B = 'b',
-	KC_C = 'c',
-	KC_D = 'd',
-	KC_E = 'e',
-	KC_F = 'f',
-	KC_G = 'g',
-	KC_H = 'h',
-	KC_I = 'i',
-	KC_J = 'j',
-	KC_K = 'k',
-	KC_L = 'l',
-	KC_M = 'm',
-	KC_N = 'n',
-	KC_O = 'o',
-	KC_P = 'p',
-	KC_Q = 'q',
-	KC_R = 'r',
-	KC_S = 's',
-	KC_T = 't',
-	KC_U = 'u',
-	KC_V = 'v',
-	KC_W = 'w',
-	KC_X = 'x',
-	KC_Y = 'y',
-	KC_Z = 'z',
+	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,
 
-	KC_CAPSLOCK,
+	CAPSLOCK,
 
-	KC_F1,
-	KC_F2,
-	KC_F3,
-	KC_F4,
-	KC_F5,
-	KC_F6,
-	KC_F7,
-	KC_F8,
-	KC_F9,
-	KC_F10,
-	KC_F11,
-	KC_F12,
+	F1,
+	F2,
+	F3,
+	F4,
+	F5,
+	F6,
+	F7,
+	F8,
+	F9,
+	F10,
+	F11,
+	F12,
 
-	KC_PRINTSCREEN,
-	KC_SCROLLLOCK,
-	KC_PAUSE,
-	KC_INSERT,
-	KC_HOME,
-	KC_PAGEUP,
-	KC_DELETE = '\177',
-	KC_END,
-	KC_PAGEDOWN,
-	KC_RIGHT,
-	KC_LEFT,
-	KC_DOWN,
-	KC_UP,
+	PRINTSCREEN,
+	SCROLLLOCK,
+	PAUSE,
+	INSERT,
+	HOME,
+	PAGEUP,
+	DELETE,
+	END,
+	PAGEDOWN,
+	RIGHT,
+	LEFT,
+	DOWN,
+	UP,
 
-	KC_NUMLOCKCLEAR,
-	KC_KP_DIVIDE,
-	KC_KP_MULTIPLY,
-	KC_KP_MINUS,
-	KC_KP_PLUS,
-	KC_KP_ENTER,
-	KC_KP_1,
-	KC_KP_2,
-	KC_KP_3,
-	KC_KP_4,
-	KC_KP_5,
-	KC_KP_6,
-	KC_KP_7,
-	KC_KP_8,
-	KC_KP_9,
-	KC_KP_0,
-	KC_KP_PERIOD,
+	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,
 
-	KC_APPLICATION,
-	KC_POWER,
-	KC_KP_EQUALS,
-	KC_F13,
-	KC_F14,
-	KC_F15,
-	KC_F16,
-	KC_F17,
-	KC_F18,
-	KC_F19,
-	KC_F20,
-	KC_F21,
-	KC_F22,
-	KC_F23,
-	KC_F24,
-	KC_EXECUTE,
-	KC_HELP,
-	KC_MENU,
-	KC_SELECT,
-	KC_STOP,
-	KC_AGAIN,
-	KC_UNDO,
-	KC_CUT,
-	KC_COPY,
-	KC_PASTE,
-	KC_FIND,
-	KC_MUTE,
-	KC_VOLUMEUP,
-	KC_VOLUMEDOWN,
-	KC_KP_COMMA,
-	KC_KP_EQUALSAS400,
+	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,
 
-	KC_ALTERASE,
-	KC_SYSREQ,
-	KC_CANCEL,
-	KC_CLEAR,
-	KC_PRIOR,
-	KC_RETURN2,
-	KC_SEPARATOR,
-	KC_OUT,
-	KC_OPER,
-	KC_CLEARAGAIN,
-	KC_CRSEL,
-	KC_EXSEL,
+	ALTERASE,
+	SYSREQ,
+	CANCEL,
+	CLEAR,
+	PRIOR,
+	RETURN2,
+	SEPARATOR,
+	OUT,
+	OPER,
+	CLEARAGAIN,
+	CRSEL,
+	EXSEL,
 
-	KC_KP_00,
-	KC_KP_000,
-	KC_THOUSANDSSEPARATOR,
-	KC_DECIMALSEPARATOR,
-	KC_CURRENCYUNIT,
-	KC_CURRENCYSUBUNIT,
-	KC_KP_LEFTPAREN,
-	KC_KP_RIGHTPAREN,
-	KC_KP_LEFTBRACE,
-	KC_KP_RIGHTBRACE,
-	KC_KP_TAB,
-	KC_KP_BACKSPACE,
-	KC_KP_A,
-	KC_KP_B,
-	KC_KP_C,
-	KC_KP_D,
-	KC_KP_E,
-	KC_KP_F,
-	KC_KP_XOR,
-	KC_KP_POWER,
-	KC_KP_PERCENT,
-	KC_KP_LESS,
-	KC_KP_GREATER,
-	KC_KP_AMPERSAND,
-	KC_KP_DBLAMPERSAND,
-	KC_KP_VERTICALBAR,
-	KC_KP_DBLVERTICALBAR,
-	KC_KP_COLON,
-	KC_KP_HASH,
-	KC_KP_SPACE,
-	KC_KP_AT,
-	KC_KP_EXCLAM,
-	KC_KP_MEMSTORE,
-	KC_KP_MEMRECALL,
-	KC_KP_MEMCLEAR,
-	KC_KP_MEMADD,
-	KC_KP_MEMSUBTRACT,
-	KC_KP_MEMMULTIPLY,
-	KC_KP_MEMDIVIDE,
-	KC_KP_PLUSMINUS,
-	KC_KP_CLEAR,
-	KC_KP_CLEARENTRY,
-	KC_KP_BINARY,
-	KC_KP_OCTAL,
-	KC_KP_DECIMAL,
-	KC_KP_HEXADECIMAL,
+	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,
 
-	KC_LCTRL,
-	KC_LSHIFT,
-	KC_LALT,
-	KC_LGUI,
-	KC_RCTRL,
-	KC_RSHIFT,
-	KC_RALT,
-	KC_RGUI,
+	LCTRL,
+	LSHIFT,
+	LALT,
+	LGUI,
+	RCTRL,
+	RSHIFT,
+	RALT,
+	RGUI,
 
-	KC_MODE,
+	MODE,
 
-	KC_AUDIONEXT,
-	KC_AUDIOPREV,
-	KC_AUDIOSTOP,
-	KC_AUDIOPLAY,
-	KC_AUDIOMUTE,
-	KC_MEDIASELECT,
-	KC_WWW,
-	KC_MAIL,
-	KC_CALCULATOR,
-	KC_COMPUTER,
-	KC_AC_SEARCH,
-	KC_AC_HOME,
-	KC_AC_BACK,
-	KC_AC_FORWARD,
-	KC_AC_STOP,
-	KC_AC_REFRESH,
-	KC_AC_BOOKMARKS,
+	AUDIONEXT,
+	AUDIOPREV,
+	AUDIOSTOP,
+	AUDIOPLAY,
+	AUDIOMUTE,
+	MEDIASELECT,
+	WWW,
+	MAIL,
+	CALCULATOR,
+	COMPUTER,
+	AC_SEARCH,
+	AC_HOME,
+	AC_BACK,
+	AC_FORWARD,
+	AC_STOP,
+	AC_REFRESH,
+	AC_BOOKMARKS,
 
-	KC_BRIGHTNESSDOWN,
-	KC_BRIGHTNESSUP,
-	KC_DISPLAYSWITCH,
-	KC_KBDILLUMTOGGLE,
-	KC_KBDILLUMDOWN,
-	KC_KBDILLUMUP,
-	KC_EJECT,
-	KC_SLEEP,	
+	BRIGHTNESSDOWN,
+	BRIGHTNESSUP,
+	DISPLAYSWITCH,
+	KBDILLUMTOGGLE,
+	KBDILLUMDOWN,
+	KBDILLUMUP,
+	EJECT,
+	SLEEP,	
 
-	KC_COUNT
+	COUNT
 };
 
 } // end namespace anki

include/anki/renderer/DebugDrawer.h

@@ -28,7 +28,7 @@ public:
 	~DebugDrawer();
 
 	void drawGrid();
-	void drawSphere(F32 radius, int complexity = 4);
+	void drawSphere(F32 radius, I complexity = 4);
 	void drawCube(F32 size = 1.0);
 	void drawLine(const Vec3& from, const Vec3& to, const Vec4& color);
 
@@ -65,10 +65,11 @@ public:
 	void flush();
 
 private:
-	struct Vertex
+	class Vertex
 	{
-		Vec4 m_positionAndColor;
-		Mat4 m_matrix;
+	public:
+		Vec4 m_position;
+		Vec4 m_color;
 	};
 
 	ProgramResourcePointer m_frag;
@@ -102,11 +103,7 @@ public:
 		: m_dbg(dbg)
 	{}
 
-	void visit(const LineSegment&)
-	{
-		/// XXX
-		ANKI_ASSERT(0 && "ToDo");
-	}
+	void visit(const LineSegment&);
 
 	void visit(const Obb&);
 

shaders/Dbg.vert.glsl

@@ -6,11 +6,10 @@
 #pragma anki type vert
 #pragma anki include "shaders/Common.glsl"
 
-layout(location = 0) in vec3 inPosition;
-layout(location = 1) in vec3 inColor;
-layout(location = 2) in mat4 inMvp;
+layout(location = 0) in vec4 inPosition;
+layout(location = 1) in vec4 inColor;
 
-layout(location = 0) out vec3 outColor;
+layout(location = 0) out vec4 outColor;
 
 out gl_PerVertex
 {
@@ -20,5 +19,5 @@ out gl_PerVertex
 void main()
 {
 	outColor = inColor;
-	gl_Position = inMvp * vec4(inPosition, 1.0);
+	gl_Position = inPosition;
 }

shaders/VariableSamplingBlurGeneric.frag.glsl

@@ -102,6 +102,14 @@ const vec2 kernel[SAMPLES - 1] = vec2[](
 #if SAMPLES > 13
 	,BLURRING_OFFSET(7, -1),
 	BLURRING_OFFSET(7, 1)
+#endif
+#if SAMPLES > 15
+	,BLURRING_OFFSET(8, -1),
+	BLURRING_OFFSET(8, 1)
+#endif
+#if SAMPLES > 17
+	,BLURRING_OFFSET(9, -1),
+	BLURRING_OFFSET(9, 1)
 #endif
 	);
 

src/input/InputSdl.cpp

@@ -25,241 +25,241 @@ void Input::init(NativeWindow* nativeWindow)
 	m_impl.reset(new InputImpl);
 
 	//impl
-	m_impl->m_sdlKeyToAnki[SDLK_RETURN] = KC_RETURN;
-	m_impl->m_sdlKeyToAnki[SDLK_ESCAPE] = KC_ESCAPE;
-	m_impl->m_sdlKeyToAnki[SDLK_BACKSPACE] = KC_BACKSPACE;
-	m_impl->m_sdlKeyToAnki[SDLK_TAB] = KC_TAB;
-	m_impl->m_sdlKeyToAnki[SDLK_SPACE] = KC_SPACE;
-	m_impl->m_sdlKeyToAnki[SDLK_EXCLAIM] = KC_EXCLAIM;
-	m_impl->m_sdlKeyToAnki[SDLK_QUOTEDBL] = KC_QUOTEDBL;
-	m_impl->m_sdlKeyToAnki[SDLK_HASH] = KC_HASH;
-	m_impl->m_sdlKeyToAnki[SDLK_PERCENT] = KC_PERCENT;
-	m_impl->m_sdlKeyToAnki[SDLK_DOLLAR] = KC_DOLLAR;
-	m_impl->m_sdlKeyToAnki[SDLK_AMPERSAND] = KC_AMPERSAND;
-	m_impl->m_sdlKeyToAnki[SDLK_QUOTE] = KC_QUOTE;
-	m_impl->m_sdlKeyToAnki[SDLK_LEFTPAREN] = KC_LEFTPAREN;
-	m_impl->m_sdlKeyToAnki[SDLK_RIGHTPAREN] = KC_RIGHTPAREN;
-	m_impl->m_sdlKeyToAnki[SDLK_ASTERISK] = KC_ASTERISK;
-	m_impl->m_sdlKeyToAnki[SDLK_PLUS] = KC_PLUS;
-	m_impl->m_sdlKeyToAnki[SDLK_COMMA] = KC_COMMA;
-	m_impl->m_sdlKeyToAnki[SDLK_MINUS] = KC_MINUS;
-	m_impl->m_sdlKeyToAnki[SDLK_PERIOD] = KC_PERIOD;
-	m_impl->m_sdlKeyToAnki[SDLK_SLASH] = KC_SLASH;
-	m_impl->m_sdlKeyToAnki[SDLK_0] = KC_0;
-	m_impl->m_sdlKeyToAnki[SDLK_1] = KC_1;
-	m_impl->m_sdlKeyToAnki[SDLK_2] = KC_2;
-	m_impl->m_sdlKeyToAnki[SDLK_3] = KC_3;
-	m_impl->m_sdlKeyToAnki[SDLK_4] = KC_4;
-	m_impl->m_sdlKeyToAnki[SDLK_5] = KC_5;
-	m_impl->m_sdlKeyToAnki[SDLK_6] = KC_6;
-	m_impl->m_sdlKeyToAnki[SDLK_7] = KC_7;
-	m_impl->m_sdlKeyToAnki[SDLK_8] = KC_8;
-	m_impl->m_sdlKeyToAnki[SDLK_9] = KC_9;
-	m_impl->m_sdlKeyToAnki[SDLK_COLON] = KC_COLON;
-	m_impl->m_sdlKeyToAnki[SDLK_SEMICOLON] = KC_SEMICOLON;
-	m_impl->m_sdlKeyToAnki[SDLK_LESS] = KC_LESS;
-	m_impl->m_sdlKeyToAnki[SDLK_EQUALS] = KC_EQUALS;
-	m_impl->m_sdlKeyToAnki[SDLK_GREATER] = KC_GREATER;
-	m_impl->m_sdlKeyToAnki[SDLK_QUESTION] = KC_QUESTION;
-	m_impl->m_sdlKeyToAnki[SDLK_AT] = KC_AT;
-	m_impl->m_sdlKeyToAnki[SDLK_LEFTBRACKET] = KC_LEFTBRACKET;
-	m_impl->m_sdlKeyToAnki[SDLK_BACKSLASH] = KC_BACKSLASH;
-	m_impl->m_sdlKeyToAnki[SDLK_RIGHTBRACKET] = KC_RIGHTBRACKET;
-	m_impl->m_sdlKeyToAnki[SDLK_CARET] = KC_CARET;
-	m_impl->m_sdlKeyToAnki[SDLK_UNDERSCORE] = KC_UNDERSCORE;
-	m_impl->m_sdlKeyToAnki[SDLK_BACKQUOTE] = KC_BACKQUOTE;
-	m_impl->m_sdlKeyToAnki[SDLK_a] = KC_A;
-	m_impl->m_sdlKeyToAnki[SDLK_b] = KC_B;
-	m_impl->m_sdlKeyToAnki[SDLK_c] = KC_C;
-	m_impl->m_sdlKeyToAnki[SDLK_d] = KC_D;
-	m_impl->m_sdlKeyToAnki[SDLK_e] = KC_E;
-	m_impl->m_sdlKeyToAnki[SDLK_f] = KC_F;
-	m_impl->m_sdlKeyToAnki[SDLK_g] = KC_G;
-	m_impl->m_sdlKeyToAnki[SDLK_h] = KC_H;
-	m_impl->m_sdlKeyToAnki[SDLK_i] = KC_I;
-	m_impl->m_sdlKeyToAnki[SDLK_j] = KC_J;
-	m_impl->m_sdlKeyToAnki[SDLK_k] = KC_K;
-	m_impl->m_sdlKeyToAnki[SDLK_l] = KC_L;
-	m_impl->m_sdlKeyToAnki[SDLK_m] = KC_M;
-	m_impl->m_sdlKeyToAnki[SDLK_n] = KC_N;
-	m_impl->m_sdlKeyToAnki[SDLK_o] = KC_O;
-	m_impl->m_sdlKeyToAnki[SDLK_p] = KC_P;
-	m_impl->m_sdlKeyToAnki[SDLK_q] = KC_Q;
-	m_impl->m_sdlKeyToAnki[SDLK_r] = KC_R;
-	m_impl->m_sdlKeyToAnki[SDLK_s] = KC_S;
-	m_impl->m_sdlKeyToAnki[SDLK_y] = KC_T;
-	m_impl->m_sdlKeyToAnki[SDLK_u] = KC_U;
-	m_impl->m_sdlKeyToAnki[SDLK_v] = KC_V;
-	m_impl->m_sdlKeyToAnki[SDLK_w] = KC_W;
-	m_impl->m_sdlKeyToAnki[SDLK_x] = KC_X;
-	m_impl->m_sdlKeyToAnki[SDLK_y] = KC_Y;
-	m_impl->m_sdlKeyToAnki[SDLK_z] = KC_Z;
-	m_impl->m_sdlKeyToAnki[SDLK_CAPSLOCK] = KC_CAPSLOCK;
-	m_impl->m_sdlKeyToAnki[SDLK_F1] = KC_F1;
-	m_impl->m_sdlKeyToAnki[SDLK_F2] = KC_F2;
-	m_impl->m_sdlKeyToAnki[SDLK_F3] = KC_F3;
-	m_impl->m_sdlKeyToAnki[SDLK_F4] = KC_F4;
-	m_impl->m_sdlKeyToAnki[SDLK_F5] = KC_F5;
-	m_impl->m_sdlKeyToAnki[SDLK_F6] = KC_F6;
-	m_impl->m_sdlKeyToAnki[SDLK_F7] = KC_F7;
-	m_impl->m_sdlKeyToAnki[SDLK_F8] = KC_F8;
-	m_impl->m_sdlKeyToAnki[SDLK_F9] = KC_F9;
-	m_impl->m_sdlKeyToAnki[SDLK_F10] = KC_F10;
-	m_impl->m_sdlKeyToAnki[SDLK_F11] = KC_F11;
-	m_impl->m_sdlKeyToAnki[SDLK_F12] = KC_F12;
-	m_impl->m_sdlKeyToAnki[SDLK_PRINTSCREEN] = KC_PRINTSCREEN;
-	m_impl->m_sdlKeyToAnki[SDLK_SCROLLLOCK] = KC_SCROLLLOCK;
-	m_impl->m_sdlKeyToAnki[SDLK_PAUSE] = KC_PAUSE;
-	m_impl->m_sdlKeyToAnki[SDLK_INSERT] = KC_INSERT;
-	m_impl->m_sdlKeyToAnki[SDLK_HOME] = KC_HOME;
-	m_impl->m_sdlKeyToAnki[SDLK_PAGEUP] = KC_PAGEUP;
-	m_impl->m_sdlKeyToAnki[SDLK_DELETE] = KC_DELETE;
-	m_impl->m_sdlKeyToAnki[SDLK_END] = KC_END;
-	m_impl->m_sdlKeyToAnki[SDLK_PAGEDOWN] = KC_PAGEDOWN;
-	m_impl->m_sdlKeyToAnki[SDLK_RIGHT] = KC_RIGHT;
-	m_impl->m_sdlKeyToAnki[SDLK_LEFT] = KC_LEFT;
-	m_impl->m_sdlKeyToAnki[SDLK_DOWN] = KC_DOWN;
-	m_impl->m_sdlKeyToAnki[SDLK_UP] = KC_UP;
-	m_impl->m_sdlKeyToAnki[SDLK_NUMLOCKCLEAR] = KC_NUMLOCKCLEAR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_DIVIDE] = KC_KP_DIVIDE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MULTIPLY] = KC_KP_MULTIPLY;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MINUS] = KC_KP_MINUS;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_PLUS] = KC_KP_PLUS;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_ENTER] = KC_KP_ENTER;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_1] = KC_KP_1;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_2] = KC_KP_2;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_3] = KC_KP_3;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_4] = KC_KP_4;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_5] = KC_KP_5;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_6] = KC_KP_6;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_7] = KC_KP_7;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_8] = KC_KP_8;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_9] = KC_KP_9;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_0] = KC_KP_0;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_PERIOD] = KC_KP_PERIOD;
-	m_impl->m_sdlKeyToAnki[SDLK_APPLICATION] = KC_APPLICATION;
-	m_impl->m_sdlKeyToAnki[SDLK_POWER] = KC_POWER;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_EQUALS] = KC_KP_EQUALS;
-	m_impl->m_sdlKeyToAnki[SDLK_F13] = KC_F13;
-	m_impl->m_sdlKeyToAnki[SDLK_F14] = KC_F14;
-	m_impl->m_sdlKeyToAnki[SDLK_F15] = KC_F15;
-	m_impl->m_sdlKeyToAnki[SDLK_F16] = KC_F16;
-	m_impl->m_sdlKeyToAnki[SDLK_F17] = KC_F17;
-	m_impl->m_sdlKeyToAnki[SDLK_F18] = KC_F18;
-	m_impl->m_sdlKeyToAnki[SDLK_F19] = KC_F19;
-	m_impl->m_sdlKeyToAnki[SDLK_F20] = KC_F20;
-	m_impl->m_sdlKeyToAnki[SDLK_F21] = KC_F21;
-	m_impl->m_sdlKeyToAnki[SDLK_F22] = KC_F22;
-	m_impl->m_sdlKeyToAnki[SDLK_F23] = KC_F23;
-	m_impl->m_sdlKeyToAnki[SDLK_F24] = KC_F24;
-	m_impl->m_sdlKeyToAnki[SDLK_EXECUTE] = KC_EXECUTE;
-	m_impl->m_sdlKeyToAnki[SDLK_HELP] = KC_HELP;
-	m_impl->m_sdlKeyToAnki[SDLK_MENU] = KC_MENU;
-	m_impl->m_sdlKeyToAnki[SDLK_SELECT] = KC_SELECT;
-	m_impl->m_sdlKeyToAnki[SDLK_STOP] = KC_STOP;
-	m_impl->m_sdlKeyToAnki[SDLK_AGAIN] = KC_AGAIN;
-	m_impl->m_sdlKeyToAnki[SDLK_UNDO] = KC_UNDO;
-	m_impl->m_sdlKeyToAnki[SDLK_CUT] = KC_CUT;
-	m_impl->m_sdlKeyToAnki[SDLK_COPY] = KC_COPY;
-	m_impl->m_sdlKeyToAnki[SDLK_PASTE] = KC_PASTE;
-	m_impl->m_sdlKeyToAnki[SDLK_FIND] = KC_FIND;
-	m_impl->m_sdlKeyToAnki[SDLK_MUTE] = KC_MUTE;
-	m_impl->m_sdlKeyToAnki[SDLK_VOLUMEUP] = KC_VOLUMEUP;
-	m_impl->m_sdlKeyToAnki[SDLK_VOLUMEDOWN] = KC_VOLUMEDOWN;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_COMMA] = KC_KP_COMMA;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_EQUALSAS400] = KC_KP_EQUALSAS400;
-	m_impl->m_sdlKeyToAnki[SDLK_ALTERASE] = KC_ALTERASE;
-	m_impl->m_sdlKeyToAnki[SDLK_SYSREQ] = KC_SYSREQ;
-	m_impl->m_sdlKeyToAnki[SDLK_CANCEL] = KC_CANCEL;
-	m_impl->m_sdlKeyToAnki[SDLK_CLEAR] = KC_CLEAR;
-	m_impl->m_sdlKeyToAnki[SDLK_PRIOR] = KC_PRIOR;
-	m_impl->m_sdlKeyToAnki[SDLK_RETURN2] = KC_RETURN2;
-	m_impl->m_sdlKeyToAnki[SDLK_SEPARATOR] = KC_SEPARATOR;
-	m_impl->m_sdlKeyToAnki[SDLK_OUT] = KC_OUT;
-	m_impl->m_sdlKeyToAnki[SDLK_OPER] = KC_OPER;
-	m_impl->m_sdlKeyToAnki[SDLK_CLEARAGAIN] = KC_CLEARAGAIN;
-	m_impl->m_sdlKeyToAnki[SDLK_CRSEL] = KC_CRSEL;
-	m_impl->m_sdlKeyToAnki[SDLK_EXSEL] = KC_EXSEL;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_00] = KC_KP_00;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_000] = KC_KP_000;
-	m_impl->m_sdlKeyToAnki[SDLK_THOUSANDSSEPARATOR] = KC_THOUSANDSSEPARATOR;
-	m_impl->m_sdlKeyToAnki[SDLK_DECIMALSEPARATOR] = KC_DECIMALSEPARATOR;
-	m_impl->m_sdlKeyToAnki[SDLK_CURRENCYUNIT] = KC_CURRENCYUNIT;
-	m_impl->m_sdlKeyToAnki[SDLK_CURRENCYSUBUNIT] = KC_CURRENCYSUBUNIT;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_LEFTPAREN] = KC_KP_LEFTPAREN;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_RIGHTPAREN] = KC_KP_RIGHTPAREN;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_LEFTBRACE] = KC_KP_LEFTBRACE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_RIGHTBRACE] = KC_KP_RIGHTBRACE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_TAB] = KC_KP_TAB;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_BACKSPACE] = KC_KP_BACKSPACE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_A] = KC_KP_A;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_B] = KC_KP_B;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_C] = KC_KP_C;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_D] = KC_KP_D;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_E] = KC_KP_E;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_F] = KC_KP_F;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_XOR] = KC_KP_XOR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_POWER] = KC_KP_POWER;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_PERCENT] = KC_KP_PERCENT;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_LESS] = KC_KP_LESS;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_GREATER] = KC_KP_GREATER;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_AMPERSAND] = KC_KP_AMPERSAND;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_DBLAMPERSAND] = KC_KP_DBLAMPERSAND;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_VERTICALBAR] = KC_KP_VERTICALBAR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_DBLVERTICALBAR] = KC_KP_DBLVERTICALBAR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_COLON] = KC_KP_COLON;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_HASH] = KC_KP_HASH;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_SPACE] = KC_KP_SPACE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_AT] = KC_KP_AT;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_EXCLAM] = KC_KP_EXCLAM;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMSTORE] = KC_KP_MEMSTORE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMRECALL] = KC_KP_MEMRECALL;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMCLEAR] = KC_KP_MEMCLEAR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMADD] = KC_KP_MEMADD;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMSUBTRACT] = KC_KP_MEMSUBTRACT;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMMULTIPLY] = KC_KP_MEMMULTIPLY;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_MEMDIVIDE] = KC_KP_MEMDIVIDE;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_PLUSMINUS] = KC_KP_PLUSMINUS;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_CLEAR] = KC_KP_CLEAR;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_CLEARENTRY] = KC_KP_CLEARENTRY;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_BINARY] = KC_KP_BINARY;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_OCTAL] = KC_KP_OCTAL;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_DECIMAL] = KC_KP_DECIMAL;
-	m_impl->m_sdlKeyToAnki[SDLK_KP_HEXADECIMAL] = KC_KP_HEXADECIMAL;
-	m_impl->m_sdlKeyToAnki[SDLK_LCTRL] = KC_LCTRL;
-	m_impl->m_sdlKeyToAnki[SDLK_LSHIFT] = KC_LSHIFT;
-	m_impl->m_sdlKeyToAnki[SDLK_LALT] = KC_LALT;
-	m_impl->m_sdlKeyToAnki[SDLK_LGUI] = KC_LGUI;
-	m_impl->m_sdlKeyToAnki[SDLK_RCTRL] = KC_RCTRL;
-	m_impl->m_sdlKeyToAnki[SDLK_RSHIFT] = KC_RSHIFT;
-	m_impl->m_sdlKeyToAnki[SDLK_RALT] = KC_RALT;
-	m_impl->m_sdlKeyToAnki[SDLK_RGUI] = KC_RGUI;
-	m_impl->m_sdlKeyToAnki[SDLK_MODE] = KC_MODE;
-	m_impl->m_sdlKeyToAnki[SDLK_AUDIONEXT] = KC_AUDIONEXT;
-	m_impl->m_sdlKeyToAnki[SDLK_AUDIOPREV] = KC_AUDIOPREV;
-	m_impl->m_sdlKeyToAnki[SDLK_AUDIOSTOP] = KC_AUDIOSTOP;
-	m_impl->m_sdlKeyToAnki[SDLK_AUDIOPLAY] = KC_AUDIOPLAY;
-	m_impl->m_sdlKeyToAnki[SDLK_AUDIOMUTE] = KC_AUDIOMUTE;
-	m_impl->m_sdlKeyToAnki[SDLK_MEDIASELECT] = KC_MEDIASELECT;
-	m_impl->m_sdlKeyToAnki[SDLK_WWW] = KC_WWW;
-	m_impl->m_sdlKeyToAnki[SDLK_MAIL] = KC_MAIL;
-	m_impl->m_sdlKeyToAnki[SDLK_CALCULATOR] = KC_CALCULATOR;
-	m_impl->m_sdlKeyToAnki[SDLK_COMPUTER] = KC_COMPUTER;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_SEARCH] = KC_AC_SEARCH;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_HOME] = KC_AC_HOME;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_BACK] = KC_AC_BACK;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_FORWARD] = KC_AC_FORWARD;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_STOP] = KC_AC_STOP;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_REFRESH] = KC_AC_REFRESH;
-	m_impl->m_sdlKeyToAnki[SDLK_AC_BOOKMARKS] = KC_AC_BOOKMARKS;
-	m_impl->m_sdlKeyToAnki[SDLK_BRIGHTNESSDOWN] = KC_BRIGHTNESSDOWN;
-	m_impl->m_sdlKeyToAnki[SDLK_BRIGHTNESSUP] = KC_BRIGHTNESSUP;
-	m_impl->m_sdlKeyToAnki[SDLK_DISPLAYSWITCH] = KC_DISPLAYSWITCH;
-	m_impl->m_sdlKeyToAnki[SDLK_KBDILLUMTOGGLE] = KC_KBDILLUMTOGGLE;
-	m_impl->m_sdlKeyToAnki[SDLK_KBDILLUMDOWN] = KC_KBDILLUMDOWN;
-	m_impl->m_sdlKeyToAnki[SDLK_KBDILLUMUP] = KC_KBDILLUMUP;
-	m_impl->m_sdlKeyToAnki[SDLK_EJECT] = KC_EJECT;
-	m_impl->m_sdlKeyToAnki[SDLK_SLEEP] = KC_SLEEP;
+	m_impl->m_sdlToAnki[SDLK_RETURN] = KeyCode::RETURN;
+	m_impl->m_sdlToAnki[SDLK_ESCAPE] = KeyCode::ESCAPE;
+	m_impl->m_sdlToAnki[SDLK_BACKSPACE] = KeyCode::BACKSPACE;
+	m_impl->m_sdlToAnki[SDLK_TAB] = KeyCode::TAB;
+	m_impl->m_sdlToAnki[SDLK_SPACE] = KeyCode::SPACE;
+	m_impl->m_sdlToAnki[SDLK_EXCLAIM] = KeyCode::EXCLAIM;
+	m_impl->m_sdlToAnki[SDLK_QUOTEDBL] = KeyCode::QUOTEDBL;
+	m_impl->m_sdlToAnki[SDLK_HASH] = KeyCode::HASH;
+	m_impl->m_sdlToAnki[SDLK_PERCENT] = KeyCode::PERCENT;
+	m_impl->m_sdlToAnki[SDLK_DOLLAR] = KeyCode::DOLLAR;
+	m_impl->m_sdlToAnki[SDLK_AMPERSAND] = KeyCode::AMPERSAND;
+	m_impl->m_sdlToAnki[SDLK_QUOTE] = KeyCode::QUOTE;
+	m_impl->m_sdlToAnki[SDLK_LEFTPAREN] = KeyCode::LEFTPAREN;
+	m_impl->m_sdlToAnki[SDLK_RIGHTPAREN] = KeyCode::RIGHTPAREN;
+	m_impl->m_sdlToAnki[SDLK_ASTERISK] = KeyCode::ASTERISK;
+	m_impl->m_sdlToAnki[SDLK_PLUS] = KeyCode::PLUS;
+	m_impl->m_sdlToAnki[SDLK_COMMA] = KeyCode::COMMA;
+	m_impl->m_sdlToAnki[SDLK_MINUS] = KeyCode::MINUS;
+	m_impl->m_sdlToAnki[SDLK_PERIOD] = KeyCode::PERIOD;
+	m_impl->m_sdlToAnki[SDLK_SLASH] = KeyCode::SLASH;
+	m_impl->m_sdlToAnki[SDLK_0] = KeyCode::_0;
+	m_impl->m_sdlToAnki[SDLK_1] = KeyCode::_1;
+	m_impl->m_sdlToAnki[SDLK_2] = KeyCode::_2;
+	m_impl->m_sdlToAnki[SDLK_3] = KeyCode::_3;
+	m_impl->m_sdlToAnki[SDLK_4] = KeyCode::_4;
+	m_impl->m_sdlToAnki[SDLK_5] = KeyCode::_5;
+	m_impl->m_sdlToAnki[SDLK_6] = KeyCode::_6;
+	m_impl->m_sdlToAnki[SDLK_7] = KeyCode::_7;
+	m_impl->m_sdlToAnki[SDLK_8] = KeyCode::_8;
+	m_impl->m_sdlToAnki[SDLK_9] = KeyCode::_9;
+	m_impl->m_sdlToAnki[SDLK_COLON] = KeyCode::COLON;
+	m_impl->m_sdlToAnki[SDLK_SEMICOLON] = KeyCode::SEMICOLON;
+	m_impl->m_sdlToAnki[SDLK_LESS] = KeyCode::LESS;
+	m_impl->m_sdlToAnki[SDLK_EQUALS] = KeyCode::EQUALS;
+	m_impl->m_sdlToAnki[SDLK_GREATER] = KeyCode::GREATER;
+	m_impl->m_sdlToAnki[SDLK_QUESTION] = KeyCode::QUESTION;
+	m_impl->m_sdlToAnki[SDLK_AT] = KeyCode::AT;
+	m_impl->m_sdlToAnki[SDLK_LEFTBRACKET] = KeyCode::LEFTBRACKET;
+	m_impl->m_sdlToAnki[SDLK_BACKSLASH] = KeyCode::BACKSLASH;
+	m_impl->m_sdlToAnki[SDLK_RIGHTBRACKET] = KeyCode::RIGHTBRACKET;
+	m_impl->m_sdlToAnki[SDLK_CARET] = KeyCode::CARET;
+	m_impl->m_sdlToAnki[SDLK_UNDERSCORE] = KeyCode::UNDERSCORE;
+	m_impl->m_sdlToAnki[SDLK_BACKQUOTE] = KeyCode::BACKQUOTE;
+	m_impl->m_sdlToAnki[SDLK_a] = KeyCode::A;
+	m_impl->m_sdlToAnki[SDLK_b] = KeyCode::B;
+	m_impl->m_sdlToAnki[SDLK_c] = KeyCode::C;
+	m_impl->m_sdlToAnki[SDLK_d] = KeyCode::D;
+	m_impl->m_sdlToAnki[SDLK_e] = KeyCode::E;
+	m_impl->m_sdlToAnki[SDLK_f] = KeyCode::F;
+	m_impl->m_sdlToAnki[SDLK_g] = KeyCode::G;
+	m_impl->m_sdlToAnki[SDLK_h] = KeyCode::H;
+	m_impl->m_sdlToAnki[SDLK_i] = KeyCode::I;
+	m_impl->m_sdlToAnki[SDLK_j] = KeyCode::J;
+	m_impl->m_sdlToAnki[SDLK_k] = KeyCode::K;
+	m_impl->m_sdlToAnki[SDLK_l] = KeyCode::L;
+	m_impl->m_sdlToAnki[SDLK_m] = KeyCode::M;
+	m_impl->m_sdlToAnki[SDLK_n] = KeyCode::N;
+	m_impl->m_sdlToAnki[SDLK_o] = KeyCode::O;
+	m_impl->m_sdlToAnki[SDLK_p] = KeyCode::P;
+	m_impl->m_sdlToAnki[SDLK_q] = KeyCode::Q;
+	m_impl->m_sdlToAnki[SDLK_r] = KeyCode::R;
+	m_impl->m_sdlToAnki[SDLK_s] = KeyCode::S;
+	m_impl->m_sdlToAnki[SDLK_y] = KeyCode::T;
+	m_impl->m_sdlToAnki[SDLK_u] = KeyCode::U;
+	m_impl->m_sdlToAnki[SDLK_v] = KeyCode::V;
+	m_impl->m_sdlToAnki[SDLK_w] = KeyCode::W;
+	m_impl->m_sdlToAnki[SDLK_x] = KeyCode::X;
+	m_impl->m_sdlToAnki[SDLK_y] = KeyCode::Y;
+	m_impl->m_sdlToAnki[SDLK_z] = KeyCode::Z;
+	m_impl->m_sdlToAnki[SDLK_CAPSLOCK] = KeyCode::CAPSLOCK;
+	m_impl->m_sdlToAnki[SDLK_F1] = KeyCode::F1;
+	m_impl->m_sdlToAnki[SDLK_F2] = KeyCode::F2;
+	m_impl->m_sdlToAnki[SDLK_F3] = KeyCode::F3;
+	m_impl->m_sdlToAnki[SDLK_F4] = KeyCode::F4;
+	m_impl->m_sdlToAnki[SDLK_F5] = KeyCode::F5;
+	m_impl->m_sdlToAnki[SDLK_F6] = KeyCode::F6;
+	m_impl->m_sdlToAnki[SDLK_F7] = KeyCode::F7;
+	m_impl->m_sdlToAnki[SDLK_F8] = KeyCode::F8;
+	m_impl->m_sdlToAnki[SDLK_F9] = KeyCode::F9;
+	m_impl->m_sdlToAnki[SDLK_F10] = KeyCode::F10;
+	m_impl->m_sdlToAnki[SDLK_F11] = KeyCode::F11;
+	m_impl->m_sdlToAnki[SDLK_F12] = KeyCode::F12;
+	m_impl->m_sdlToAnki[SDLK_PRINTSCREEN] = KeyCode::PRINTSCREEN;
+	m_impl->m_sdlToAnki[SDLK_SCROLLLOCK] = KeyCode::SCROLLLOCK;
+	m_impl->m_sdlToAnki[SDLK_PAUSE] = KeyCode::PAUSE;
+	m_impl->m_sdlToAnki[SDLK_INSERT] = KeyCode::INSERT;
+	m_impl->m_sdlToAnki[SDLK_HOME] = KeyCode::HOME;
+	m_impl->m_sdlToAnki[SDLK_PAGEUP] = KeyCode::PAGEUP;
+	m_impl->m_sdlToAnki[SDLK_DELETE] = KeyCode::DELETE;
+	m_impl->m_sdlToAnki[SDLK_END] = KeyCode::END;
+	m_impl->m_sdlToAnki[SDLK_PAGEDOWN] = KeyCode::PAGEDOWN;
+	m_impl->m_sdlToAnki[SDLK_RIGHT] = KeyCode::RIGHT;
+	m_impl->m_sdlToAnki[SDLK_LEFT] = KeyCode::LEFT;
+	m_impl->m_sdlToAnki[SDLK_DOWN] = KeyCode::DOWN;
+	m_impl->m_sdlToAnki[SDLK_UP] = KeyCode::UP;
+	m_impl->m_sdlToAnki[SDLK_NUMLOCKCLEAR] = KeyCode::NUMLOCKCLEAR;
+	m_impl->m_sdlToAnki[SDLK_KP_DIVIDE] = KeyCode::KP_DIVIDE;
+	m_impl->m_sdlToAnki[SDLK_KP_MULTIPLY] = KeyCode::KP_MULTIPLY;
+	m_impl->m_sdlToAnki[SDLK_KP_MINUS] = KeyCode::KP_MINUS;
+	m_impl->m_sdlToAnki[SDLK_KP_PLUS] = KeyCode::KP_PLUS;
+	m_impl->m_sdlToAnki[SDLK_KP_ENTER] = KeyCode::KP_ENTER;
+	m_impl->m_sdlToAnki[SDLK_KP_1] = KeyCode::KP_1;
+	m_impl->m_sdlToAnki[SDLK_KP_2] = KeyCode::KP_2;
+	m_impl->m_sdlToAnki[SDLK_KP_3] = KeyCode::KP_3;
+	m_impl->m_sdlToAnki[SDLK_KP_4] = KeyCode::KP_4;
+	m_impl->m_sdlToAnki[SDLK_KP_5] = KeyCode::KP_5;
+	m_impl->m_sdlToAnki[SDLK_KP_6] = KeyCode::KP_6;
+	m_impl->m_sdlToAnki[SDLK_KP_7] = KeyCode::KP_7;
+	m_impl->m_sdlToAnki[SDLK_KP_8] = KeyCode::KP_8;
+	m_impl->m_sdlToAnki[SDLK_KP_9] = KeyCode::KP_9;
+	m_impl->m_sdlToAnki[SDLK_KP_0] = KeyCode::KP_0;
+	m_impl->m_sdlToAnki[SDLK_KP_PERIOD] = KeyCode::KP_PERIOD;
+	m_impl->m_sdlToAnki[SDLK_APPLICATION] = KeyCode::APPLICATION;
+	m_impl->m_sdlToAnki[SDLK_POWER] = KeyCode::POWER;
+	m_impl->m_sdlToAnki[SDLK_KP_EQUALS] = KeyCode::KP_EQUALS;
+	m_impl->m_sdlToAnki[SDLK_F13] = KeyCode::F13;
+	m_impl->m_sdlToAnki[SDLK_F14] = KeyCode::F14;
+	m_impl->m_sdlToAnki[SDLK_F15] = KeyCode::F15;
+	m_impl->m_sdlToAnki[SDLK_F16] = KeyCode::F16;
+	m_impl->m_sdlToAnki[SDLK_F17] = KeyCode::F17;
+	m_impl->m_sdlToAnki[SDLK_F18] = KeyCode::F18;
+	m_impl->m_sdlToAnki[SDLK_F19] = KeyCode::F19;
+	m_impl->m_sdlToAnki[SDLK_F20] = KeyCode::F20;
+	m_impl->m_sdlToAnki[SDLK_F21] = KeyCode::F21;
+	m_impl->m_sdlToAnki[SDLK_F22] = KeyCode::F22;
+	m_impl->m_sdlToAnki[SDLK_F23] = KeyCode::F23;
+	m_impl->m_sdlToAnki[SDLK_F24] = KeyCode::F24;
+	m_impl->m_sdlToAnki[SDLK_EXECUTE] = KeyCode::EXECUTE;
+	m_impl->m_sdlToAnki[SDLK_HELP] = KeyCode::HELP;
+	m_impl->m_sdlToAnki[SDLK_MENU] = KeyCode::MENU;
+	m_impl->m_sdlToAnki[SDLK_SELECT] = KeyCode::SELECT;
+	m_impl->m_sdlToAnki[SDLK_STOP] = KeyCode::STOP;
+	m_impl->m_sdlToAnki[SDLK_AGAIN] = KeyCode::AGAIN;
+	m_impl->m_sdlToAnki[SDLK_UNDO] = KeyCode::UNDO;
+	m_impl->m_sdlToAnki[SDLK_CUT] = KeyCode::CUT;
+	m_impl->m_sdlToAnki[SDLK_COPY] = KeyCode::COPY;
+	m_impl->m_sdlToAnki[SDLK_PASTE] = KeyCode::PASTE;
+	m_impl->m_sdlToAnki[SDLK_FIND] = KeyCode::FIND;
+	m_impl->m_sdlToAnki[SDLK_MUTE] = KeyCode::MUTE;
+	m_impl->m_sdlToAnki[SDLK_VOLUMEUP] = KeyCode::VOLUMEUP;
+	m_impl->m_sdlToAnki[SDLK_VOLUMEDOWN] = KeyCode::VOLUMEDOWN;
+	m_impl->m_sdlToAnki[SDLK_KP_COMMA] = KeyCode::KP_COMMA;
+	m_impl->m_sdlToAnki[SDLK_KP_EQUALSAS400] = KeyCode::KP_EQUALSAS400;
+	m_impl->m_sdlToAnki[SDLK_ALTERASE] = KeyCode::ALTERASE;
+	m_impl->m_sdlToAnki[SDLK_SYSREQ] = KeyCode::SYSREQ;
+	m_impl->m_sdlToAnki[SDLK_CANCEL] = KeyCode::CANCEL;
+	m_impl->m_sdlToAnki[SDLK_CLEAR] = KeyCode::CLEAR;
+	m_impl->m_sdlToAnki[SDLK_PRIOR] = KeyCode::PRIOR;
+	m_impl->m_sdlToAnki[SDLK_RETURN2] = KeyCode::RETURN2;
+	m_impl->m_sdlToAnki[SDLK_SEPARATOR] = KeyCode::SEPARATOR;
+	m_impl->m_sdlToAnki[SDLK_OUT] = KeyCode::OUT;
+	m_impl->m_sdlToAnki[SDLK_OPER] = KeyCode::OPER;
+	m_impl->m_sdlToAnki[SDLK_CLEARAGAIN] = KeyCode::CLEARAGAIN;
+	m_impl->m_sdlToAnki[SDLK_CRSEL] = KeyCode::CRSEL;
+	m_impl->m_sdlToAnki[SDLK_EXSEL] = KeyCode::EXSEL;
+	m_impl->m_sdlToAnki[SDLK_KP_00] = KeyCode::KP_00;
+	m_impl->m_sdlToAnki[SDLK_KP_000] = KeyCode::KP_000;
+	m_impl->m_sdlToAnki[SDLK_THOUSANDSSEPARATOR] = KeyCode::THOUSANDSSEPARATOR;
+	m_impl->m_sdlToAnki[SDLK_DECIMALSEPARATOR] = KeyCode::DECIMALSEPARATOR;
+	m_impl->m_sdlToAnki[SDLK_CURRENCYUNIT] = KeyCode::CURRENCYUNIT;
+	m_impl->m_sdlToAnki[SDLK_CURRENCYSUBUNIT] = KeyCode::CURRENCYSUBUNIT;
+	m_impl->m_sdlToAnki[SDLK_KP_LEFTPAREN] = KeyCode::KP_LEFTPAREN;
+	m_impl->m_sdlToAnki[SDLK_KP_RIGHTPAREN] = KeyCode::KP_RIGHTPAREN;
+	m_impl->m_sdlToAnki[SDLK_KP_LEFTBRACE] = KeyCode::KP_LEFTBRACE;
+	m_impl->m_sdlToAnki[SDLK_KP_RIGHTBRACE] = KeyCode::KP_RIGHTBRACE;
+	m_impl->m_sdlToAnki[SDLK_KP_TAB] = KeyCode::KP_TAB;
+	m_impl->m_sdlToAnki[SDLK_KP_BACKSPACE] = KeyCode::KP_BACKSPACE;
+	m_impl->m_sdlToAnki[SDLK_KP_A] = KeyCode::KP_A;
+	m_impl->m_sdlToAnki[SDLK_KP_B] = KeyCode::KP_B;
+	m_impl->m_sdlToAnki[SDLK_KP_C] = KeyCode::KP_C;
+	m_impl->m_sdlToAnki[SDLK_KP_D] = KeyCode::KP_D;
+	m_impl->m_sdlToAnki[SDLK_KP_E] = KeyCode::KP_E;
+	m_impl->m_sdlToAnki[SDLK_KP_F] = KeyCode::KP_F;
+	m_impl->m_sdlToAnki[SDLK_KP_XOR] = KeyCode::KP_XOR;
+	m_impl->m_sdlToAnki[SDLK_KP_POWER] = KeyCode::KP_POWER;
+	m_impl->m_sdlToAnki[SDLK_KP_PERCENT] = KeyCode::KP_PERCENT;
+	m_impl->m_sdlToAnki[SDLK_KP_LESS] = KeyCode::KP_LESS;
+	m_impl->m_sdlToAnki[SDLK_KP_GREATER] = KeyCode::KP_GREATER;
+	m_impl->m_sdlToAnki[SDLK_KP_AMPERSAND] = KeyCode::KP_AMPERSAND;
+	m_impl->m_sdlToAnki[SDLK_KP_DBLAMPERSAND] = KeyCode::KP_DBLAMPERSAND;
+	m_impl->m_sdlToAnki[SDLK_KP_VERTICALBAR] = KeyCode::KP_VERTICALBAR;
+	m_impl->m_sdlToAnki[SDLK_KP_DBLVERTICALBAR] = KeyCode::KP_DBLVERTICALBAR;
+	m_impl->m_sdlToAnki[SDLK_KP_COLON] = KeyCode::KP_COLON;
+	m_impl->m_sdlToAnki[SDLK_KP_HASH] = KeyCode::KP_HASH;
+	m_impl->m_sdlToAnki[SDLK_KP_SPACE] = KeyCode::KP_SPACE;
+	m_impl->m_sdlToAnki[SDLK_KP_AT] = KeyCode::KP_AT;
+	m_impl->m_sdlToAnki[SDLK_KP_EXCLAM] = KeyCode::KP_EXCLAM;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMSTORE] = KeyCode::KP_MEMSTORE;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMRECALL] = KeyCode::KP_MEMRECALL;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMCLEAR] = KeyCode::KP_MEMCLEAR;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMADD] = KeyCode::KP_MEMADD;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMSUBTRACT] = KeyCode::KP_MEMSUBTRACT;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMMULTIPLY] = KeyCode::KP_MEMMULTIPLY;
+	m_impl->m_sdlToAnki[SDLK_KP_MEMDIVIDE] = KeyCode::KP_MEMDIVIDE;
+	m_impl->m_sdlToAnki[SDLK_KP_PLUSMINUS] = KeyCode::KP_PLUSMINUS;
+	m_impl->m_sdlToAnki[SDLK_KP_CLEAR] = KeyCode::KP_CLEAR;
+	m_impl->m_sdlToAnki[SDLK_KP_CLEARENTRY] = KeyCode::KP_CLEARENTRY;
+	m_impl->m_sdlToAnki[SDLK_KP_BINARY] = KeyCode::KP_BINARY;
+	m_impl->m_sdlToAnki[SDLK_KP_OCTAL] = KeyCode::KP_OCTAL;
+	m_impl->m_sdlToAnki[SDLK_KP_DECIMAL] = KeyCode::KP_DECIMAL;
+	m_impl->m_sdlToAnki[SDLK_KP_HEXADECIMAL] = KeyCode::KP_HEXADECIMAL;
+	m_impl->m_sdlToAnki[SDLK_LCTRL] = KeyCode::LCTRL;
+	m_impl->m_sdlToAnki[SDLK_LSHIFT] = KeyCode::LSHIFT;
+	m_impl->m_sdlToAnki[SDLK_LALT] = KeyCode::LALT;
+	m_impl->m_sdlToAnki[SDLK_LGUI] = KeyCode::LGUI;
+	m_impl->m_sdlToAnki[SDLK_RCTRL] = KeyCode::RCTRL;
+	m_impl->m_sdlToAnki[SDLK_RSHIFT] = KeyCode::RSHIFT;
+	m_impl->m_sdlToAnki[SDLK_RALT] = KeyCode::RALT;
+	m_impl->m_sdlToAnki[SDLK_RGUI] = KeyCode::RGUI;
+	m_impl->m_sdlToAnki[SDLK_MODE] = KeyCode::MODE;
+	m_impl->m_sdlToAnki[SDLK_AUDIONEXT] = KeyCode::AUDIONEXT;
+	m_impl->m_sdlToAnki[SDLK_AUDIOPREV] = KeyCode::AUDIOPREV;
+	m_impl->m_sdlToAnki[SDLK_AUDIOSTOP] = KeyCode::AUDIOSTOP;
+	m_impl->m_sdlToAnki[SDLK_AUDIOPLAY] = KeyCode::AUDIOPLAY;
+	m_impl->m_sdlToAnki[SDLK_AUDIOMUTE] = KeyCode::AUDIOMUTE;
+	m_impl->m_sdlToAnki[SDLK_MEDIASELECT] = KeyCode::MEDIASELECT;
+	m_impl->m_sdlToAnki[SDLK_WWW] = KeyCode::WWW;
+	m_impl->m_sdlToAnki[SDLK_MAIL] = KeyCode::MAIL;
+	m_impl->m_sdlToAnki[SDLK_CALCULATOR] = KeyCode::CALCULATOR;
+	m_impl->m_sdlToAnki[SDLK_COMPUTER] = KeyCode::COMPUTER;
+	m_impl->m_sdlToAnki[SDLK_AC_SEARCH] = KeyCode::AC_SEARCH;
+	m_impl->m_sdlToAnki[SDLK_AC_HOME] = KeyCode::AC_HOME;
+	m_impl->m_sdlToAnki[SDLK_AC_BACK] = KeyCode::AC_BACK;
+	m_impl->m_sdlToAnki[SDLK_AC_FORWARD] = KeyCode::AC_FORWARD;
+	m_impl->m_sdlToAnki[SDLK_AC_STOP] = KeyCode::AC_STOP;
+	m_impl->m_sdlToAnki[SDLK_AC_REFRESH] = KeyCode::AC_REFRESH;
+	m_impl->m_sdlToAnki[SDLK_AC_BOOKMARKS] = KeyCode::AC_BOOKMARKS;
+	m_impl->m_sdlToAnki[SDLK_BRIGHTNESSDOWN] = KeyCode::BRIGHTNESSDOWN;
+	m_impl->m_sdlToAnki[SDLK_BRIGHTNESSUP] = KeyCode::BRIGHTNESSUP;
+	m_impl->m_sdlToAnki[SDLK_DISPLAYSWITCH] = KeyCode::DISPLAYSWITCH;
+	m_impl->m_sdlToAnki[SDLK_KBDILLUMTOGGLE] = KeyCode::KBDILLUMTOGGLE;
+	m_impl->m_sdlToAnki[SDLK_KBDILLUMDOWN] = KeyCode::KBDILLUMDOWN;
+	m_impl->m_sdlToAnki[SDLK_KBDILLUMUP] = KeyCode::KBDILLUMUP;
+	m_impl->m_sdlToAnki[SDLK_EJECT] = KeyCode::EJECT;
+	m_impl->m_sdlToAnki[SDLK_SLEEP] = KeyCode::SLEEP;
 
 	// Call once to clear first events
 	handleEvents();
@@ -293,12 +293,12 @@ void Input::handleEvents()
 		switch(event.type)
 		{
 		case SDL_KEYDOWN:
-			akkey = m_impl->m_sdlKeyToAnki[event.key.keysym.sym];
-			m_keys[akkey] = 1;
+			akkey = m_impl->m_sdlToAnki[event.key.keysym.sym];
+			m_keys[static_cast<U>(akkey)] = 1;
 			break;
 		case SDL_KEYUP:
-			akkey = m_impl->m_sdlKeyToAnki[event.key.keysym.sym];
-			m_keys[akkey] = 0;
+			akkey = m_impl->m_sdlToAnki[event.key.keysym.sym];
+			m_keys[static_cast<U>(akkey)] = 0;
 			break;
 		case SDL_MOUSEBUTTONDOWN:
 			//XXX

src/renderer/Dbg.cpp

@@ -45,7 +45,7 @@ void Dbg::init(const ConfigSet& initializer)
 		m_drawer.reset(new DebugDrawer);
 		m_sceneDrawer.reset(new SceneDebugDrawer(m_drawer.get()));
 
-		jobs.flush();
+		jobs.finish();
 	}
 	catch(std::exception& e)
 	{
@@ -61,18 +61,23 @@ void Dbg::run(GlJobChainHandle& jobs)
 	SceneGraph& scene = m_r->getSceneGraph();
 
 	m_fb.bind(jobs, false);
-	jobs.enableBlend(true);
 	jobs.enableDepthTest(m_depthTest);
 
+	Camera& cam = scene.getActiveCamera();
 	m_drawer->prepareDraw(jobs);
-	m_drawer->setViewProjectionMatrix(
-		scene.getActiveCamera().getViewProjectionMatrix());
+	m_drawer->setViewProjectionMatrix(cam.getViewProjectionMatrix());
 	m_drawer->setModelMatrix(Mat4::getIdentity());
 	//drawer->drawGrid();
 
 	scene.iterateSceneNodes([&](SceneNode& node)
 	{
 		SpatialComponent* sp = node.tryGetComponent<SpatialComponent>();
+
+		if(&cam.getComponent<SpatialComponent>() == sp)
+		{
+			return;
+		}
+
 		if(bitsEnabled(DF_SPATIAL) && sp)
 		{
 			m_sceneDrawer->draw(node);
@@ -176,11 +181,10 @@ void Dbg::run(GlJobChainHandle& jobs)
 	// XXX
 #endif
 
-	jobs.enableBlend(false);
-	jobs.enableDepthTest(false);
-
 	m_drawer->flush();
 	m_drawer->finishDraw();
+
+	jobs.enableDepthTest(false);
 }
 
 } // end namespace anki

src/renderer/DebugDrawer.cpp

@@ -10,6 +10,7 @@
 #include "anki/Scene.h"
 #include "anki/resource/TextureResource.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/core/Logger.h"
 
 namespace anki {
 
@@ -39,7 +40,7 @@ DebugDrawer::DebugDrawer()
 	m_mvpMat.setIdentity();
 	m_crntCol = Vec3(1.0, 0.0, 0.0);
 
-	jobs.flush();
+	jobs.finish();
 }
 
 //==============================================================================
@@ -71,8 +72,8 @@ void DebugDrawer::end()
 {
 	if(m_vertexPointer % 2 != 0)
 	{
-		// push back the previous vertex to close the loop
-		pushBackVertex(m_clientVerts[m_vertexPointer].m_positionAndColor.xyz());
+		pushBackVertex(Vec3(0.0));
+		ANKI_LOGW("Forgot to close the line loop");
 	}
 }
 
@@ -93,19 +94,10 @@ void DebugDrawer::flush()
 	m_ppline.bind(m_jobs);
 
 	m_vertBuff.bindVertexBuffer(m_jobs, 
-		3, GL_FLOAT, false, sizeof(Vertex), 0, 0); // Pos
+		4, GL_FLOAT, false, sizeof(Vertex), 0, 0); // Pos
 
 	m_vertBuff.bindVertexBuffer(m_jobs, 
-		4, GL_UNSIGNED_BYTE, true, sizeof(Vertex), sizeof(Vec3), 1); // Color
-
-	m_vertBuff.bindVertexBuffer(m_jobs, 
-		4, GL_FLOAT, false, sizeof(Vertex), 1 * sizeof(Vec4), 2);
-	m_vertBuff.bindVertexBuffer(m_jobs, 
-		4, GL_FLOAT, false, sizeof(Vertex), 2 * sizeof(Vec4), 3);
-	m_vertBuff.bindVertexBuffer(m_jobs, 
-		4, GL_FLOAT, false, sizeof(Vertex), 3 * sizeof(Vec4), 4);
-	m_vertBuff.bindVertexBuffer(m_jobs, 
-		4, GL_FLOAT, false, sizeof(Vertex), 4 * sizeof(Vec4), 5);
+		4, GL_FLOAT, true, sizeof(Vertex), sizeof(Vec4), 1); // Color
 
 	GlDrawcallArrays dc(GL_LINES, m_vertexPointer);
 
@@ -117,21 +109,8 @@ void DebugDrawer::flush()
 //==============================================================================
 void DebugDrawer::pushBackVertex(const Vec3& pos)
 {
-	U32 color = (U8)(1.0 * 255.0);
-	color = (color << 8) | (U8)(m_crntCol.z() * 255.0);
-	color = (color << 8) | (U8)(m_crntCol.y() * 255.0);
-	color = (color << 8) | (U8)(m_crntCol.x() * 255.0);
-
-	union
-	{
-		F32 f;
-		U32 u;
-	} uni;
-
-	uni.u = color;
-
-	m_clientVerts[m_vertexPointer].m_positionAndColor = Vec4(pos, uni.f);
-	m_clientVerts[m_vertexPointer].m_matrix = m_mvpMat.getTransposed();
+	m_clientVerts[m_vertexPointer].m_position = m_mvpMat * Vec4(pos, 1.0);
+	m_clientVerts[m_vertexPointer].m_color = Vec4(m_crntCol, 1.0);
 
 	++m_vertexPointer;
 
@@ -197,7 +176,7 @@ void DebugDrawer::drawGrid()
 }
 
 //==============================================================================
-void DebugDrawer::drawSphere(F32 radius, int complexity)
+void DebugDrawer::drawSphere(F32 radius, I complexity)
 {
 	Vector<Vec3>* sphereLines;
 
@@ -336,6 +315,16 @@ void CollisionDebugDrawer::visit(const Plane& plane)
 	m_dbg->drawGrid();
 }
 
+//==============================================================================
+void CollisionDebugDrawer::visit(const LineSegment& ls)
+{
+	m_dbg->setModelMatrix(Mat4::getIdentity());
+	m_dbg->begin();
+	m_dbg->pushBackVertex(ls.getOrigin());
+	m_dbg->pushBackVertex(ls.getOrigin() + ls.getDirection());
+	m_dbg->end();
+}
+
 //==============================================================================
 void CollisionDebugDrawer::visit(const Aabb& aabb)
 {

testapp/Main.cpp

@@ -136,7 +136,7 @@ void init()
 	scene.setActiveCamera(cam);
 
 	// lights
-#if 1
+#if 0
 	Vec3 lpos(-24.0, 0.1, -10.0);
 	for(int i = 0; i < 50; i++)
 	{
@@ -160,7 +160,7 @@ void init()
 	}
 #endif
 
-#if 1
+#if 0
 	SpotLight* spot = scene.newSceneNode<SpotLight>("spot0");
 	spot->setOuterAngle(toRad(45.0));
 	spot->setInnerAngle(toRad(15.0));
@@ -261,7 +261,7 @@ void init()
 	}
 #endif
 
-#if 1
+#if 0
 	// horse
 	horse = scene.newSceneNode<ModelNode>("horse", "models/horse/horse.ankimdl");
 	horse->setLocalTransform(Transform(Vec3(-2, 0, 0), Mat3::getIdentity(),
@@ -281,20 +281,13 @@ void init()
 #endif
 
 #if 0
-	StaticGeometryNode* sponzaModel = new StaticGeometryNode(
-		//"data/maps/sponza/sponza_no_bmeshes.mdl",
-		//"data/maps/sponza/sponza.mdl",
-		"sponza", &scene, "data/maps/sponza/static_geometry.mdl");
-
-	(void)sponzaModel;
-#endif
-	//scene.load("maps/sponza/master.ankiscene");
 	{
 		String str;
 		File file(ANKI_R("maps/sponza/scene.lua"), File::OpenFlag::READ);
 		file.readAllText(str);
 		ScriptManagerSingleton::get().evalString(str.c_str());
 	}
+#endif
 
 	initPhysics();
 
@@ -329,6 +322,17 @@ void init()
 	scene.getEventManager().newFollowPathEvent(-1.0, 
 		path->getDistance() / distPerSec, 
 		cam, path, distPerSec);*/
+
+
+	horse = scene.newSceneNode<ModelNode>("shape0", 
+		"models/collision_test/Cube_Material-material.ankimdl");
+	horse->setLocalTransform(Transform(Vec3(0.0, 0, 0), Mat3::getIdentity(),
+		1.0));
+
+	horse = scene.newSceneNode<ModelNode>("shape1", 
+		"models/collision_test/Cube.001_Material_001-material.ankimdl");
+	horse->setLocalTransform(Transform(Vec3(0, 3, 0), Mat3::getIdentity(),
+		1.0));
 }
 
 //==============================================================================
@@ -369,36 +373,36 @@ void mainLoopExtra()
 		&SceneGraphSingleton::get().getActiveCamera().getComponent<MoveComponent>();
 	Input& in = InputSingleton::get();
 
-	if(in.getKey(KC_1))
+	if(in.getKey(KeyCode::_1))
 	{
 		mover = &SceneGraphSingleton::get().getActiveCamera();
 	}
-	if(in.getKey(KC_2))
+	if(in.getKey(KeyCode::_2))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("horse").getComponent<MoveComponent>();
 	}
-	if(in.getKey(KC_3))
+	if(in.getKey(KeyCode::_3))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("spot0").getComponent<MoveComponent>();
 	}
-	if(in.getKey(KC_4))
+	if(in.getKey(KeyCode::_4))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("spot1").getComponent<MoveComponent>();
 	}
-	if(in.getKey(KC_5))
+	if(in.getKey(KeyCode::_5))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("pe").getComponent<MoveComponent>();
 	}
-	if(in.getKey(KC_6))
+	if(in.getKey(KeyCode::_6))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("vase_plight0").getComponent<MoveComponent>();
 	}
-	if(in.getKey(KC_7))
+	if(in.getKey(KeyCode::_7))
 	{
 		mover = &SceneGraphSingleton::get().findSceneNode("red_barrel").getComponent<MoveComponent>();
 	}
 
-	/*if(in.getKey(KC_L) == 1)
+	/*if(in.getKey(KeyCode::L) == 1)
 	{
 		SceneNode& l = 
 			SceneGraphSingleton::get().findSceneNode("crate");
@@ -409,62 +413,62 @@ void mainLoopExtra()
 		l.getComponent<MoveComponent>().setLocalTransform(trf);
 	}*/
 
-	if(in.getKey(KC_F1) == 1)
+	if(in.getKey(KeyCode::F1) == 1)
 	{
 		MainRendererSingleton::get().getDbg().setEnabled(
 			!MainRendererSingleton::get().getDbg().getEnabled());
 	}
-	if(in.getKey(KC_F2) == 1)
+	if(in.getKey(KeyCode::F2) == 1)
 	{
 		MainRendererSingleton::get().getDbg().switchBits(
 			Dbg::DF_SPATIAL);
 	}
-	if(in.getKey(KC_F3) == 1)
+	if(in.getKey(KeyCode::F3) == 1)
 	{
 		MainRendererSingleton::get().getDbg().switchBits(
 			Dbg::DF_PHYSICS);
 	}
-	if(in.getKey(KC_F4) == 1)
+	if(in.getKey(KeyCode::F4) == 1)
 	{
 		MainRendererSingleton::get().getDbg().switchBits(
 			Dbg::DF_SECTOR);
 	}
-	if(in.getKey(KC_F5) == 1)
+	if(in.getKey(KeyCode::F5) == 1)
 	{
 		MainRendererSingleton::get().getDbg().switchBits(
 			Dbg::DF_OCTREE);
 	}
-	if(in.getKey(KC_F6) == 1)
+	if(in.getKey(KeyCode::F6) == 1)
 	{
 		MainRendererSingleton::get().getDbg().switchDepthTestEnabled();
 	}
-	if(in.getKey(KC_F12) == 1)
+	if(in.getKey(KeyCode::F12) == 1)
 	{
 		MainRendererSingleton::get().takeScreenshot("screenshot.tga");
 	}
 
-	if(in.getKey(KC_UP)) mover->rotateLocalX(ang);
-	if(in.getKey(KC_DOWN)) mover->rotateLocalX(-ang);
-	if(in.getKey(KC_LEFT)) mover->rotateLocalY(ang);
-	if(in.getKey(KC_RIGHT)) mover->rotateLocalY(-ang);
-
-	if(in.getKey(KC_A)) mover->moveLocalX(-dist);
-	if(in.getKey(KC_D)) mover->moveLocalX(dist);
-	if(in.getKey(KC_Z)) mover->moveLocalY(dist);
-	if(in.getKey(KC_SPACE)) mover->moveLocalY(-dist);
-	if(in.getKey(KC_W)) mover->moveLocalZ(-dist);
-	if(in.getKey(KC_S)) mover->moveLocalZ(dist);
-	if(in.getKey(KC_Q)) mover->rotateLocalZ(ang);
-	if(in.getKey(KC_E)) mover->rotateLocalZ(-ang);
-	if(in.getKey(KC_PAGEUP))
+	if(in.getKey(KeyCode::UP)) mover->rotateLocalX(ang);
+	if(in.getKey(KeyCode::DOWN)) mover->rotateLocalX(-ang);
+	if(in.getKey(KeyCode::LEFT)) mover->rotateLocalY(ang);
+	if(in.getKey(KeyCode::RIGHT)) mover->rotateLocalY(-ang);
+
+	if(in.getKey(KeyCode::A)) mover->moveLocalX(-dist);
+	if(in.getKey(KeyCode::D)) mover->moveLocalX(dist);
+	if(in.getKey(KeyCode::Z)) mover->moveLocalY(dist);
+	if(in.getKey(KeyCode::SPACE)) mover->moveLocalY(-dist);
+	if(in.getKey(KeyCode::W)) mover->moveLocalZ(-dist);
+	if(in.getKey(KeyCode::S)) mover->moveLocalZ(dist);
+	if(in.getKey(KeyCode::Q)) mover->rotateLocalZ(ang);
+	if(in.getKey(KeyCode::E)) mover->rotateLocalZ(-ang);
+	if(in.getKey(KeyCode::PAGEUP))
 	{
 		mover->scale(scale);
 	}
-	if(in.getKey(KC_PAGEDOWN))
+	if(in.getKey(KeyCode::PAGEDOWN))
 	{
 		mover->scale(-scale);
 	}
-	if(in.getKey(KC_P) == 1)
+	if(in.getKey(KeyCode::P) == 1)
 	{
 		std::cout << "{Vec3(" 
 			<< mover->getWorldTransform().getOrigin().toString()
@@ -473,7 +477,7 @@ void mainLoopExtra()
 			<< ")}," << std::endl;
 	}
 
-	if(in.getKey(KC_L) == 1)
+	if(in.getKey(KeyCode::L) == 1)
 	{
 		try
 		{
@@ -533,7 +537,7 @@ void mainLoop()
 		//EventManagerSingleton::get().updateAllEvents(prevUpdateTime, crntTime);
 		MainRendererSingleton::get().render(SceneGraphSingleton::get());
 
-		if(InputSingleton::get().getKey(KC_ESCAPE))
+		if(InputSingleton::get().getKey(KeyCode::ESCAPE))
 		{
 			break;
 		}
@@ -638,9 +642,9 @@ void initSubsystems(int argc, char* argv[])
 	config.set("pps.hdr.enabled", true);
 	config.set("pps.hdr.renderingQuality", 0.6);
 	config.set("pps.hdr.blurringDist", 1.0);
-	config.set("pps.hdr.blurringIterationsCount", 4);
+	config.set("pps.hdr.blurringIterationsCount", 2);
 	config.set("pps.hdr.exposure", 8.0);
-	config.set("pps.hdr.samples", 11);
+	config.set("pps.hdr.samples", 17);
 	config.set("pps.sslr.enabled", true);
 	config.set("pps.sslr.renderingQuality", 0.35);
 	config.set("pps.sslr.blurringIterationsCount", 1);