~ Initial SDL2 implementation

Limitation
- Dependent projects need to set NAZARA_PLATFORM_SDL2 if nazara has been build with SDL2 since OpenGL.hpp (and maybe some other headers) exposes platform details
- SDL2 window doesn't supports async window since the API isn't fitting for now
- Contexts parameters can't be changed until we close all the SDL windows (SDL limitation)

.gitignore

@@ -162,3 +162,5 @@ DocProject/Help/*.hhk
 DocProject/Help/*.hhp
 DocProject/Help/Html2
 DocProject/Help/html
+
+build/gmake/

SDK/src/NDK/Lua/LuaBinding_Platform.cpp

@@ -33,7 +33,7 @@ namespace Ndk
 
 		keyboard.PushGlobalTable(state);
 		{
-			static_assert(Nz::Keyboard::Count == 121, "Nz::Keyboard::Key has been updated but change was not reflected to Lua binding");
+			static_assert(Nz::Keyboard::Count == 124, "Nz::Keyboard::Key has been updated but change was not reflected to Lua binding");
 
 			state.PushField("Undefined", Nz::Keyboard::Undefined);
 
@@ -63,6 +63,7 @@ namespace Ndk
 			state.PushField("Divide",            Nz::Keyboard::Divide);
 			state.PushField("Multiply",          Nz::Keyboard::Multiply);
 			state.PushField("Subtract",          Nz::Keyboard::Subtract);
+			state.PushField("NumpadReturn",      Nz::Keyboard::NumpadReturn);
 
 			state.PushField("Backslash",         Nz::Keyboard::Backslash);
 			state.PushField("Backspace",         Nz::Keyboard::Backspace);
@@ -98,6 +99,8 @@ namespace Ndk
 			state.PushField("Space",             Nz::Keyboard::Space);
 			state.PushField("Tab",               Nz::Keyboard::Tab);
 			state.PushField("Tilde",             Nz::Keyboard::Tilde);
+			state.PushField("Menu",              Nz::Keyboard::Menu);
+			state.PushField("ISOBackslash102",   Nz::Keyboard::ISOBackslash102);
 			state.PushField("Browser_Back",      Nz::Keyboard::Browser_Back);
 			state.PushField("Browser_Favorites", Nz::Keyboard::Browser_Favorites);
 			state.PushField("Browser_Forward",   Nz::Keyboard::Browser_Forward);

build/config.lua

@@ -24,3 +24,6 @@ ServerMode = false
 
 -- Builds modules as one united library (useless on POSIX systems)
 UniteModules = false
+
+-- Use SDL2 platform
+PlatformSDL2 = true

build/scripts/common.lua

@@ -387,6 +387,7 @@ function NazaraBuild:Initialize()
 		if (f) then
 			MODULE = {}
 			self:SetupModuleTable(MODULE)
+			Config = self.Config
 
 			f()
 
@@ -529,6 +530,7 @@ function NazaraBuild:LoadConfig()
 	AddBoolOption("PremakeProject", "premakeproject", "Add a PremakeProject as a shortcut to call Premake")
 	AddBoolOption("ServerMode", "server", "Excludes client-only modules/tools/examples")
 	AddBoolOption("UniteModules", "united", "Builds all the modules as one united library")
+	AddBoolOption("PlatformSDL2", "platform-sdl2", "Use SDL2 instead of native APIs")
 
 	-- AdditionalCompilationOptions
 	do

build/scripts/modules/platform.lua

@@ -7,6 +7,19 @@ MODULE.Libraries = {
 	"NazaraUtility"
 }
 
+if Config.PlatformSDL2 then
+	table.insert(MODULE.Defines, "NAZARA_PLATFORM_SDL2")
+
+	table.insert(MODULE.Files, "../src/Nazara/Platform/SDL2/**.hpp")
+	table.insert(MODULE.Files, "../src/Nazara/Platform/SDL2/**.cpp")
+
+	table.insert(MODULE.Libraries, "SDL2")
+
+	MODULE.FilesExcluded = {
+		"../src/Nazara/Platform/Win32/**",
+		"../src/Nazara/Platform/X11/**"
+	}
+else
 	MODULE.OsFiles.Windows = {
 		"../src/Nazara/Platform/Win32/**.hpp",
 		"../src/Nazara/Platform/Win32/**.cpp"
@@ -31,3 +44,4 @@ MODULE.OsLibraries.Posix = {
 		"xcb-randr"
 	}
 
+end

build/scripts/modules/renderer.lua

@@ -12,6 +12,17 @@ MODULE.Libraries = {
 	"NazaraPlatform"
 }
 
+if Config.PlatformSDL2 then
+    table.insert(MODULE.Defines, "NAZARA_PLATFORM_SDL2")
+
+    table.insert(MODULE.Files, "../src/Nazara/Renderer/SDL2/**.hpp")
+    table.insert(MODULE.Files, "../src/Nazara/Renderer/SDL2/**.cpp")
+
+    MODULE.FilesExcluded = {
+        "../src/Nazara/Renderer/Win32/**",
+        "../src/Nazara/Renderer/GLX/**.cpp"
+    }
+else
     MODULE.OsFiles.Windows = {
         "../src/Nazara/Renderer/Win32/**.hpp",
         "../src/Nazara/Renderer/Win32/**.cpp"
@@ -32,3 +43,4 @@ MODULE.OsLibraries.Posix = {
         "GL",
         "X11"
     }
+end

examples/FirstScene/build.lua

@@ -9,3 +9,7 @@ EXAMPLE.Files = {
 EXAMPLE.Libraries = {
 	"NazaraSDK"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/HardwareInfo/build.lua

@@ -16,3 +16,7 @@ EXAMPLE.Libraries = {
 	"NazaraRenderer",
 	"NazaraUtility"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/MeshInfos/build.lua

@@ -12,3 +12,6 @@ EXAMPLE.Libraries = {
 	"NazaraUtility"
 }
 
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/Particles/build.lua

@@ -11,3 +11,7 @@ EXAMPLE.Files = {
 EXAMPLE.Libraries = {
 	"NazaraSDK"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/Tut00/build.lua

@@ -20,3 +20,7 @@ EXAMPLE.Libraries = {
     "NazaraUtility",
     "NazaraSDK"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/Tut01/build.lua

@@ -9,3 +9,7 @@ EXAMPLE.Files = {
 EXAMPLE.Libraries = {
 	"NazaraSDK"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

examples/Tut02/build.lua

@@ -9,3 +9,7 @@ EXAMPLE.Files = {
 EXAMPLE.Libraries = {
 	"NazaraSDK"
 }
+
+if Config.PlatformSDL2 then
+	table.insert(EXAMPLE.Defines, "NAZARA_PLATFORM_SDL2")
+end

include/Nazara/Platform/Keyboard.hpp

@@ -78,6 +78,7 @@ namespace Nz
 				Decimal,
 				Divide,
 				Multiply,
+				NumpadReturn,
 				Numpad0,
 				Numpad1,
 				Numpad2,
@@ -135,6 +136,8 @@ namespace Nz
 				Space,
 				Tab,
 				Tilde,
+				Menu,
+				ISOBackslash102,
 
 				// Navigator keys
 				Browser_Back,

include/Nazara/Platform/VideoMode.hpp

@@ -32,12 +32,12 @@ namespace Nz
 			static const std::vector<VideoMode>& GetFullscreenModes();
 	};
 
-	bool operator==(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator==(const VideoMode& left, const VideoMode& right);
-	bool operator!=(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator!=(const VideoMode& left, const VideoMode& right);
-	bool operator<(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator<(const VideoMode& left, const VideoMode& right);
-	bool operator<=(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator<=(const VideoMode& left, const VideoMode& right);
-	bool operator>(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator>(const VideoMode& left, const VideoMode& right);
-	bool operator>=(const VideoMode& left, const VideoMode& right);
+	bool NAZARA_PLATFORM_API operator>=(const VideoMode& left, const VideoMode& right);
 }
 
 #endif // NAZARA_VIDEOMODE_HPP

include/Nazara/Platform/WindowHandle.hpp

@@ -8,13 +8,17 @@
 #define NAZARA_WINDOWHANDLE_HPP
 
 #include <Nazara/Prerequisites.hpp>
-#if defined(NAZARA_PLATFORM_X11)
+#if defined(NAZARA_PLATFORM_SDL2)
+#elif defined(NAZARA_PLATFORM_X11)
 #include <xcb/xcb.h>
 #endif
 
 namespace Nz
 {
-	#if defined(NAZARA_PLATFORM_WINDOWS)
+	#if defined(NAZARA_PLATFORM_SDL2)
+	// Real type is SDL_Window
+	using WindowHandle = void*;
+	#elif defined(NAZARA_PLATFORM_WINDOWS)
 	// http://msdn.microsoft.com/en-us/library/aa383751(v=vs.85).aspx
 	using WindowHandle = void*;
 	#elif defined(NAZARA_PLATFORM_X11)

include/Nazara/Prerequisites.hpp

@@ -117,9 +117,12 @@
 	#endif
 #elif defined(__linux__) || defined(__unix__)
 	#define NAZARA_PLATFORM_LINUX
-	#define NAZARA_PLATFORM_GLX
 	#define NAZARA_PLATFORM_POSIX
+
+	#ifndef NAZARA_PLATFORM_SDL2
+		#define NAZARA_PLATFORM_GLX
 		#define NAZARA_PLATFORM_X11
+	#endif
 
 	#define NAZARA_EXPORT __attribute__((visibility ("default")))
 	#define NAZARA_IMPORT __attribute__((visibility ("default")))

include/Nazara/Renderer/OpenGL.hpp

@@ -6,12 +6,14 @@
 
 #ifndef NAZARA_OPENGL_HPP
 #define NAZARA_OPENGL_HPP
-
+#ifndef NAZARA_RENDERER_OPENGL
+#define NAZARA_RENDERER_OPENGL
+#endif
 #ifdef NAZARA_RENDERER_OPENGL
 
-#include <Nazara/Prerequisites.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Rect.hpp>
+#include <Nazara/Prerequisites.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/Enums.hpp>
 #include <Nazara/Utility/Enums.hpp>
@@ -21,7 +23,9 @@
 #include <GL/glcorearb.h>
 #include <GL/glext.h>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <SDL2/SDL_video.h>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <GL/wglext.h>
 #elif defined(NAZARA_PLATFORM_GLX)
 namespace GLX
@@ -331,7 +335,8 @@ NAZARA_RENDERER_API extern PFNGLVERTEXATTRIBPOINTERPROC      glVertexAttribPoint
 	NAZARA_RENDERER_API extern PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer;
 	NAZARA_RENDERER_API extern PFNGLVERTEXATTRIBLPOINTERPROC glVertexAttribLPointer;
 	NAZARA_RENDERER_API extern PFNGLVIEWPORTPROC glViewport;
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	NAZARA_RENDERER_API extern PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormat;
 	NAZARA_RENDERER_API extern PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs;
 	NAZARA_RENDERER_API extern PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB;
@@ -346,6 +351,8 @@ NAZARA_RENDERER_API extern GLX::PFNGLXSWAPINTERVALSGIPROC         glXSwapInterva
 
 }
 
+#undef None
+
 #endif // NAZARA_RENDERER_OPENGL
 
 #endif // NAZARA_OPENGL_HPP

src/Nazara/Platform/Cursor.cpp

@@ -4,7 +4,9 @@
 
 #include <Nazara/Platform/Cursor.hpp>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/CursorImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/CursorImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/CursorImpl.hpp>

src/Nazara/Platform/Icon.cpp

@@ -4,7 +4,9 @@
 
 #include <Nazara/Platform/Icon.hpp>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/IconImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/IconImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/IconImpl.hpp>

src/Nazara/Platform/Keyboard.cpp

@@ -4,7 +4,9 @@
 
 #include <Nazara/Platform/Keyboard.hpp>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/InputImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/InputImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/InputImpl.hpp>

src/Nazara/Platform/Mouse.cpp

@@ -5,7 +5,9 @@
 #include <Nazara/Platform/Mouse.hpp>
 #include <Nazara/Platform/Window.hpp>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/InputImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/InputImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/InputImpl.hpp>

src/Nazara/Platform/SDL2/CursorImpl.cpp

@@ -0,0 +1,108 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Platform/Debug.hpp>
+#include <Nazara/Platform/SDL2/CursorImpl.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <Nazara/Utility/PixelFormat.hpp>
+
+namespace Nz
+{
+	bool CursorImpl::Create(const Image& cursor, int hotSpotX, int hotSpotY)
+	{
+		m_iconImage = cursor;
+		if (!m_iconImage.Convert(PixelFormatType_BGRA8))
+		{
+			NazaraError("Failed to convert icon to BGRA8");
+			return false;
+		}
+
+		m_icon = SDL_CreateRGBSurfaceWithFormatFrom(
+			m_iconImage.GetPixels(),
+			m_iconImage.GetWidth(),
+			m_iconImage.GetHeight(),
+			32,
+			32 * m_iconImage.GetWidth(),
+			SDL_PIXELFORMAT_BGRA8888
+			);
+
+		if (!m_icon)
+		{
+			NazaraError(SDL_GetError());
+
+			return false;
+		}
+
+		m_cursor = SDL_CreateColorCursor(m_icon, hotSpotX, hotSpotY);
+
+		if (!m_cursor)
+		{
+			NazaraError(SDL_GetError());
+
+			return false;
+		}
+
+		return true;
+	}
+
+	bool CursorImpl::Create(SystemCursor cursor)
+	{
+		if (cursor != SystemCursor_None)
+			m_cursor = SDL_CreateSystemCursor(s_systemCursorIds[cursor]);
+		else
+			m_cursor = nullptr;
+
+		m_icon = nullptr;
+
+		return true;
+	}
+
+	void CursorImpl::Destroy()
+	{
+		if (m_icon)
+			SDL_FreeSurface(m_icon);
+
+		if (m_cursor)
+			SDL_FreeCursor(m_cursor);
+	}
+
+	SDL_Cursor* CursorImpl::GetCursor()
+	{
+		return m_cursor;
+	}
+
+	bool CursorImpl::Initialize()
+	{
+		return true;
+	}
+
+	void CursorImpl::Uninitialize()
+	{
+	}
+
+	std::array<SDL_SystemCursor, SystemCursor_Max + 1> CursorImpl::s_systemCursorIds =
+	{
+		SDL_SYSTEM_CURSOR_CROSSHAIR,                     // SystemCursor_Crosshair
+		SDL_SYSTEM_CURSOR_ARROW,                         // SystemCursor_Default
+		SDL_SYSTEM_CURSOR_HAND,                          // SystemCursor_Hand
+		SDL_SYSTEM_CURSOR_ARROW,                         // SystemCursor_Help
+		SDL_SYSTEM_CURSOR_SIZEALL,                       // SystemCursor_Move
+		SDL_NUM_SYSTEM_CURSORS,                          // SystemCursor_None
+		SDL_SYSTEM_CURSOR_HAND,                          // SystemCursor_Pointer
+		SDL_SYSTEM_CURSOR_WAITARROW,                     // SystemCursor_Progress
+		SDL_SYSTEM_CURSOR_SIZEWE,                        // SystemCursor_ResizeE
+		SDL_SYSTEM_CURSOR_SIZENS,                        // SystemCursor_ResizeN
+		SDL_SYSTEM_CURSOR_SIZENESW,                      // SystemCursor_ResizeNE
+		SDL_SYSTEM_CURSOR_SIZENWSE,                      // SystemCursor_ResizeNW
+		SDL_SYSTEM_CURSOR_SIZENS,                        // SystemCursor_ResizeS
+		SDL_SYSTEM_CURSOR_SIZENWSE,                      // SystemCursor_ResizeSE
+		SDL_SYSTEM_CURSOR_SIZENESW,                      // SystemCursor_ResizeSW
+		SDL_SYSTEM_CURSOR_SIZEWE,                        // SystemCursor_ResizeW
+		SDL_SYSTEM_CURSOR_IBEAM,                         // SystemCursor_Text
+		SDL_SYSTEM_CURSOR_WAIT                           // SystemCursor_Wait
+	};
+
+	static_assert(SystemCursor_Max + 1 == 18, "System cursor array is incomplete");
+}

src/Nazara/Platform/SDL2/CursorImpl.hpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_CURSORIMPL_HPP
+#define NAZARA_CURSORIMPL_HPP
+
+#include <array>
+#include <Nazara/Platform/Enums.hpp>
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Utility/Image.hpp>
+
+#include <SDL2/SDL_mouse.h>
+
+namespace Nz
+{
+	class Image;
+
+	class CursorImpl
+	{
+		friend class Cursor;
+
+		public:
+			bool Create(const Image& image, int hotSpotX, int hotSpotY);
+			bool Create(SystemCursor cursor);
+
+			void Destroy();
+
+			SDL_Cursor* GetCursor();
+
+		private:
+			static bool Initialize();
+			static void Uninitialize();
+
+			SDL_Cursor* m_cursor = nullptr;
+			SDL_Surface* m_icon = nullptr;
+			Image m_iconImage;
+
+			static std::array<SDL_SystemCursor, SystemCursor_Max + 1> s_systemCursorIds;
+	};
+}
+
+#endif // NAZARA_CURSORIMPL_HPP

src/Nazara/Platform/SDL2/IconImpl.cpp

@@ -0,0 +1,49 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Platform/Debug.hpp>
+#include <Nazara/Platform/SDL2/IconImpl.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <Nazara/Utility/PixelFormat.hpp>
+
+namespace Nz
+{
+	bool IconImpl::Create(const Image& icon)
+	{
+		m_iconImage = icon;
+		if (!m_iconImage.Convert(PixelFormatType_BGRA8))
+		{
+			NazaraError("Failed to convert icon to BGRA8");
+			return false;
+		}
+
+		m_icon = SDL_CreateRGBSurfaceWithFormatFrom(
+			m_iconImage.GetPixels(),
+			m_iconImage.GetWidth(),
+			m_iconImage.GetHeight(),
+			32,
+			32 * m_iconImage.GetWidth(),
+			SDL_PIXELFORMAT_BGRA8888
+			);
+
+		if (!m_icon)
+		{
+			NazaraError(SDL_GetError());
+			return false;
+		}
+
+		return true;
+	}
+
+	void IconImpl::Destroy()
+	{
+		SDL_FreeSurface(m_icon);
+		m_iconImage.Destroy();
+	}
+
+	SDL_Surface* IconImpl::GetIcon()
+	{
+		return m_icon;
+	}
+}

src/Nazara/Platform/SDL2/IconImpl.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_ICONIMPL_HPP
+#define NAZARA_ICONIMPL_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <SDL2/SDL_surface.h>
+
+namespace Nz
+{
+	class Image;
+
+	class IconImpl
+	{
+		public:
+			bool Create(const Image& image);
+			void Destroy();
+
+			SDL_Surface* GetIcon();
+
+		private:
+
+			SDL_Surface* m_icon = nullptr;
+			Image m_iconImage;
+	};
+}
+
+#endif // NAZARA_ICONIMPL_HPP

src/Nazara/Platform/SDL2/InputImpl.cpp

@@ -0,0 +1,234 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Platform/Debug.hpp>
+#include <Nazara/Platform/SDL2/InputImpl.hpp>
+#include <Nazara/Platform/Window.hpp>
+
+#include <SDL2/SDL_keyboard.h>
+#include <SDL2/SDL_mouse.h>
+
+namespace Nz
+{
+	namespace
+	{
+		SDL_Scancode nzKeyboardToSDLScanCode[Keyboard::Count] = {
+			// Lettres
+			SDL_SCANCODE_A, // Key::A
+			SDL_SCANCODE_B, // Key::B
+			SDL_SCANCODE_C, // Key::C
+			SDL_SCANCODE_D, // Key::D
+			SDL_SCANCODE_E, // Key::E
+			SDL_SCANCODE_F, // Key::F
+			SDL_SCANCODE_G, // Key::G
+			SDL_SCANCODE_H, // Key::H
+			SDL_SCANCODE_I, // Key::I
+			SDL_SCANCODE_J, // Key::J
+			SDL_SCANCODE_K, // Key::K
+			SDL_SCANCODE_L, // Key::L
+			SDL_SCANCODE_M, // Key::M
+			SDL_SCANCODE_N, // Key::N
+			SDL_SCANCODE_O, // Key::O
+			SDL_SCANCODE_P, // Key::P
+			SDL_SCANCODE_Q, // Key::Q
+			SDL_SCANCODE_R, // Key::R
+			SDL_SCANCODE_S, // Key::S
+			SDL_SCANCODE_T, // Key::T
+			SDL_SCANCODE_U, // Key::U
+			SDL_SCANCODE_V, // Key::V
+			SDL_SCANCODE_W, // Key::W
+			SDL_SCANCODE_X, // Key::X
+			SDL_SCANCODE_Y, // Key::Y
+			SDL_SCANCODE_Z, // Key::Z
+
+			// Touches de fonction
+			SDL_SCANCODE_F1,    // Key::F1
+			SDL_SCANCODE_F2,    // Key::F2
+			SDL_SCANCODE_F3,    // Key::F3
+			SDL_SCANCODE_F4,    // Key::F4
+			SDL_SCANCODE_F5,    // Key::F5
+			SDL_SCANCODE_F6,    // Key::F6
+			SDL_SCANCODE_F7,    // Key::F7
+			SDL_SCANCODE_F8,    // Key::F8
+			SDL_SCANCODE_F9,    // Key::F9
+			SDL_SCANCODE_F10,   // Key::F10
+			SDL_SCANCODE_F11,   // Key::F11
+			SDL_SCANCODE_F12,   // Key::F12
+			SDL_SCANCODE_F13,   // Key::F13
+			SDL_SCANCODE_F14,   // Key::F14
+			SDL_SCANCODE_F15,   // Key::F15
+
+			// Flèches directionnelles
+			SDL_SCANCODE_DOWN,  // Key::Down
+			SDL_SCANCODE_LEFT,  // Key::Left
+			SDL_SCANCODE_RIGHT, // Key::Right
+			SDL_SCANCODE_UP,    // Key::Up
+
+			// Pavé numérique
+			SDL_SCANCODE_KP_PLUS,       // Key::Add
+			SDL_SCANCODE_KP_PERIOD,     // Key::Decimal
+			SDL_SCANCODE_KP_DIVIDE,     // Key::Divide
+			SDL_SCANCODE_KP_MULTIPLY,   // Key::Multiply
+			SDL_SCANCODE_KP_ENTER,      // Key::NumpadReturn
+			SDL_SCANCODE_KP_0,          // Key::Numpad0
+			SDL_SCANCODE_KP_1,          // Key::Numpad1
+			SDL_SCANCODE_KP_2,          // Key::Numpad2
+			SDL_SCANCODE_KP_3,          // Key::Numpad3
+			SDL_SCANCODE_KP_4,          // Key::Numpad4
+			SDL_SCANCODE_KP_5,          // Key::Numpad5
+			SDL_SCANCODE_KP_6,          // Key::Numpad6
+			SDL_SCANCODE_KP_7,          // Key::Numpad7
+			SDL_SCANCODE_KP_8,          // Key::Numpad8
+			SDL_SCANCODE_KP_9,          // Key::Numpad9
+			SDL_SCANCODE_KP_MINUS,      // Key::Subtract
+
+
+			// Diverss
+			SDL_SCANCODE_BACKSLASH,     // Key::Backslash
+			SDL_SCANCODE_BACKSPACE,     // Key::Backspace
+			SDL_SCANCODE_CLEAR,         // Key::Clear
+			SDL_SCANCODE_COMMA,         // Key::Comma,
+			SDL_SCANCODE_MINUS,         // Key::Dash
+			SDL_SCANCODE_DELETE,        // Key::Delete
+			SDL_SCANCODE_END,           // Key::End
+			SDL_SCANCODE_EQUALS,        // Key::Equal
+			SDL_SCANCODE_ESCAPE,        // Key::Escape
+			SDL_SCANCODE_HOME,          // Key::Home
+			SDL_SCANCODE_INSERT,        // Key::Insert
+			SDL_SCANCODE_LALT,          // Key::LAlt
+			SDL_SCANCODE_LEFTBRACKET,   // Key::LBracket
+			SDL_SCANCODE_LCTRL,         // Key::LControl
+			SDL_SCANCODE_LSHIFT,        // Key::LShift
+			SDL_SCANCODE_LGUI,          // Key::LSystem
+			SDL_SCANCODE_0,             // Key::Num0
+			SDL_SCANCODE_1,             // Key::Num1
+			SDL_SCANCODE_2,             // Key::Num2
+			SDL_SCANCODE_3,             // Key::Num3
+			SDL_SCANCODE_4,             // Key::Num4
+			SDL_SCANCODE_5,             // Key::Num5
+			SDL_SCANCODE_6,             // Key::Num6
+			SDL_SCANCODE_7,             // Key::Num7
+			SDL_SCANCODE_8,             // Key::Num8
+			SDL_SCANCODE_9,             // Key::Num9
+			SDL_SCANCODE_PAGEDOWN,      // Key::PageDown
+			SDL_SCANCODE_PAGEUP,        // Key::PageUp
+			SDL_SCANCODE_PAUSE,         // Key::Pause
+			SDL_SCANCODE_PERIOD,        // Key::Period
+			SDL_SCANCODE_SYSREQ,        // Key::Print
+			SDL_SCANCODE_PRINTSCREEN,   // Key::PrintScreen
+			SDL_SCANCODE_APOSTROPHE,    // Key::Quote
+			SDL_SCANCODE_RALT,          // Key::RAlt
+			SDL_SCANCODE_RIGHTBRACKET,  // Key::RBracket
+			SDL_SCANCODE_RCTRL,         // Key::RControl
+			SDL_SCANCODE_RETURN,        // Key::Return
+			SDL_SCANCODE_RSHIFT,        // Key::RShift
+			SDL_SCANCODE_RGUI,          // Key::RSystem
+			SDL_SCANCODE_SEMICOLON,     // Key::Semicolon
+			SDL_SCANCODE_SLASH,         // Key::Slash
+			SDL_SCANCODE_SPACE,         // Key::Space
+			SDL_SCANCODE_TAB,           // Key::Tab
+			SDL_SCANCODE_GRAVE,         // Key::Tilde
+			SDL_SCANCODE_APPLICATION,   // Key::Menu
+			SDL_SCANCODE_NONUSBACKSLASH,// Key::ISOBackslash102
+
+			// Touches navigateur
+			SDL_SCANCODE_AC_BACK,       // Key::Browser_Back
+			SDL_SCANCODE_AC_BOOKMARKS,  // Key::Browser_Favorites
+			SDL_SCANCODE_AC_FORWARD,    // Key::Browser_Forward
+			SDL_SCANCODE_AC_HOME,       // Key::Browser_Home
+			SDL_SCANCODE_AC_REFRESH,    // Key::Browser_Refresh
+			SDL_SCANCODE_AC_SEARCH,     // Key::Browser_Search
+			SDL_SCANCODE_AC_STOP,       // Key::Browser_Stop
+
+			// Touches de contrôle
+			SDL_SCANCODE_AUDIONEXT,     // Key::Media_Next,
+			SDL_SCANCODE_AUDIOPLAY,     // Key::Media_PlayPause,
+			SDL_SCANCODE_AUDIOPREV,     // Key::Media_Previous,
+			SDL_SCANCODE_AUDIOSTOP,     // Key::Media_Stop,
+
+			// Touches de contrôle du volume
+			SDL_SCANCODE_VOLUMEDOWN,    // Key::Volume_Down
+			SDL_SCANCODE_MUTE,          // Key::Volume_Mute
+			SDL_SCANCODE_VOLUMEUP,      // Key::Volume_Up
+
+			// Touches à verrouillage
+			SDL_SCANCODE_CAPSLOCK,      // Key::CapsLock
+			SDL_SCANCODE_NUMLOCKCLEAR,  // Key::NumLock
+			SDL_SCANCODE_SCROLLLOCK     // Key::ScrollLock
+		};
+	}
+
+	String EventImpl::GetKeyName(Keyboard::Key key)
+	{
+		auto scancode = nzKeyboardToSDLScanCode[key];
+
+		auto name = String::Unicode(SDL_GetKeyName(SDL_GetKeyFromScancode(scancode)));
+
+		if (name == "")
+			name = "\"" + String::Unicode(SDL_GetScancodeName(scancode)) + "\"";
+
+		return name == "\"\"" ? String::Unicode("Unknown") : name;
+	}
+
+	Vector2i EventImpl::GetMousePosition()
+	{
+		Vector2i pos;
+		SDL_GetGlobalMouseState(&pos.x, &pos.y);
+
+		return pos;
+	}
+
+	Vector2i EventImpl::GetMousePosition(const Window& relativeTo)
+	{
+		auto handle = relativeTo.GetHandle();
+		if (handle)
+		{
+			auto windowPos = relativeTo.GetPosition();
+			auto mousePos = GetMousePosition();
+
+			return mousePos - windowPos;
+		}
+		else
+		{
+			NazaraError("Invalid window handle");
+
+			// Attention que (-1, -1) est une position tout à fait valide et ne doit pas servir de test
+			return Vector2i(-1, -1);
+		}
+	}
+
+	bool EventImpl::IsKeyPressed(Keyboard::Key key)
+	{
+		return SDL_GetKeyboardState(nullptr)[nzKeyboardToSDLScanCode[key]];
+	}
+
+	bool EventImpl::IsMouseButtonPressed(Mouse::Button button)
+	{
+		static int vButtons[Mouse::Max + 1] = {
+			SDL_BUTTON_LMASK,    // Button::Left
+			SDL_BUTTON_MMASK,    // Button::Middle
+			SDL_BUTTON_RMASK,    // Button::Right
+			SDL_BUTTON_X1MASK,   // Button::XButton1
+			SDL_BUTTON_X2MASK    // Button::XButton2
+		};
+
+		return (SDL_GetGlobalMouseState(nullptr, nullptr) & vButtons[button]) != 0;
+	}
+
+	void EventImpl::SetMousePosition(int x, int y)
+	{
+		if (SDL_WarpMouseGlobal(x, y) != 0)
+			NazaraWarning(SDL_GetError());
+	}
+
+	void EventImpl::SetMousePosition(int x, int y, const Window& relativeTo)
+	{
+		auto handle = static_cast<SDL_Window*>(relativeTo.GetHandle());
+		if (handle)
+			SDL_WarpMouseInWindow(handle, x, y);
+		else
+			NazaraError("Invalid window handle");
+	}
+}

src/Nazara/Platform/SDL2/InputImpl.hpp

@@ -0,0 +1,30 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_INPUTIMPL_HPP
+#define NAZARA_INPUTIMPL_HPP
+
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Platform/Keyboard.hpp>
+#include <Nazara/Platform/Mouse.hpp>
+
+namespace Nz
+{
+	class EventImpl
+	{
+		public:
+			static String GetKeyName(Keyboard::Key key);
+			static Vector2i GetMousePosition();
+			static Vector2i GetMousePosition(const Window& relativeTo);
+			static bool IsKeyPressed(Keyboard::Key key);
+			static bool IsMouseButtonPressed(Mouse::Button button);
+			static void SetMousePosition(int x, int y);
+			static void SetMousePosition(int x, int y, const Window& relativeTo);
+	};
+}
+
+#endif // NAZARA_INPUTIMPL_HPP

src/Nazara/Platform/SDL2/VideoModeImpl.cpp

@@ -0,0 +1,51 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <algorithm>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Platform/Debug.hpp>
+#include <Nazara/Platform/SDL2/VideoModeImpl.hpp>
+#include <Nazara/Platform/VideoMode.hpp>
+#include <SDL2/SDL_video.h>
+
+namespace Nz
+{
+	VideoMode VideoModeImpl::GetDesktopMode()
+	{
+		SDL_DisplayMode mode;
+		if (SDL_GetDesktopDisplayMode(0, &mode) != 0) // handle multi screen ?
+		{
+			NazaraError(SDL_GetError());
+
+			return VideoMode(800, 600, static_cast<UInt8>(32)); // useless ?
+		}
+
+		return VideoMode(mode.w, mode.h, SDL_BITSPERPIXEL(mode.format));
+	}
+
+	void VideoModeImpl::GetFullscreenModes(std::vector<VideoMode>& modes)
+	{
+		SDL_DisplayMode mode;
+
+		int numModes = SDL_GetNumDisplayModes(0);
+		if (numModes < 0)
+		{
+			NazaraError(SDL_GetError());
+
+			return;
+		}
+
+		for (int i = 0; i < numModes; i++)
+		{
+			if (SDL_GetDisplayMode(0, i, &mode) != 0) // handle multi screen ?
+
+				NazaraError(SDL_GetError());
+
+			VideoMode vMode(mode.w, mode.h, SDL_BITSPERPIXEL(mode.format));
+
+			if (std::find(modes.begin(), modes.end(), vMode) == modes.end())
+				modes.push_back(vMode);
+		}
+	}
+}

src/Nazara/Platform/SDL2/VideoModeImpl.hpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_VIDEOMODEIMPL_HPP
+#define NAZARA_VIDEOMODEIMPL_HPP
+
+#include <Nazara/Platform/VideoMode.hpp>
+
+namespace Nz
+{
+	class VideoModeImpl
+	{
+		public:
+			static VideoMode GetDesktopMode();
+			static void GetFullscreenModes(std::vector<VideoMode>& modes);
+	};
+}
+
+#endif // NNAZARA_VIDEOMODEIMPL_HPP

src/Nazara/Platform/SDL2/WindowImpl.cpp

@@ -0,0 +1,695 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+// Un grand merci à Laurent Gomila pour la SFML qui m'aura bien aidé à réaliser cette implémentation
+
+#include <cstdio>
+#include <memory>
+#include <Nazara/Core/ConditionVariable.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Mutex.hpp>
+#include <Nazara/Core/Thread.hpp>
+#include <Nazara/Platform/Config.hpp>
+#include <Nazara/Platform/Cursor.hpp>
+#include <Nazara/Platform/Icon.hpp>
+#include <Nazara/Platform/SDL2/CursorImpl.hpp>
+#include <Nazara/Platform/SDL2/IconImpl.hpp>
+#include <Nazara/Platform/SDL2/WindowImpl.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <SDL2/SDL.h>
+
+namespace Nz
+{
+	namespace
+	{
+		WindowImpl* fullscreenWindow = nullptr;
+
+		Mouse::Button SDLToNazaraButton(Uint8 sdlButton)
+		{
+			switch (sdlButton)
+			{
+				case SDL_BUTTON_LEFT:
+					return Mouse::Left;
+				case SDL_BUTTON_MIDDLE:
+					return Mouse::Middle;
+				case SDL_BUTTON_RIGHT:
+					return Mouse::Right;
+				case SDL_BUTTON_X1:
+					return Mouse::XButton1;
+				case SDL_BUTTON_X2:
+					return Mouse::XButton2;
+				default:
+					NazaraAssert(false, "Unkown mouse button");
+					return Mouse::Left;
+			}
+		}
+	}
+
+	WindowImpl::WindowImpl(Window* parent) :
+		m_cursor(nullptr),
+		m_handle(nullptr),
+		//m_callback(0),
+		m_style(0),
+		m_maxSize(-1),
+		m_minSize(-1),
+		m_parent(parent),
+		m_keyRepeat(true),
+		m_mouseInside(false),
+		m_smoothScrolling(false),
+		m_scrolling(0)
+	{
+		m_cursor = SDL_GetDefaultCursor();
+	}
+
+	bool WindowImpl::Create(const VideoMode& mode, const String& title, WindowStyleFlags style)
+	{
+		bool async = (style & WindowStyle_Threaded) != 0;
+		if (async)
+		{
+			NazaraError("SDL2 backend doesn't support asyn window for now");
+
+			return false;
+		}
+
+
+		bool fullscreen = (style & WindowStyle_Fullscreen) != 0;
+
+		Uint32 winStyle = SDL_WINDOW_OPENGL;
+
+		unsigned int x, y;
+		unsigned int width = mode.width;
+		unsigned int height = mode.height;
+		if (fullscreen)
+			winStyle |= SDL_WINDOW_FULLSCREEN;
+
+		// Testé une seconde fois car sa valeur peut changer
+		if (fullscreen)
+		{
+			x = 0;
+			y = 0;
+
+			fullscreenWindow = this;
+		}
+		else
+		{
+			if (!(style & WindowStyle_Titlebar))
+				winStyle |= SDL_WINDOW_BORDERLESS;
+
+			x = SDL_WINDOWPOS_CENTERED;
+			y = SDL_WINDOWPOS_CENTERED;
+		}
+
+		if (style & WindowStyle_Resizable)
+			winStyle |= SDL_WINDOW_RESIZABLE;
+		if (style & WindowStyle_Max)
+			winStyle |= SDL_WINDOW_MAXIMIZED;
+
+		m_eventListener = true;
+		m_ownsWindow = true;
+		m_sizemove = false;
+		m_style = style;
+
+		m_handle = SDL_CreateWindow(title.GetConstBuffer(), x, y, width, height, winStyle);
+
+		if (!m_handle)
+		{
+			NazaraError("Failed to create window: " + Error::GetLastSystemError());
+			return false;
+		}
+
+		PrepareWindow(fullscreen);
+
+		SDL_AddEventWatch(HandleEvent, this);
+
+		return true;
+	}
+
+	bool WindowImpl::Create(WindowHandle handle)
+	{
+		m_handle = static_cast<SDL_Window*>(handle);
+
+		if (!m_handle || !SDL_GetWindowID(m_handle))
+		{
+			NazaraError("Invalid handle");
+			return false;
+		}
+
+		m_eventListener = false;
+		m_ownsWindow = false;
+		m_sizemove = false;
+
+		SDL_GetWindowPosition(m_handle, &m_position.x, &m_position.y);
+
+		int width;
+		int height;
+		SDL_GetWindowSize(m_handle, &width, &height);
+
+		m_size.Set(width, height);
+
+		SDL_AddEventWatch(HandleEvent, this);
+
+		return true;
+	}
+
+	void WindowImpl::Destroy()
+	{
+		if (m_ownsWindow && m_handle)
+			SDL_DestroyWindow(m_handle);
+		else
+			SetEventListener(false);
+
+		SDL_DelEventWatch(HandleEvent, this);
+	}
+
+	void WindowImpl::EnableKeyRepeat(bool enable)
+	{
+		m_keyRepeat = enable;
+	}
+
+	void WindowImpl::EnableSmoothScrolling(bool enable)
+	{
+		m_smoothScrolling = enable;
+	}
+
+	WindowHandle WindowImpl::GetHandle() const
+	{
+		return m_handle;
+	}
+
+	Vector2i WindowImpl::GetPosition() const
+	{
+		return m_position;
+	}
+
+	Vector2ui WindowImpl::GetSize() const
+	{
+		return m_size;
+	}
+
+	WindowStyleFlags WindowImpl::GetStyle() const
+	{
+		return m_style;
+	}
+
+	String WindowImpl::GetTitle() const
+	{
+		return String::Unicode(SDL_GetWindowTitle(m_handle));
+	}
+
+	bool WindowImpl::HasFocus() const
+	{
+		return (SDL_GetWindowFlags(m_handle) & SDL_WINDOW_INPUT_FOCUS) != 0;
+	}
+
+	void WindowImpl::IgnoreNextMouseEvent(int mouseX, int mouseY)
+	{
+		m_ignoreNextMouseMove = true;
+		// Petite astuce ... probablement foireuse dans certains cas :ahde:
+		m_mousePos.x = mouseX;
+		m_mousePos.y = mouseY;
+	}
+
+	bool WindowImpl::IsMinimized() const
+	{
+		return (SDL_GetWindowFlags(m_handle) & SDL_WINDOW_MINIMIZED) != 0;
+	}
+
+	bool WindowImpl::IsVisible() const
+	{
+		return (SDL_GetWindowFlags(m_handle) & SDL_WINDOW_SHOWN) != 0;
+	}
+
+	void WindowImpl::RefreshCursor()
+	{
+		if (!m_cursor)
+		{
+			if (SDL_ShowCursor(SDL_DISABLE) < 0)
+				NazaraWarning(SDL_GetError());
+		}
+		else
+		{
+			if (SDL_ShowCursor(SDL_ENABLE) < 0)
+				NazaraWarning(SDL_GetError());
+
+			SDL_SetCursor(m_cursor);
+		}
+	}
+
+	void WindowImpl::ProcessEvents(bool block)
+	{
+		SDL_PumpEvents();
+
+
+		/*if (m_ownsWindow)
+		   {
+		    if (block)
+		        WaitMessage();
+
+		    MSG message;
+		    while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE))
+		    {
+		        TranslateMessage(&message);
+		        DispatchMessageW(&message);
+		    }
+		   }*/
+	}
+
+	int SDLCALL WindowImpl::HandleEvent(void *userdata, SDL_Event* event)
+	{
+		try {
+			auto window = static_cast<WindowImpl*>(userdata);
+
+			WindowEvent evt;
+			evt.type = WindowEventType::WindowEventType_Max;
+
+			switch (event->type)
+			{
+				case SDL_WINDOWEVENT:
+					if (SDL_GetWindowID(window->m_handle) != event->window.windowID)
+						return 0;
+
+					switch (event->window.event)
+					{
+						case SDL_WINDOWEVENT_CLOSE:
+							evt.type = Nz::WindowEventType::WindowEventType_Quit;
+							break;
+						case SDL_WINDOWEVENT_RESIZED:
+							evt.type = Nz::WindowEventType::WindowEventType_Resized;
+
+							evt.size.width = event->window.data1;
+							evt.size.height = event->window.data2;
+
+							window->m_size.Set(event->window.data1, event->window.data2);
+
+							break;
+						case SDL_WINDOWEVENT_MOVED:
+							evt.type = Nz::WindowEventType::WindowEventType_Moved;
+
+							evt.position.x = event->window.data1;
+							evt.position.y = event->window.data2;
+
+							window->m_position.Set(event->window.data1, event->window.data2);
+
+							break;
+						case SDL_WINDOWEVENT_FOCUS_GAINED:
+							evt.type = Nz::WindowEventType::WindowEventType_GainedFocus;
+
+							break;
+						case SDL_WINDOWEVENT_FOCUS_LOST:
+							evt.type = Nz::WindowEventType::WindowEventType_LostFocus;
+
+							break;
+						case SDL_WINDOWEVENT_ENTER:
+							evt.type = Nz::WindowEventType::WindowEventType_MouseEntered;
+
+							break;
+						case SDL_WINDOWEVENT_LEAVE:
+							evt.type = Nz::WindowEventType::WindowEventType_MouseLeft;
+
+							break;
+					}
+					break;
+
+				case SDL_MOUSEMOTION:
+					if (SDL_GetWindowID(window->m_handle) != event->motion.windowID)
+						return 0;
+
+					if (window->m_ignoreNextMouseMove && event->motion.x == window->m_mousePos.x && event->motion.y == window->m_mousePos.y)
+					{
+						window->m_ignoreNextMouseMove = false;
+
+						return 0;
+					}
+
+					evt.type = Nz::WindowEventType::WindowEventType_MouseMoved;
+
+					evt.mouseMove.x = event->motion.x;
+					evt.mouseMove.y = event->motion.y;
+					evt.mouseMove.deltaX = event->motion.xrel;
+					evt.mouseMove.deltaY = event->motion.yrel;
+
+					break;
+
+				case SDL_MOUSEBUTTONDOWN:
+					if (SDL_GetWindowID(window->m_handle) != event->button.windowID)
+						return 0;
+
+					evt.mouseButton.button = SDLToNazaraButton(event->button.button);
+					evt.mouseButton.x = event->button.x;
+					evt.mouseButton.y = event->button.y;
+
+					if (event->button.clicks % 2 == 0)
+					{
+						evt.type = Nz::WindowEventType::WindowEventType_MouseButtonDoubleClicked;
+
+						window->m_parent->PushEvent(evt);
+					}
+
+					evt.type = Nz::WindowEventType::WindowEventType_MouseButtonPressed;
+
+					break;
+
+				case SDL_MOUSEBUTTONUP:
+					if (SDL_GetWindowID(window->m_handle) != event->button.windowID)
+						return 0;
+
+					evt.mouseButton.button = SDLToNazaraButton(event->button.button);
+					evt.mouseButton.x = event->button.x;
+					evt.mouseButton.y = event->button.y;
+
+					evt.type = Nz::WindowEventType::WindowEventType_MouseButtonReleased;
+
+					break;
+
+				case SDL_MOUSEWHEEL:
+					if (SDL_GetWindowID(window->m_handle) != event->wheel.windowID)
+						return 0;
+
+					evt.type = Nz::WindowEventType::WindowEventType_MouseWheelMoved;
+
+					evt.mouseWheel.delta = event->wheel.y;
+
+					break;
+
+				case SDL_KEYDOWN:
+					if (SDL_GetWindowID(window->m_handle) != event->key.windowID)
+						return 0;
+
+					evt.type = WindowEventType_KeyPressed;
+
+					evt.key.code = SDLKeySymToNazaraKey(event->key.keysym);
+					evt.key.alt = (event->key.keysym.mod & KMOD_ALT) != 0;
+					evt.key.control = (event->key.keysym.mod & KMOD_CTRL) != 0;
+					evt.key.repeated = event->key.repeat != 0;
+					evt.key.shift = (event->key.keysym.mod & KMOD_SHIFT) != 0;
+					evt.key.system = (event->key.keysym.mod & KMOD_GUI) != 0;
+
+					break;
+
+				case SDL_KEYUP:
+					if (SDL_GetWindowID(window->m_handle) != event->key.windowID)
+						return 0;
+
+					evt.type = WindowEventType_KeyReleased;
+
+					evt.key.code = SDLKeySymToNazaraKey(event->key.keysym);
+					evt.key.alt = (event->key.keysym.mod & KMOD_ALT) != 0;
+					evt.key.control = (event->key.keysym.mod & KMOD_CTRL) != 0;
+					evt.key.repeated = event->key.repeat != 0;
+					evt.key.shift = (event->key.keysym.mod & KMOD_SHIFT) != 0;
+					evt.key.system = (event->key.keysym.mod & KMOD_GUI) != 0;
+
+					break;
+
+				case SDL_TEXTINPUT:
+					if (SDL_GetWindowID(window->m_handle) != event->text.windowID)
+						return 0;
+
+					evt.type = WindowEventType_TextEntered;
+
+					for (decltype(evt.text.character)codepoint : String::Unicode(event->text.text).GetUtf32String())
+					{
+						evt.text.character = codepoint;
+
+						window->m_parent->PushEvent(evt);
+					}
+
+					// prevent post switch event
+					evt.type = WindowEventType::WindowEventType_Max;
+
+					break;
+			}
+
+			if (evt.type != WindowEventType::WindowEventType_Max)
+				window->m_parent->PushEvent(evt);
+		}
+		catch (std::exception e)
+		{
+			NazaraError(e.what());
+		}
+		catch (...)     // Don't let any exceptions go thru C calls
+		{
+			NazaraError("An unknown error happened");
+		}
+
+		return 0;
+	}
+
+	void WindowImpl::SetCursor(const Cursor& cursor)
+	{
+		m_cursor = cursor.m_impl->GetCursor();
+
+		if (HasFocus())
+			RefreshCursor();
+	}
+
+	void WindowImpl::SetEventListener(bool listener)
+	{
+
+	}
+
+	void WindowImpl::SetFocus()
+	{
+		SDL_RaiseWindow(m_handle);
+	}
+
+	void WindowImpl::SetIcon(const Icon& icon)
+	{
+		SDL_SetWindowIcon(m_handle, icon.m_impl->GetIcon());
+	}
+
+	void WindowImpl::SetMaximumSize(int width, int height)
+	{
+		SDL_SetWindowMaximumSize(m_handle, width, height);
+	}
+
+	void WindowImpl::SetMinimumSize(int width, int height)
+	{
+		SDL_SetWindowMinimumSize(m_handle, width, height);
+	}
+
+	void WindowImpl::SetPosition(int x, int y)
+	{
+		SDL_SetWindowPosition(m_handle, x, y);
+	}
+
+	void WindowImpl::SetSize(unsigned int width, unsigned int height)
+	{
+		m_size.Set(width, height);
+		SDL_SetWindowSize(m_handle, width, height);
+	}
+
+	void WindowImpl::SetStayOnTop(bool stayOnTop)
+	{
+		NazaraDebug("Stay on top isn't supported by SDL2 backend for now");
+	}
+
+	void WindowImpl::SetTitle(const String& title)
+	{
+		SDL_SetWindowTitle(m_handle, title.GetConstBuffer());
+	}
+
+	void WindowImpl::SetVisible(bool visible)
+	{
+		visible ? SDL_ShowWindow(m_handle) : SDL_HideWindow(m_handle);
+	}
+
+	void WindowImpl::PrepareWindow(bool fullscreen)
+	{
+		(void)fullscreen;     // ignore param warning
+
+		SDL_GetWindowPosition(m_handle, &m_position.x, &m_position.y);
+
+		int width, height;
+		SDL_GetWindowSize(m_handle, &width, &height);
+
+		m_size.Set(width, height);
+	}
+
+	bool WindowImpl::Initialize()
+	{
+		if (SDL_Init(SDL_INIT_VIDEO) < 0)
+		{
+			NazaraError(SDL_GetError());
+			return false;
+		}
+		if (SDL_GL_LoadLibrary(nullptr) < 0)
+		{
+			NazaraError(SDL_GetError());
+
+			SDL_Quit();
+			return false;
+		}
+
+		if (SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, true) < 0)
+			NazaraError("Couldn't set share OpenGL contexes");
+
+		return true;
+	}
+
+	void WindowImpl::Uninitialize()
+	{
+		SDL_Quit();
+	}
+
+	Keyboard::Key WindowImpl::SDLKeySymToNazaraKey(SDL_Keysym& keysym)
+	{
+		auto key = keysym.scancode;
+
+		switch (key)
+		{
+			case SDL_SCANCODE_LCTRL:           return Keyboard::LControl;
+			case SDL_SCANCODE_RCTRL:           return Keyboard::RControl;
+			case SDL_SCANCODE_LALT:            return Keyboard::LAlt;
+			case SDL_SCANCODE_RALT:            return Keyboard::RAlt;
+			case SDL_SCANCODE_LSHIFT:          return Keyboard::LShift;
+			case SDL_SCANCODE_RSHIFT:          return Keyboard::RShift;
+
+			case SDL_SCANCODE_0:               return Keyboard::Num0;
+			case SDL_SCANCODE_1:               return Keyboard::Num1;
+			case SDL_SCANCODE_2:               return Keyboard::Num2;
+			case SDL_SCANCODE_3:               return Keyboard::Num3;
+			case SDL_SCANCODE_4:               return Keyboard::Num4;
+			case SDL_SCANCODE_5:               return Keyboard::Num5;
+			case SDL_SCANCODE_6:               return Keyboard::Num6;
+			case SDL_SCANCODE_7:               return Keyboard::Num7;
+			case SDL_SCANCODE_8:               return Keyboard::Num8;
+			case SDL_SCANCODE_9:               return Keyboard::Num9;
+			case SDL_SCANCODE_A:               return Keyboard::A;
+			case SDL_SCANCODE_B:               return Keyboard::B;
+			case SDL_SCANCODE_C:               return Keyboard::C;
+			case SDL_SCANCODE_D:               return Keyboard::D;
+			case SDL_SCANCODE_E:               return Keyboard::E;
+			case SDL_SCANCODE_F:               return Keyboard::F;
+			case SDL_SCANCODE_G:               return Keyboard::G;
+			case SDL_SCANCODE_H:               return Keyboard::H;
+			case SDL_SCANCODE_I:               return Keyboard::I;
+			case SDL_SCANCODE_J:               return Keyboard::J;
+			case SDL_SCANCODE_K:               return Keyboard::K;
+			case SDL_SCANCODE_L:               return Keyboard::L;
+			case SDL_SCANCODE_M:               return Keyboard::M;
+			case SDL_SCANCODE_N:               return Keyboard::N;
+			case SDL_SCANCODE_O:               return Keyboard::O;
+			case SDL_SCANCODE_P:               return Keyboard::P;
+			case SDL_SCANCODE_Q:               return Keyboard::Q;
+			case SDL_SCANCODE_R:               return Keyboard::R;
+			case SDL_SCANCODE_S:               return Keyboard::S;
+			case SDL_SCANCODE_T:               return Keyboard::T;
+			case SDL_SCANCODE_U:               return Keyboard::U;
+			case SDL_SCANCODE_V:               return Keyboard::V;
+			case SDL_SCANCODE_W:               return Keyboard::W;
+			case SDL_SCANCODE_X:               return Keyboard::X;
+			case SDL_SCANCODE_Y:               return Keyboard::Y;
+			case SDL_SCANCODE_Z:               return Keyboard::Z;
+			case SDL_SCANCODE_KP_PLUS:         return Keyboard::Add;
+			case SDL_SCANCODE_BACKSPACE:       return Keyboard::Backspace;
+			case SDL_SCANCODE_AC_BACK:         return Keyboard::Browser_Back;
+			case SDL_SCANCODE_AC_BOOKMARKS:    return Keyboard::Browser_Favorites;
+			case SDL_SCANCODE_AC_FORWARD:      return Keyboard::Browser_Forward;
+			case SDL_SCANCODE_AC_HOME:         return Keyboard::Browser_Home;
+			case SDL_SCANCODE_AC_REFRESH:      return Keyboard::Browser_Refresh;
+			case SDL_SCANCODE_AC_SEARCH:       return Keyboard::Browser_Search;
+			case SDL_SCANCODE_AC_STOP:         return Keyboard::Browser_Stop;
+			case SDL_SCANCODE_CAPSLOCK:        return Keyboard::CapsLock;
+			case SDL_SCANCODE_CLEAR:             return Keyboard::Clear;
+			case SDL_SCANCODE_KP_PERIOD:         return Keyboard::Decimal;
+			case SDL_SCANCODE_DELETE:            return Keyboard::Delete;
+			case SDL_SCANCODE_KP_DIVIDE:         return Keyboard::Divide;
+			case SDL_SCANCODE_DOWN:              return Keyboard::Down;
+			case SDL_SCANCODE_END:               return Keyboard::End;
+			case SDL_SCANCODE_ESCAPE:            return Keyboard::Escape;
+			case SDL_SCANCODE_F1:                return Keyboard::F1;
+			case SDL_SCANCODE_F2:                return Keyboard::F2;
+			case SDL_SCANCODE_F3:                return Keyboard::F3;
+			case SDL_SCANCODE_F4:                return Keyboard::F4;
+			case SDL_SCANCODE_F5:                return Keyboard::F5;
+			case SDL_SCANCODE_F6:                return Keyboard::F6;
+			case SDL_SCANCODE_F7:                return Keyboard::F7;
+			case SDL_SCANCODE_F8:                return Keyboard::F8;
+			case SDL_SCANCODE_F9:                return Keyboard::F9;
+			case SDL_SCANCODE_F10:               return Keyboard::F10;
+			case SDL_SCANCODE_F11:               return Keyboard::F11;
+			case SDL_SCANCODE_F12:               return Keyboard::F12;
+			case SDL_SCANCODE_F13:               return Keyboard::F13;
+			case SDL_SCANCODE_F14:               return Keyboard::F14;
+			case SDL_SCANCODE_F15:               return Keyboard::F15;
+			case SDL_SCANCODE_HOME:              return Keyboard::Home;
+			case SDL_SCANCODE_INSERT:            return Keyboard::Insert;
+			case SDL_SCANCODE_LEFT:              return Keyboard::Left;
+			case SDL_SCANCODE_LGUI:              return Keyboard::LSystem;
+			case SDL_SCANCODE_AUDIONEXT:         return Keyboard::Media_Next;
+			case SDL_SCANCODE_AUDIOPLAY:         return Keyboard::Media_Play;
+			case SDL_SCANCODE_AUDIOPREV:         return Keyboard::Media_Previous;
+			case SDL_SCANCODE_AUDIOSTOP:         return Keyboard::Media_Stop;
+			case SDL_SCANCODE_KP_MULTIPLY:       return Keyboard::Multiply;
+			case SDL_SCANCODE_PAGEDOWN:          return Keyboard::PageDown;
+			case SDL_SCANCODE_KP_0:              return Keyboard::Numpad0;
+			case SDL_SCANCODE_KP_1:              return Keyboard::Numpad1;
+			case SDL_SCANCODE_KP_2:              return Keyboard::Numpad2;
+			case SDL_SCANCODE_KP_3:              return Keyboard::Numpad3;
+			case SDL_SCANCODE_KP_4:              return Keyboard::Numpad4;
+			case SDL_SCANCODE_KP_5:              return Keyboard::Numpad5;
+			case SDL_SCANCODE_KP_6:              return Keyboard::Numpad6;
+			case SDL_SCANCODE_KP_7:              return Keyboard::Numpad7;
+			case SDL_SCANCODE_KP_8:              return Keyboard::Numpad8;
+			case SDL_SCANCODE_KP_9:              return Keyboard::Numpad9;
+			case SDL_SCANCODE_NUMLOCKCLEAR:      return Keyboard::NumLock;
+			case SDL_SCANCODE_SEMICOLON:         return Keyboard::Semicolon;
+			case SDL_SCANCODE_SLASH:             return Keyboard::Slash;
+			case SDL_SCANCODE_GRAVE:             return Keyboard::Tilde;
+			case SDL_SCANCODE_APPLICATION:       return Keyboard::Menu;
+			case SDL_SCANCODE_NONUSBACKSLASH:    return Keyboard::ISOBackslash102;
+			case SDL_SCANCODE_LEFTBRACKET:       return Keyboard::LBracket;
+			case SDL_SCANCODE_BACKSLASH:         return Keyboard::Backslash;
+			case SDL_SCANCODE_RIGHTBRACKET:      return Keyboard::RBracket;
+			case SDL_SCANCODE_APOSTROPHE:        return Keyboard::Quote;
+			case SDL_SCANCODE_COMMA:             return Keyboard::Comma;
+			case SDL_SCANCODE_MINUS:             return Keyboard::Dash;
+			case SDL_SCANCODE_PERIOD:            return Keyboard::Period;
+			case SDL_SCANCODE_EQUALS:            return Keyboard::Equal;
+			case SDL_SCANCODE_RIGHT:             return Keyboard::Right;
+			case SDL_SCANCODE_PAGEUP:            return Keyboard::PageUp;
+			case SDL_SCANCODE_PAUSE:             return Keyboard::Pause;
+			case SDL_SCANCODE_SYSREQ:            return Keyboard::Print;
+			case SDL_SCANCODE_SCROLLLOCK:        return Keyboard::ScrollLock;
+			case SDL_SCANCODE_PRINTSCREEN:       return Keyboard::PrintScreen;
+			case SDL_SCANCODE_KP_MINUS:          return Keyboard::Subtract;
+			case SDL_SCANCODE_RETURN:            return Keyboard::Return;
+			case SDL_SCANCODE_KP_ENTER:          return Keyboard::NumpadReturn;
+			case SDL_SCANCODE_RGUI:              return Keyboard::RSystem;
+			case SDL_SCANCODE_SPACE:             return Keyboard::Space;
+			case SDL_SCANCODE_TAB:               return Keyboard::Tab;
+			case SDL_SCANCODE_UP:                return Keyboard::Up;
+			case SDL_SCANCODE_VOLUMEDOWN:        return Keyboard::Volume_Down;
+			case SDL_SCANCODE_MUTE:              return Keyboard::Volume_Mute;
+			case SDL_SCANCODE_AUDIOMUTE:         return Keyboard::Volume_Mute;
+			case SDL_SCANCODE_VOLUMEUP:          return Keyboard::Volume_Up;
+
+			default:
+				return Keyboard::Undefined;
+		}
+	}
+
+	// not implemented for now, wait for mainloop friendly input
+	//void WindowImpl::WindowThread(SDL_Window* handle, /*DWORD styleEx,*/ const String& title, /*DWORD style,*/ bool fullscreen, const Rectui& dimensions, WindowImpl* window, Mutex* mutex, ConditionVariable* condition)
+	//{
+	//	SDL_Window& winHandle = *handle;
+	/*winHandle = CreateWindowExW(styleEx, className, title.GetWideString().data(), style, dimensions.x, dimensions.y, dimensions.width, dimensions.height, nullptr, nullptr, GetModuleHandle(nullptr), window);
+
+	   if (winHandle)
+	    window->PrepareWindow(fullscreen);
+
+	   mutex->Lock();
+	   condition->Signal();
+	   mutex->Unlock(); // mutex and condition may be destroyed after this line
+
+	   if (!winHandle)
+	    return;
+
+	   while (window->m_threadActive)
+	    window->ProcessEvents(true);
+
+	   DestroyWindow(winHandle);*/
+	//}
+}

