~ 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)
2019-04-03 21:17:06 +02:00
parent ffc58e9806
commit 848f05a420
42 changed files with 2943 additions and 1268 deletions
--- a/src/Nazara/Platform/SDL2/CursorImpl.cpp
+++ b/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");
+}
--- a/src/Nazara/Platform/SDL2/CursorImpl.hpp
+++ b/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
--- a/src/Nazara/Platform/SDL2/IconImpl.cpp
+++ b/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;
+	}
+}
--- a/src/Nazara/Platform/SDL2/IconImpl.hpp
+++ b/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
--- a/src/Nazara/Platform/SDL2/InputImpl.cpp
+++ b/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");
+	}
+}
--- a/src/Nazara/Platform/SDL2/InputImpl.hpp
+++ b/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
--- a/src/Nazara/Platform/SDL2/VideoModeImpl.cpp
+++ b/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);
+		}
+	}
+}
--- a/src/Nazara/Platform/SDL2/VideoModeImpl.hpp
+++ b/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
--- a/src/Nazara/Platform/SDL2/WindowImpl.cpp
+++ b/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);*/
+	//}
+}
--- a/src/Nazara/Platform/SDL2/WindowImpl.hpp
+++ b/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