src/Nazara/Platform/SDL2/WindowImpl.hpp

@@ -0,0 +1,113 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Platform module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+// Interface inspirée de la SFML par Laurent Gomila
+
+#pragma once
+
+#ifndef NAZARA_WINDOWIMPL_HPP
+#define NAZARA_WINDOWIMPL_HPP
+
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Core/Thread.hpp>
+#include <Nazara/Math/Rect.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Platform/Config.hpp>
+#include <Nazara/Platform/Keyboard.hpp>
+#include <Nazara/Platform/Mouse.hpp>
+#include <Nazara/Platform/VideoMode.hpp>
+#include <Nazara/Platform/Window.hpp>
+#include <Nazara/Prerequisites.hpp>
+#include <SDL2/SDL_events.h>
+#include <SDL2/SDL_keyboard.h>
+#include <SDL2/SDL_video.h>
+
+namespace Nz
+{
+	class ConditionVariable;
+	class Mutex;
+	class Window;
+
+	class WindowImpl
+	{
+		public:
+			WindowImpl(Window* parent);
+			WindowImpl(const WindowImpl&) = delete;
+			WindowImpl(WindowImpl&&) = delete; ///TODO?
+			~WindowImpl() = default;
+
+			bool Create(const VideoMode& mode, const String& title, WindowStyleFlags style);
+			bool Create(WindowHandle handle);
+
+			void Destroy();
+
+			void EnableKeyRepeat(bool enable);
+			void EnableSmoothScrolling(bool enable);
+
+			WindowHandle GetHandle() const;
+			Vector2i GetPosition() const;
+			Vector2ui GetSize() const;
+			WindowStyleFlags GetStyle() const;
+			String GetTitle() const;
+
+			bool HasFocus() const;
+
+			void IgnoreNextMouseEvent(int mouseX, int mouseY);
+
+			bool IsMinimized() const;
+			bool IsVisible() const;
+
+			void RefreshCursor();
+
+			void ProcessEvents(bool block);
+
+			void SetCursor(const Cursor& cursor);
+			void SetEventListener(bool listener);
+			void SetFocus();
+			void SetIcon(const Icon& icon);
+			void SetMaximumSize(int width, int height);
+			void SetMinimumSize(int width, int height);
+			void SetPosition(int x, int y);
+			void SetSize(unsigned int width, unsigned int height);
+			void SetStayOnTop(bool stayOnTop);
+			void SetTitle(const String& title);
+			void SetVisible(bool visible);
+
+			WindowImpl& operator=(const WindowImpl&) = delete;
+			WindowImpl& operator=(WindowImpl&&) = delete; ///TODO?
+
+			static bool Initialize();
+			static void Uninitialize();
+
+		private:
+			int static SDLCALL HandleEvent(void *userdata, SDL_Event * event);
+
+			void PrepareWindow(bool fullscreen);
+
+			static Keyboard::Key SDLKeySymToNazaraKey(SDL_Keysym& keysym);
+			//static void WindowThread(SDL_Window* handle, /*DWORD styleEx,*/ const String& title, /*DWORD style,*/ bool fullscreen, const Rectui& dimensions, WindowImpl* window, Mutex* mutex, ConditionVariable* condition);
+
+			SDL_Cursor* m_cursor;
+			SDL_Window* m_handle;
+			WindowStyleFlags m_style;
+			Vector2i m_maxSize;
+			Vector2i m_minSize;
+			Vector2i m_mousePos;
+			Vector2i m_position;
+			Vector2ui m_size;
+			//Thread m_thread;
+			Window* m_parent;
+			bool m_eventListener;
+			bool m_ignoreNextMouseMove = false;
+			bool m_keyRepeat;
+			bool m_mouseInside;
+			bool m_ownsWindow;
+			bool m_sizemove;
+			bool m_smoothScrolling;
+			bool m_threadActive;
+			short m_scrolling;
+	};
+}
+
+#endif // NAZARA_WINDOWIMPL_HPP

src/Nazara/Platform/VideoMode.cpp

@@ -6,7 +6,9 @@
 #include <algorithm>
 #include <functional>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/VideoModeImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/VideoModeImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/VideoModeImpl.hpp>

src/Nazara/Platform/Win32/InputImpl.cpp

@@ -2,11 +2,11 @@
 // This file is part of the "Nazara Engine - Platform module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Platform/Win32/InputImpl.hpp>
 #include <Nazara/Core/Error.hpp>
+#include <Nazara/Platform/Debug.hpp>
+#include <Nazara/Platform/Win32/InputImpl.hpp>
 #include <Nazara/Platform/Window.hpp>
 #include <windows.h>
-#include <Nazara/Platform/Debug.hpp>
 
 namespace Nz
 {
@@ -69,6 +69,7 @@ namespace Nz
 			VK_DECIMAL,  // Key::Decimal
 			VK_DIVIDE,   // Key::Divide
 			VK_MULTIPLY, // Key::Multiply
+			VK_RETURN,   // Key::Multiply
 			VK_NUMPAD0,  // Key::Numpad0
 			VK_NUMPAD1,  // Key::Numpad1
 			VK_NUMPAD2,  // Key::Numpad2
@@ -126,6 +127,8 @@ namespace Nz
 			VK_SPACE,      // Key::Space
 			VK_TAB,        // Key::Tab
 			VK_OEM_3,      // Key::Tilde
+			VK_APPS,       // Key::Menu
+			VK_OEM_102,    // Key::ISOBackslash102
 
 			// Touches navigateur
 			VK_BROWSER_BACK,      // Key::Browser_Back
@@ -192,6 +195,7 @@ namespace Nz
 			case VK_RIGHT:
 			case VK_RWIN:
 			case VK_UP:
+			case VK_RETURN: // TODO check
 				code |= 0x1000000; // 24ème bit pour l'extension
 				break;
 		}
@@ -257,7 +261,6 @@ namespace Nz
 
 		// Gestion de l'inversement des boutons de la souris
 		if (GetSystemMetrics(SM_SWAPBUTTON))
-		{
 			switch (button)
 			{
 				case Mouse::Left:
@@ -271,7 +274,6 @@ namespace Nz
 				default:
 					break;
 			}
-		}
 
 		return (GetAsyncKeyState(vButtons[button]) & 0x8000) != 0;
 	}

src/Nazara/Platform/Win32/WindowImpl.cpp

@@ -4,21 +4,21 @@
 
 // Un grand merci à Laurent Gomila pour la SFML qui m'aura bien aidé à réaliser cette implémentation
 
-#include <Nazara/Platform/Win32/WindowImpl.hpp>
+#include <cstdio>
+#include <memory>
 #include <Nazara/Core/ConditionVariable.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Mutex.hpp>
 #include <Nazara/Core/Thread.hpp>
 #include <Nazara/Platform/Config.hpp>
 #include <Nazara/Platform/Cursor.hpp>
+#include <Nazara/Platform/Debug.hpp>
 #include <Nazara/Platform/Icon.hpp>
 #include <Nazara/Platform/Win32/CursorImpl.hpp>
 #include <Nazara/Platform/Win32/IconImpl.hpp>
+#include <Nazara/Platform/Win32/WindowImpl.hpp>
 #include <Nazara/Utility/Image.hpp>
-#include <cstdio>
-#include <memory>
 #include <windowsx.h>
-#include <Nazara/Platform/Debug.hpp>
 
 #ifdef _WIN64
 	#define GCL_HCURSOR GCLP_HCURSOR
@@ -194,12 +194,9 @@ namespace Nz
 					m_thread.Join();
 				}
 			}
-			else
+			else if (m_handle)
-			{
-				if (m_handle)
 				DestroyWindow(m_handle);
 		}
-		}
 		else
 			SetEventListener(false);
 	}
@@ -438,7 +435,6 @@ namespace Nz
 		}
 
 		if (m_eventListener)
-		{
 			switch (message)
 			{
 				case WM_CHAR:
@@ -903,7 +899,6 @@ namespace Nz
 				default:
 					break;
 			}
-		}
 
 		#if NAZARA_PLATFORM_WINDOWS_DISABLE_MENU_KEYS
 		// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646360(v=vs.85).aspx
@@ -961,6 +956,7 @@ namespace Nz
 		{
 			case VK_CONTROL:    return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::RControl : Keyboard::LControl;
 			case VK_MENU:       return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::RAlt : Keyboard::LAlt;
+			case VK_RETURN:     return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::NumpadReturn : Keyboard::Return; // TODO Check
 			case VK_SHIFT:
 			{
 				static UINT scancode = MapVirtualKey(VK_SHIFT, MAPVK_VK_TO_VSC);
@@ -1059,6 +1055,8 @@ namespace Nz
 			case VK_OEM_1:             return Keyboard::Semicolon;
 			case VK_OEM_2:             return Keyboard::Slash;
 			case VK_OEM_3:             return Keyboard::Tilde;
+			case VK_APPS:              return Keyboard::Menu;
+			case VK_OEM_102:           return Keyboard::ISOBackslash102;
 			case VK_OEM_4:             return Keyboard::LBracket;
 			case VK_OEM_5:             return Keyboard::Backslash;
 			case VK_OEM_6:             return Keyboard::RBracket;
@@ -1074,7 +1072,6 @@ namespace Nz
 			case VK_SCROLL:            return Keyboard::ScrollLock;
 			case VK_SNAPSHOT:          return Keyboard::PrintScreen;
 			case VK_SUBTRACT:          return Keyboard::Subtract;
-			case VK_RETURN:            return Keyboard::Return;
 			case VK_RWIN:              return Keyboard::RSystem;
 			case VK_SPACE:             return Keyboard::Space;
 			case VK_TAB:               return Keyboard::Tab;
@@ -1137,10 +1134,8 @@ namespace Nz
 
 		RECT rect;
 		if (GetWindowRect(handle, &rect))
-		{
 			if (static_cast<DWORD>(rect.right - rect.left) == mode.dmPelsWidth && static_cast<DWORD>(rect.bottom - rect.top) == mode.dmPelsHeight)
 				style |= WindowStyle_Fullscreen;
-		}
 
 		return style;
 	}

src/Nazara/Platform/Window.cpp

@@ -9,7 +9,9 @@
 #include <Nazara/Platform/Cursor.hpp>
 #include <Nazara/Platform/Icon.hpp>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Platform/SDL2/WindowImpl.hpp>
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Platform/Win32/WindowImpl.hpp>
 #elif defined(NAZARA_PLATFORM_X11)
 	#include <Nazara/Platform/X11/WindowImpl.hpp>

src/Nazara/Platform/X11/InputImpl.cpp

@@ -79,6 +79,7 @@ namespace Nz
 				case Keyboard::Decimal: keysym = XK_KP_Decimal; break;
 				case Keyboard::Divide: keysym = XK_KP_Divide; break;
 				case Keyboard::Multiply: keysym = XK_KP_Multiply; break;
+				case Keyboard::NumpadReturn: keysym = XK_KP_Enter; break;
 				case Keyboard::Numpad0: keysym = XK_KP_0; break;
 				case Keyboard::Numpad1: keysym = XK_KP_1; break;
 				case Keyboard::Numpad2: keysym = XK_KP_2; break;
@@ -136,6 +137,8 @@ namespace Nz
 				case Keyboard::Space: keysym = XK_space; break;
 				case Keyboard::Tab: keysym = XK_Tab; break;
 				case Keyboard::Tilde: keysym = XK_grave; break;
+				case Keyboard::Menu: keysym = XK_Menu; break;
+				case Keyboard::ISOBackslash102: keysym = XK_less; break;
 
 				// Touches navigateur
 				case Keyboard::Browser_Back: keysym = XF86XK_Back; break;

src/Nazara/Platform/X11/WindowImpl.cpp

@@ -4,10 +4,10 @@
 
 // Un grand merci à Laurent Gomila pour la SFML qui m'aura bien aidé à réaliser cette implémentation
 
-#include <Nazara/Platform/X11/WindowImpl.hpp>
 #include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Platform/Cursor.hpp>
+#include <Nazara/Platform/Debug.hpp>
 #include <Nazara/Platform/Event.hpp>
 #include <Nazara/Platform/Icon.hpp>
 #include <Nazara/Platform/VideoMode.hpp>
@@ -15,11 +15,11 @@
 #include <Nazara/Platform/X11/CursorImpl.hpp>
 #include <Nazara/Platform/X11/Display.hpp>
 #include <Nazara/Platform/X11/IconImpl.hpp>
+#include <Nazara/Platform/X11/WindowImpl.hpp>
+#include <xcb/xcb_keysyms.h>
 #include <X11/keysym.h>
 #include <X11/XF86keysym.h>
 #include <X11/Xutil.h>
-#include <xcb/xcb_keysyms.h>
-#include <Nazara/Platform/Debug.hpp>
 
 /*
     Things to do left:
@@ -237,13 +237,11 @@ namespace Nz
 		if (m_ownsWindow)
 		{
 			if (m_style & WindowStyle_Threaded)
-			{
 				if (m_thread.IsJoinable())
 				{
 					m_threadActive = false;
 					m_thread.Join();
 				}
-			}
 
 			// Destroy the window
 			if (m_window && m_ownsWindow)
@@ -341,7 +339,7 @@ namespace Nz
 		if (error)
 			NazaraError("Failed to check if window has focus");
 
-		return (reply->focus == m_window);
+		return reply->focus == m_window;
 	}
 
 	void WindowImpl::IgnoreNextMouseEvent(int mouseX, int mouseY)
@@ -659,9 +657,7 @@ namespace Nz
 			    )
 				NazaraError("Failed to change window visibility to visible");
 		}
-		else
+		else if (!X11::CheckCookie(
-		{
-			if (!X11::CheckCookie(
 					 connection,
 					 xcb_unmap_window(
 						 connection,
@@ -669,7 +665,6 @@ namespace Nz
 						 ))
 		         )
 			NazaraError("Failed to change window visibility to invisible");
-		}
 
 		xcb_flush(connection);
 	}
@@ -852,7 +847,7 @@ namespace Nz
 		case XK_KP_Home: return Keyboard::Numpad7;
 		case XK_KP_Up: return Keyboard::Numpad8;
 		case XK_KP_Page_Up: return Keyboard::Numpad9;
-			case XK_KP_Enter: return Keyboard::Return;
+		case XK_KP_Enter: return Keyboard::NumpadReturn;
 		case XK_KP_Subtract: return Keyboard::Subtract;
 
 		// Divers
@@ -900,6 +895,8 @@ namespace Nz
 		case XK_space: return Keyboard::Space;
 		case XK_Tab: return Keyboard::Tab;
 		case XK_grave: return Keyboard::Tilde;
+		case XK_Menu: return Keyboard::Menu;
+		case XK_less: return Keyboard::ISOBackslash102;
 
 		// Touches navigateur
 		case XF86XK_Back: return Keyboard::Browser_Back;

src/Nazara/Renderer/Context.cpp

@@ -12,7 +12,10 @@
 #include <memory>
 #include <vector>
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+	#include <Nazara/Renderer/SDL2/ContextImpl.hpp>
+	#define CALLBACK
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Renderer/Win32/ContextImpl.hpp>
 #elif defined(NAZARA_PLATFORM_GLX)
 	#include <Nazara/Renderer/GLX/ContextImpl.hpp>

src/Nazara/Renderer/OpenGL.cpp

@@ -2,21 +2,23 @@
 // This file is part of the "Nazara Engine - Renderer module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Renderer/Context.hpp>
+#include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/RenderTarget.hpp>
-#if defined(NAZARA_PLATFORM_GLX)
+#if defined(NAZARA_PLATFORM_SDL2)
+#include <SDL2/SDL_video.h>
+#elif defined(NAZARA_PLATFORM_GLX)
 #include <Nazara/Platform/X11/Display.hpp>
 #endif // NAZARA_PLATFORM_GLX
+#include <Nazara/Renderer/Debug.hpp>
 #include <set>
 #include <sstream>
 #include <stdexcept>
 #include <unordered_map>
-#include <Nazara/Renderer/Debug.hpp>
 
 namespace Nz
 {
@@ -28,7 +30,9 @@ namespace Nz
 
 		OpenGLFunc LoadEntry(const char* name, bool launchException = true)
 		{
-			#if defined(NAZARA_PLATFORM_WINDOWS)
+			#if defined(NAZARA_PLATFORM_SDL2)
+			OpenGLFunc entry = reinterpret_cast<OpenGLFunc>(SDL_GL_GetProcAddress(name));
+			#elif defined(NAZARA_PLATFORM_WINDOWS)
 			OpenGLFunc entry = reinterpret_cast<OpenGLFunc>(wglGetProcAddress(name));
 			if (!entry) // wglGetProcAddress ne fonctionne pas sur les fonctions OpenGL <= 1.1
 				entry = reinterpret_cast<OpenGLFunc>(GetProcAddress(openGLlibrary, name));
@@ -51,7 +55,16 @@ namespace Nz
 
 		bool LoadLibrary()
 		{
-			#ifdef NAZARA_PLATFORM_WINDOWS
+			#if defined(NAZARA_PLATFORM_SDL2)
+			if (SDL_GL_LoadLibrary(nullptr) != 0)
+			{
+				NazaraError(SDL_GetError());
+
+				return false;
+			}
+			return true;
+
+			#elif defined(NAZARA_PLATFORM_WINDOWS)
 			openGLlibrary = ::LoadLibraryA("opengl32.dll");
 
 			return openGLlibrary != nullptr;
@@ -62,7 +75,9 @@ namespace Nz
 
 		void UnloadLibrary()
 		{
-			#ifdef NAZARA_PLATFORM_WINDOWS
+			#if defined(NAZARA_PLATFORM_SDL2)
+			SDL_GL_UnloadLibrary();
+			#elif defined(NAZARA_PLATFORM_WINDOWS)
 			FreeLibrary(openGLlibrary);
 			#endif
 		}
@@ -158,7 +173,6 @@ namespace Nz
 
 		// Les fonctions de blend n'a aucun intérêt sans blending
 		if (states.blending)
-		{
 			if (currentRenderStates.dstBlend != states.dstBlend ||
 			    currentRenderStates.srcBlend != states.srcBlend)
 			{
@@ -166,7 +180,6 @@ namespace Nz
 				currentRenderStates.dstBlend = states.dstBlend;
 				currentRenderStates.srcBlend = states.srcBlend;
 			}
-		}
 
 		if (states.depthBuffer)
 		{
@@ -187,13 +200,11 @@ namespace Nz
 
 		// Inutile de changer le mode de face culling s'il n'est pas actif
 		if (states.faceCulling)
-		{
 			if (currentRenderStates.cullingSide != states.cullingSide)
 			{
 				glCullFace(FaceSide[states.cullingSide]);
 				currentRenderStates.cullingSide = states.cullingSide;
 			}
-		}
 
 		if (currentRenderStates.faceFilling != states.faceFilling)
 		{
@@ -731,7 +742,10 @@ namespace Nz
 		if (s_initialized)
 			return true;
 
-		#if defined(NAZARA_PLATFORM_GLX)
+
+		#if defined(NAZARA_PLATFORM_SDL2)
+
+		#elif defined(NAZARA_PLATFORM_GLX)
 		Initializer<X11> display;
 		if (!display)
 		{
@@ -768,7 +782,7 @@ namespace Nz
 		/****************************Chargement OpenGL****************************/
 
 		///FIXME: I'm really thinking this is a mistake and GLX has no need to be initialized differently (Lynix)
-		#if defined(NAZARA_PLATFORM_LINUX)
+		#if defined(NAZARA_PLATFORM_LINUX) && not defined(NAZARA_PLATFORM_SDL2)
 		glXCreateContextAttribs = reinterpret_cast<GLX::PFNGLXCREATECONTEXTATTRIBSARBPROC>(LoadEntry("glXCreateContextAttribsARB", false));
 		#endif
 
@@ -779,7 +793,7 @@ namespace Nz
 			return false;
 		}
 
-		#if defined(NAZARA_PLATFORM_WINDOWS)
+		#if defined(NAZARA_PLATFORM_WINDOWS) && not defined(NAZARA_PLATFORM_SDL2)
 		wglCreateContextAttribs = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(LoadEntry("wglCreateContextAttribsARB", false));
 		wglChoosePixelFormat = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(LoadEntry("wglChoosePixelFormatARB", false));
 		if (!wglChoosePixelFormat)
@@ -1031,7 +1045,8 @@ namespace Nz
 		glInvalidateBufferData = reinterpret_cast<PFNGLINVALIDATEBUFFERDATAPROC>(LoadEntry("glInvalidateBufferData", false));
 		glVertexAttribLPointer = reinterpret_cast<PFNGLVERTEXATTRIBLPOINTERPROC>(LoadEntry("glVertexAttribLPointer", false));
 
-		#if defined(NAZARA_PLATFORM_WINDOWS)
+		#if defined(NAZARA_PLATFORM_SDL2)
+		#elif defined(NAZARA_PLATFORM_WINDOWS)
 		wglGetExtensionsStringARB = reinterpret_cast<PFNWGLGETEXTENSIONSSTRINGARBPROC>(LoadEntry("wglGetExtensionsStringARB", false));
 		wglGetExtensionsStringEXT = reinterpret_cast<PFNWGLGETEXTENSIONSSTRINGEXTPROC>(LoadEntry("wglGetExtensionsStringEXT", false));
 		wglSwapInterval = reinterpret_cast<PFNWGLSWAPINTERVALEXTPROC>(LoadEntry("wglSwapIntervalEXT", false));
@@ -2287,7 +2302,8 @@ PFNGLVERTEXATTRIBIPOINTERPROC     glVertexAttribIPointer     = nullptr;
 	PFNGLVERTEXATTRIBLPOINTERPROC glVertexAttribLPointer     = nullptr;
 	PFNGLVIEWPORTPROC glViewport                 = nullptr;
 
-#if defined(NAZARA_PLATFORM_WINDOWS)
+#if defined(NAZARA_PLATFORM_SDL2)
+#elif defined(NAZARA_PLATFORM_WINDOWS)
 	PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormat       = nullptr;
 	PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs    = nullptr;
 	PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB  = nullptr;

src/Nazara/Renderer/SDL2/ContextImpl.cpp

@@ -0,0 +1,145 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+// Code inspiré de NeHe (Lesson1) et de la SFML par Laurent Gomila
+
+#include <cstring>
+#include <Nazara/Core/CallOnExit.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/LockGuard.hpp>
+#include <Nazara/Core/Mutex.hpp>
+#include <Nazara/Renderer/Context.hpp>
+#include <Nazara/Renderer/Debug.hpp>
+#include <Nazara/Renderer/OpenGL.hpp>
+#include <Nazara/Renderer/SDL2/ContextImpl.hpp>
+namespace Nz
+{
+	ContextImpl::ContextImpl()
+	{
+	}
+
+	bool ContextImpl::Activate() const
+	{
+		bool success = SDL_GL_MakeCurrent(m_window, m_context) == 0;
+
+		if (!success)
+			NazaraError(SDL_GetError());
+		else
+			lastActive = m_window;
+
+		return success;
+	}
+
+	bool ContextImpl::Create(ContextParameters& parameters)
+	{
+		if (parameters.window)
+		{
+			m_window = static_cast<SDL_Window*>(parameters.window);
+			m_ownsWindow = false;
+		}
+		else
+		{
+			m_window = SDL_CreateWindow("STATIC", 0, 0, 1, 1, SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN);
+			if (!m_window)
+			{
+				NazaraError("Failed to create window");
+				return false;
+			}
+
+			//SDL_HideWindow(m_window);
+			m_ownsWindow = true;
+		}
+
+		// En cas d'exception, la ressource sera quand même libérée
+		CallOnExit onExit([this] ()
+		{
+			Destroy();
+		});
+
+
+		bool valid = true;
+
+		std::array<std::pair<SDL_GLattr, int>, 13> attributes{
+			std::pair<SDL_GLattr, int>
+			{SDL_GL_CONTEXT_PROFILE_MASK,       parameters.compatibilityProfile ? SDL_GL_CONTEXT_PROFILE_COMPATIBILITY : SDL_GL_CONTEXT_PROFILE_CORE},
+			{SDL_GL_CONTEXT_MAJOR_VERSION,      parameters.majorVersion},
+			{SDL_GL_CONTEXT_MINOR_VERSION,      parameters.minorVersion},
+			{SDL_GL_CONTEXT_FLAGS,              parameters.debugMode ? SDL_GL_CONTEXT_DEBUG_FLAG : 0},
+			{SDL_GL_SHARE_WITH_CURRENT_CONTEXT, true},
+			{SDL_GL_RED_SIZE,           (parameters.bitsPerPixel == 32) ? 8 : parameters.bitsPerPixel / 3}, // sad but I don't have a solution for now
+			{SDL_GL_GREEN_SIZE,         (parameters.bitsPerPixel == 32) ? 8 : parameters.bitsPerPixel / 3},
+			{SDL_GL_BLUE_SIZE,          (parameters.bitsPerPixel == 32) ? 8 : parameters.bitsPerPixel / 3},
+			{SDL_GL_ALPHA_SIZE,         (parameters.bitsPerPixel == 32) ? 8 : 0},
+			{SDL_GL_DEPTH_SIZE,         parameters.depthBits},
+			{SDL_GL_STENCIL_SIZE,       parameters.stencilBits},
+			//{SDL_GL_DOUBLEBUFFER,	    parameters.doubleBuffered}, // doesn't work if we dont close all windows
+			{SDL_GL_MULTISAMPLEBUFFERS, parameters.antialiasingLevel > 0 ? GL_TRUE : GL_FALSE},
+			{SDL_GL_MULTISAMPLESAMPLES, parameters.antialiasingLevel}
+		};
+
+		for (const auto& attribute : attributes) {
+			valid &= SDL_GL_SetAttribute(attribute.first, attribute.second) == 0;
+
+			if (!valid) {
+				NazaraWarning(SDL_GetError());
+				break;
+			}
+		}
+
+		if (!valid)
+			NazaraWarning("Could not find a format matching requirements, disabling antialiasing...");
+
+		int antialiasingLevel;
+		SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &antialiasingLevel);
+
+		parameters.antialiasingLevel = static_cast<decltype(antialiasingLevel)>(antialiasingLevel);
+
+
+		onExit.Reset();
+
+		m_context = SDL_GL_CreateContext(m_window);
+
+		if (!m_context) {
+			NazaraError(SDL_GetError());
+
+			return false;
+		}
+
+		return true;
+	}
+
+	void ContextImpl::Destroy()
+	{
+		if (m_context)
+		{
+			SDL_GL_DeleteContext(m_context);
+			m_context = nullptr;
+		}
+
+		if (m_ownsWindow)
+		{
+			SDL_DestroyWindow(m_window);
+			m_window = nullptr;
+		}
+	}
+
+	void ContextImpl::EnableVerticalSync(bool enabled)
+	{
+
+		if (SDL_GL_SetSwapInterval(enabled ? 1 : 0) != 0)
+			NazaraError("Vertical sync not supported");
+	}
+
+	void ContextImpl::SwapBuffers()
+	{
+		SDL_GL_SwapWindow(m_window);
+	}
+
+	bool ContextImpl::Desactivate()
+	{
+		return SDL_GL_MakeCurrent(nullptr, nullptr) == 0;
+	}
+
+	SDL_Window* ContextImpl::lastActive = nullptr;
+}

src/Nazara/Renderer/SDL2/ContextImpl.hpp

@@ -0,0 +1,42 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine".
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_CONTEXTIMPL_HPP
+#define NAZARA_CONTEXTIMPL_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Renderer/ContextParameters.hpp>
+#include <SDL2/SDL.h>
+
+namespace Nz
+{
+	class ContextImpl
+	{
+		public:
+			ContextImpl();
+
+			bool Activate() const;
+
+			bool Create(ContextParameters& parameters);
+
+			void Destroy();
+
+			void EnableVerticalSync(bool enabled);
+
+			void SwapBuffers();
+
+			static bool Desactivate();
+
+		private:
+			SDL_GLContext m_context;
+			SDL_Window* m_window;
+			bool m_ownsWindow;
+
+			static SDL_Window* lastActive;
+	};
+}
+
+#endif // NAZARA_CONTEXTIMPL_HPP