2018-02-21 22:05:17 +00:00
// ImGui Platform Binding for: SDL2
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
2016-03-24 10:00:47 +00:00
2018-02-05 19:34:11 +00:00
// Implemented features:
2018-06-11 10:33:51 +00:00
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// [X] Platform: Clipboard support.
2018-06-30 12:33:45 +00:00
// [X] Platform: Keyboard arrays indexed using SDL_SCANCODE_* codes, e.g. ImGui::IsKeyPressed(SDL_SCANCODE_SPACE).
2018-06-12 14:24:24 +00:00
// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-06-08 17:37:33 +00:00
// Missing features:
2018-06-11 10:33:51 +00:00
// [ ] Platform: SDL2 handling of IME under Windows appears to be broken and it explicitly disable the regular Windows IME. You can restore Windows IME by compiling SDL with SDL_DISABLE_WINDOWS_IME.
2018-02-05 19:34:11 +00:00
2015-11-29 11:19:30 +00:00
// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.
2018-07-04 17:06:28 +00:00
// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.
2015-07-08 16:27:25 +00:00
// https://github.com/ocornut/imgui
2018-02-15 10:11:21 +00:00
// CHANGELOG
2018-02-16 16:20:18 +00:00
// (minor and older changes stripped away, please see git history for details)
2018-03-18 17:44:57 +00:00
// 2018-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2018-06-29 14:30:41 +00:00
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
2018-06-10 13:45:54 +00:00
// 2018-06-08: Misc: Extracted imgui_impl_sdl.cpp/.h away from the old combined SDL2+OpenGL/Vulkan examples.
2018-06-08 17:37:33 +00:00
// 2018-06-08: Misc: ImGui_ImplSDL2_InitForOpenGL() now takes a SDL_GLContext parameter.
2018-05-11 20:22:41 +00:00
// 2018-05-09: Misc: Fixed clipboard paste memory leak (we didn't call SDL_FreeMemory on the data returned by SDL_GetClipboardText).
2018-04-06 21:34:43 +00:00
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
2018-02-16 18:55:16 +00:00
// 2018-02-16: Inputs: Added support for mouse cursors, honoring ImGui::GetMouseCursor() value.
2018-02-16 16:20:18 +00:00
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
// 2018-02-05: Misc: Using SDL_GetPerformanceCounter() instead of SDL_GetTicks() to be able to handle very high framerate (1000+ FPS).
// 2018-02-05: Inputs: Keyboard mapping is using scancodes everywhere instead of a confusing mixture of keycodes and scancodes.
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 2018-01-19: Inputs: When available (SDL 2.0.4+) using SDL_CaptureMouse() to retrieve coordinates outside of client area when dragging. Otherwise (SDL 2.0.3 and before) testing for SDL_WINDOW_INPUT_FOCUS instead of SDL_WINDOW_MOUSE_FOCUS.
// 2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
// 2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
// 2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
2018-02-15 10:11:21 +00:00
2018-02-16 21:22:47 +00:00
# include "imgui.h"
2018-06-10 13:45:54 +00:00
# include "imgui_impl_sdl.h"
2018-02-27 22:30:39 +00:00
2018-02-27 09:29:37 +00:00
// SDL
2018-04-23 13:54:38 +00:00
// (the multi-viewports feature requires SDL features supported from SDL 2.0.5+)
2015-05-25 07:40:58 +00:00
# include <SDL.h>
# include <SDL_syswm.h>
2018-05-11 12:05:40 +00:00
# define SDL_HAS_WARP_MOUSE_GLOBAL SDL_VERSION_ATLEAST(2,0,4)
2018-04-23 13:54:38 +00:00
# define SDL_HAS_CAPTURE_MOUSE SDL_VERSION_ATLEAST(2,0,4)
# define SDL_HAS_WINDOW_OPACITY SDL_VERSION_ATLEAST(2,0,5)
# define SDL_HAS_ALWAYS_ON_TOP SDL_VERSION_ATLEAST(2,0,5)
# define SDL_HAS_USABLE_DISPLAY_BOUNDS SDL_VERSION_ATLEAST(2,0,5)
# define SDL_HAS_PER_MONITOR_DPI SDL_VERSION_ATLEAST(2,0,4)
# define SDL_HAS_VULKAN SDL_VERSION_ATLEAST(2,0,6)
# define SDL_HAS_MOUSE_FOCUS_CLICKTHROUGH SDL_VERSION_ATLEAST(2,0,5)
2018-03-14 13:14:16 +00:00
# if !SDL_HAS_VULKAN
static const Uint32 SDL_WINDOW_VULKAN = 0x10000000 ;
# endif
2015-05-25 07:40:58 +00:00
// Data
2018-03-07 11:19:19 +00:00
static SDL_Window * g_Window = NULL ;
2018-02-05 22:09:14 +00:00
static Uint64 g_Time = 0 ;
2015-05-25 07:40:58 +00:00
static bool g_MousePressed [ 3 ] = { false , false , false } ;
2018-06-20 09:06:29 +00:00
static SDL_Cursor * g_MouseCursors [ ImGuiMouseCursor_COUNT ] = { 0 } ;
2018-05-11 20:22:41 +00:00
static char * g_ClipboardTextData = NULL ;
2015-05-25 07:40:58 +00:00
2018-02-27 22:30:39 +00:00
// Forward Declarations
static void ImGui_ImplSDL2_InitPlatformInterface ( SDL_Window * window , void * sdl_gl_context ) ;
static void ImGui_ImplSDL2_ShutdownPlatformInterface ( ) ;
2018-02-16 21:22:47 +00:00
static const char * ImGui_ImplSDL2_GetClipboardText ( void * )
2015-05-25 07:40:58 +00:00
{
2018-05-11 20:22:41 +00:00
if ( g_ClipboardTextData )
SDL_free ( g_ClipboardTextData ) ;
g_ClipboardTextData = SDL_GetClipboardText ( ) ;
return g_ClipboardTextData ;
2015-05-25 07:40:58 +00:00
}
2018-02-16 21:22:47 +00:00
static void ImGui_ImplSDL2_SetClipboardText ( void * , const char * text )
2015-05-25 07:40:58 +00:00
{
SDL_SetClipboardText ( text ) ;
}
Examples: Added a bunch of comments/referencs related to io.WantCaptureMouse, io.WantCaptureKeyboard (#1262, #1237, #1219, #635, #1058, #1051, #912, #533, #703, #446, #459, #364, #213, #52, and more)
2017-11-01 13:24:09 +00:00
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
2018-02-16 21:22:47 +00:00
bool ImGui_ImplSDL2_ProcessEvent ( SDL_Event * event )
2015-05-25 07:40:58 +00:00
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2015-07-08 17:42:43 +00:00
switch ( event - > type )
2015-07-08 16:10:54 +00:00
{
case SDL_MOUSEWHEEL :
{
2018-01-20 11:45:31 +00:00
if ( event - > wheel . x > 0 ) io . MouseWheelH + = 1 ;
if ( event - > wheel . x < 0 ) io . MouseWheelH - = 1 ;
if ( event - > wheel . y > 0 ) io . MouseWheel + = 1 ;
if ( event - > wheel . y < 0 ) io . MouseWheel - = 1 ;
2015-07-08 16:10:54 +00:00
return true ;
}
case SDL_MOUSEBUTTONDOWN :
{
2015-07-08 17:42:43 +00:00
if ( event - > button . button = = SDL_BUTTON_LEFT ) g_MousePressed [ 0 ] = true ;
if ( event - > button . button = = SDL_BUTTON_RIGHT ) g_MousePressed [ 1 ] = true ;
if ( event - > button . button = = SDL_BUTTON_MIDDLE ) g_MousePressed [ 2 ] = true ;
2015-07-08 16:10:54 +00:00
return true ;
}
case SDL_TEXTINPUT :
{
2015-07-16 03:16:22 +00:00
io . AddInputCharactersUTF8 ( event - > text . text ) ;
2015-07-08 16:10:54 +00:00
return true ;
}
case SDL_KEYDOWN :
case SDL_KEYUP :
{
2018-02-05 21:35:29 +00:00
int key = event - > key . keysym . scancode ;
IM_ASSERT ( key > = 0 & & key < IM_ARRAYSIZE ( io . KeysDown ) ) ;
2015-07-08 17:42:43 +00:00
io . KeysDown [ key ] = ( event - > type = = SDL_KEYDOWN ) ;
2015-07-08 16:10:54 +00:00
io . KeyShift = ( ( SDL_GetModState ( ) & KMOD_SHIFT ) ! = 0 ) ;
io . KeyCtrl = ( ( SDL_GetModState ( ) & KMOD_CTRL ) ! = 0 ) ;
io . KeyAlt = ( ( SDL_GetModState ( ) & KMOD_ALT ) ! = 0 ) ;
2016-04-02 16:22:40 +00:00
io . KeySuper = ( ( SDL_GetModState ( ) & KMOD_GUI ) ! = 0 ) ;
2015-07-08 16:10:54 +00:00
return true ;
}
2018-03-15 09:54:27 +00:00
// Multi-viewport support
case SDL_WINDOWEVENT :
Uint8 window_event = event - > window . event ;
if ( window_event = = SDL_WINDOWEVENT_CLOSE | | window_event = = SDL_WINDOWEVENT_MOVED | | window_event = = SDL_WINDOWEVENT_RESIZED )
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( ( void * ) SDL_GetWindowFromID ( event - > window . windowID ) ) )
{
if ( window_event = = SDL_WINDOWEVENT_CLOSE )
viewport - > PlatformRequestClose = true ;
if ( window_event = = SDL_WINDOWEVENT_MOVED )
viewport - > PlatformRequestMove = true ;
if ( window_event = = SDL_WINDOWEVENT_RESIZED )
viewport - > PlatformRequestResize = true ;
return true ;
}
break ;
2015-07-08 16:10:54 +00:00
}
return false ;
2015-05-25 07:40:58 +00:00
}
2018-06-10 13:04:09 +00:00
static bool ImGui_ImplSDL2_Init ( SDL_Window * window , void * sdl_gl_context )
2015-05-25 07:40:58 +00:00
{
2018-03-07 11:19:19 +00:00
g_Window = window ;
2018-03-20 21:14:34 +00:00
// Setup back-end capabilities flags
2015-05-25 07:40:58 +00:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-03-20 21:14:34 +00:00
io . BackendFlags | = ImGuiBackendFlags_HasMouseCursors ; // We can honor GetMouseCursor() values (optional)
2018-05-11 12:05:40 +00:00
# if SDL_HAS_WARP_MOUSE_GLOBAL
io . BackendFlags | = ImGuiBackendFlags_HasSetMousePos ; // We can honor io.WantSetMousePos requests (optional, rarely used)
# endif
2018-03-20 21:14:34 +00:00
# if SDL_HAS_CAPTURE_MOUSE
io . BackendFlags | = ImGuiBackendFlags_PlatformHasViewports ; // We can create multi-viewports on the Platform side (optional)
# endif
2018-04-18 17:06:49 +00:00
// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
2018-02-05 21:35:29 +00:00
io . KeyMap [ ImGuiKey_Tab ] = SDL_SCANCODE_TAB ;
2015-05-25 07:40:58 +00:00
io . KeyMap [ ImGuiKey_LeftArrow ] = SDL_SCANCODE_LEFT ;
io . KeyMap [ ImGuiKey_RightArrow ] = SDL_SCANCODE_RIGHT ;
io . KeyMap [ ImGuiKey_UpArrow ] = SDL_SCANCODE_UP ;
io . KeyMap [ ImGuiKey_DownArrow ] = SDL_SCANCODE_DOWN ;
2015-07-08 16:10:54 +00:00
io . KeyMap [ ImGuiKey_PageUp ] = SDL_SCANCODE_PAGEUP ;
io . KeyMap [ ImGuiKey_PageDown ] = SDL_SCANCODE_PAGEDOWN ;
2015-05-25 07:40:58 +00:00
io . KeyMap [ ImGuiKey_Home ] = SDL_SCANCODE_HOME ;
io . KeyMap [ ImGuiKey_End ] = SDL_SCANCODE_END ;
2018-01-18 09:01:36 +00:00
io . KeyMap [ ImGuiKey_Insert ] = SDL_SCANCODE_INSERT ;
2018-02-05 21:35:29 +00:00
io . KeyMap [ ImGuiKey_Delete ] = SDL_SCANCODE_DELETE ;
io . KeyMap [ ImGuiKey_Backspace ] = SDL_SCANCODE_BACKSPACE ;
2018-02-06 18:29:31 +00:00
io . KeyMap [ ImGuiKey_Space ] = SDL_SCANCODE_SPACE ;
2018-02-05 21:35:29 +00:00
io . KeyMap [ ImGuiKey_Enter ] = SDL_SCANCODE_RETURN ;
io . KeyMap [ ImGuiKey_Escape ] = SDL_SCANCODE_ESCAPE ;
io . KeyMap [ ImGuiKey_A ] = SDL_SCANCODE_A ;
io . KeyMap [ ImGuiKey_C ] = SDL_SCANCODE_C ;
io . KeyMap [ ImGuiKey_V ] = SDL_SCANCODE_V ;
io . KeyMap [ ImGuiKey_X ] = SDL_SCANCODE_X ;
io . KeyMap [ ImGuiKey_Y ] = SDL_SCANCODE_Y ;
io . KeyMap [ ImGuiKey_Z ] = SDL_SCANCODE_Z ;
2016-03-26 14:43:45 +00:00
2018-02-16 21:22:47 +00:00
io . SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText ;
io . GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText ;
2016-10-15 09:36:43 +00:00
io . ClipboardUserData = NULL ;
2016-03-26 14:43:45 +00:00
2018-02-16 21:22:47 +00:00
g_MouseCursors [ ImGuiMouseCursor_Arrow ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_ARROW ) ;
g_MouseCursors [ ImGuiMouseCursor_TextInput ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_IBEAM ) ;
g_MouseCursors [ ImGuiMouseCursor_ResizeAll ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_SIZEALL ) ;
g_MouseCursors [ ImGuiMouseCursor_ResizeNS ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_SIZENS ) ;
g_MouseCursors [ ImGuiMouseCursor_ResizeEW ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_SIZEWE ) ;
g_MouseCursors [ ImGuiMouseCursor_ResizeNESW ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_SIZENESW ) ;
g_MouseCursors [ ImGuiMouseCursor_ResizeNWSE ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_SIZENWSE ) ;
2018-06-29 10:16:17 +00:00
g_MouseCursors [ ImGuiMouseCursor_Hand ] = SDL_CreateSystemCursor ( SDL_SYSTEM_CURSOR_HAND ) ;
2018-02-16 17:45:31 +00:00
2018-02-27 22:30:39 +00:00
// Our mouse update function expect PlatformHandle to be filled for the main viewport
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
main_viewport - > PlatformHandle = ( void * ) window ;
2018-03-07 13:46:53 +00:00
// We need SDL_CaptureMouse(), SDL_GetGlobalMouseState() from SDL 2.0.4+ to support multiple viewports.
// We left the call to ImGui_ImplSDL2_InitPlatformInterface() outside of #ifdef to avoid unused-function warnings.
2018-04-10 17:21:52 +00:00
if ( ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable ) & & ( io . BackendFlags & ImGuiBackendFlags_PlatformHasViewports ) )
2018-03-07 13:46:53 +00:00
ImGui_ImplSDL2_InitPlatformInterface ( window , sdl_gl_context ) ;
2018-02-27 22:30:39 +00:00
2015-05-25 07:40:58 +00:00
return true ;
}
2018-06-08 17:37:33 +00:00
bool ImGui_ImplSDL2_InitForOpenGL ( SDL_Window * window , void * sdl_gl_context )
{
( void ) sdl_gl_context ; // Viewport branch will need this.
2018-06-10 13:04:09 +00:00
return ImGui_ImplSDL2_Init ( window , sdl_gl_context ) ;
2018-06-08 17:37:33 +00:00
}
bool ImGui_ImplSDL2_InitForVulkan ( SDL_Window * window )
{
# if !SDL_HAS_VULKAN
IM_ASSERT ( 0 & & " Unsupported " ) ;
# endif
2018-06-10 13:04:09 +00:00
return ImGui_ImplSDL2_Init ( window , NULL ) ;
2018-06-08 17:37:33 +00:00
}
2018-02-16 21:22:47 +00:00
void ImGui_ImplSDL2_Shutdown ( )
2015-05-25 07:40:58 +00:00
{
2018-02-27 22:30:39 +00:00
ImGui_ImplSDL2_ShutdownPlatformInterface ( ) ;
2018-03-07 11:19:19 +00:00
g_Window = NULL ;
2018-02-27 22:30:39 +00:00
2018-05-11 20:22:41 +00:00
// Destroy last known clipboard data
if ( g_ClipboardTextData )
SDL_free ( g_ClipboardTextData ) ;
2018-06-13 17:22:22 +00:00
g_ClipboardTextData = NULL ;
2018-05-11 20:22:41 +00:00
2018-02-20 13:23:22 +00:00
// Destroy SDL mouse cursors
2018-06-20 09:06:29 +00:00
for ( ImGuiMouseCursor cursor_n = 0 ; cursor_n < ImGuiMouseCursor_COUNT ; cursor_n + + )
2018-02-16 21:22:47 +00:00
SDL_FreeCursor ( g_MouseCursors [ cursor_n ] ) ;
2018-02-20 13:23:22 +00:00
memset ( g_MouseCursors , 0 , sizeof ( g_MouseCursors ) ) ;
2015-05-25 07:40:58 +00:00
}
2018-05-11 14:41:32 +00:00
static void ImGui_ImplSDL2_UpdateMousePosAndButtons ( )
2018-02-27 22:30:39 +00:00
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-05-11 12:05:40 +00:00
const ImVec2 mouse_pos_backup = io . MousePos ;
2018-02-27 22:30:39 +00:00
io . MousePos = ImVec2 ( - FLT_MAX , - FLT_MAX ) ;
io . MouseHoveredViewport = 0 ;
2018-05-11 12:05:40 +00:00
// Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
// (When multi-viewports are enabled, all imgui positions are same as OS positions.)
# if SDL_HAS_WARP_MOUSE_GLOBAL
if ( io . WantSetMousePos )
{
if ( ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable ) = = 0 )
SDL_WarpMouseInWindow ( g_Window , ( int ) mouse_pos_backup . x , ( int ) mouse_pos_backup . y ) ;
else
SDL_WarpMouseGlobal ( ( int ) mouse_pos_backup . x , ( int ) mouse_pos_backup . y ) ;
}
# endif
2018-02-27 22:30:39 +00:00
int mx , my ;
Uint32 mouse_buttons = SDL_GetMouseState ( & mx , & my ) ;
io . MouseDown [ 0 ] = g_MousePressed [ 0 ] | | ( mouse_buttons & SDL_BUTTON ( SDL_BUTTON_LEFT ) ) ! = 0 ; // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
io . MouseDown [ 1 ] = g_MousePressed [ 1 ] | | ( mouse_buttons & SDL_BUTTON ( SDL_BUTTON_RIGHT ) ) ! = 0 ;
io . MouseDown [ 2 ] = g_MousePressed [ 2 ] | | ( mouse_buttons & SDL_BUTTON ( SDL_BUTTON_MIDDLE ) ) ! = 0 ;
g_MousePressed [ 0 ] = g_MousePressed [ 1 ] = g_MousePressed [ 2 ] = false ;
2018-03-13 22:16:15 +00:00
# if SDL_HAS_CAPTURE_MOUSE
2018-02-27 22:30:39 +00:00
SDL_Window * focused_window = SDL_GetKeyboardFocus ( ) ;
if ( focused_window )
{
2018-06-08 17:37:33 +00:00
// SDL_GetMouseState() gives mouse position seemingly based on the last window entered/focused(?)
2018-06-10 13:04:09 +00:00
// The creation of new windows at runtime and SDL_CaptureMouse both seems to severely mess up with that, so we retrieve that position globally.
2018-02-27 22:30:39 +00:00
int wx , wy ;
SDL_GetWindowPosition ( focused_window , & wx , & wy ) ;
SDL_GetGlobalMouseState ( & mx , & my ) ;
mx - = wx ;
my - = wy ;
}
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( ( void * ) focused_window ) )
io . MousePos = ImVec2 ( viewport - > Pos . x + ( float ) mx , viewport - > Pos . y + ( float ) my ) ;
2018-04-23 13:54:38 +00:00
// We already retrieve global mouse position, SDL_CaptureMouse() also let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't trigger the OS window resize cursor
2018-02-27 22:30:39 +00:00
// The function is only supported from SDL 2.0.4 (released Jan 2016)
bool any_mouse_button_down = ImGui : : IsAnyMouseDown ( ) ;
SDL_CaptureMouse ( any_mouse_button_down ? SDL_TRUE : SDL_FALSE ) ;
2018-03-07 11:19:19 +00:00
# else
if ( SDL_GetWindowFlags ( g_Window ) & SDL_WINDOW_INPUT_FOCUS )
io . MousePos = ImVec2 ( ( float ) mx , ( float ) my ) ;
2018-02-27 22:30:39 +00:00
# endif
2018-05-11 14:41:32 +00:00
}
static void ImGui_ImplSDL2_UpdateMouseCursor ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
if ( io . ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange )
return ;
2018-02-27 22:30:39 +00:00
2018-05-11 14:41:32 +00:00
ImGuiMouseCursor imgui_cursor = ImGui : : GetMouseCursor ( ) ;
if ( io . MouseDrawCursor | | imgui_cursor = = ImGuiMouseCursor_None )
2018-02-27 22:30:39 +00:00
{
2018-05-11 14:41:32 +00:00
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
SDL_ShowCursor ( SDL_FALSE ) ;
}
else
{
// Show OS mouse cursor
SDL_SetCursor ( g_MouseCursors [ imgui_cursor ] ? g_MouseCursors [ imgui_cursor ] : g_MouseCursors [ ImGuiMouseCursor_Arrow ] ) ;
SDL_ShowCursor ( SDL_TRUE ) ;
2018-02-27 22:30:39 +00:00
}
}
2018-02-16 21:22:47 +00:00
void ImGui_ImplSDL2_NewFrame ( SDL_Window * window )
2015-05-25 07:40:58 +00:00
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-02-16 21:22:47 +00:00
IM_ASSERT ( io . Fonts - > IsBuilt ( ) ) ; // Font atlas needs to be built, call renderer _NewFrame() function e.g. ImGui_ImplOpenGL3_NewFrame()
2015-05-25 07:40:58 +00:00
// Setup display size (every frame to accommodate for window resizing)
int w , h ;
2016-03-25 21:25:20 +00:00
int display_w , display_h ;
2016-02-15 09:56:37 +00:00
SDL_GetWindowSize ( window , & w , & h ) ;
2016-03-25 21:25:20 +00:00
SDL_GL_GetDrawableSize ( window , & display_w , & display_h ) ;
2015-05-25 07:40:58 +00:00
io . DisplaySize = ImVec2 ( ( float ) w , ( float ) h ) ;
2016-03-25 21:25:20 +00:00
io . DisplayFramebufferScale = ImVec2 ( w > 0 ? ( ( float ) display_w / w ) : 0 , h > 0 ? ( ( float ) display_h / h ) : 0 ) ;
2016-01-20 14:06:31 +00:00
2018-02-05 22:09:14 +00:00
// Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
static Uint64 frequency = SDL_GetPerformanceFrequency ( ) ;
Uint64 current_time = SDL_GetPerformanceCounter ( ) ;
io . DeltaTime = g_Time > 0 ? ( float ) ( ( double ) ( current_time - g_Time ) / frequency ) : ( float ) ( 1.0f / 60.0f ) ;
2015-05-25 07:40:58 +00:00
g_Time = current_time ;
2018-05-11 14:41:32 +00:00
ImGui_ImplSDL2_UpdateMousePosAndButtons ( ) ;
ImGui_ImplSDL2_UpdateMouseCursor ( ) ;
2018-02-27 22:30:39 +00:00
}
2018-01-19 09:46:54 +00:00
2018-03-18 17:44:57 +00:00
//--------------------------------------------------------------------------------------------------------
2018-04-24 15:09:50 +00:00
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
// This is an _advanced_ and _optional_ feature, allowing the back-end to create and handle multiple viewports simultaneously.
// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
2018-03-18 17:44:57 +00:00
//--------------------------------------------------------------------------------------------------------
2018-02-27 22:30:39 +00:00
2018-03-18 21:19:02 +00:00
struct ImGuiViewportDataSDL2
2018-02-27 22:30:39 +00:00
{
SDL_Window * Window ;
Uint32 WindowID ;
2018-04-09 20:01:24 +00:00
bool WindowOwned ;
2018-02-27 22:30:39 +00:00
SDL_GLContext GLContext ;
2018-04-09 20:01:24 +00:00
ImGuiViewportDataSDL2 ( ) { Window = NULL ; WindowID = 0 ; WindowOwned = false ; GLContext = NULL ; }
2018-03-18 21:19:02 +00:00
~ ImGuiViewportDataSDL2 ( ) { IM_ASSERT ( Window = = NULL & & GLContext = = NULL ) ; }
2018-02-27 22:30:39 +00:00
} ;
2018-03-18 17:44:57 +00:00
static void ImGui_ImplSDL2_CreateWindow ( ImGuiViewport * viewport )
2018-02-27 22:30:39 +00:00
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = IM_NEW ( ImGuiViewportDataSDL2 ) ( ) ;
2018-02-27 22:30:39 +00:00
viewport - > PlatformUserData = data ;
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * main_viewport_data = ( ImGuiViewportDataSDL2 * ) main_viewport - > PlatformUserData ;
2018-03-15 18:25:23 +00:00
2018-04-23 13:54:38 +00:00
// Share GL resources with main context
2018-03-15 18:25:23 +00:00
bool use_opengl = ( main_viewport_data - > GLContext ! = NULL ) ;
SDL_GLContext backup_context = NULL ;
if ( use_opengl )
{
backup_context = SDL_GL_GetCurrentContext ( ) ;
SDL_GL_SetAttribute ( SDL_GL_SHARE_WITH_CURRENT_CONTEXT , 1 ) ;
SDL_GL_MakeCurrent ( main_viewport_data - > Window , main_viewport_data - > GLContext ) ;
}
2018-02-27 22:30:39 +00:00
// We don't enable SDL_WINDOW_RESIZABLE because it enforce windows decorations
Uint32 sdl_flags = 0 ;
2018-03-15 18:25:23 +00:00
sdl_flags | = use_opengl ? SDL_WINDOW_OPENGL : SDL_WINDOW_VULKAN ;
2018-02-27 22:30:39 +00:00
sdl_flags | = SDL_WINDOW_HIDDEN ;
sdl_flags | = ( viewport - > Flags & ImGuiViewportFlags_NoDecoration ) ? SDL_WINDOW_BORDERLESS : 0 ;
sdl_flags | = ( viewport - > Flags & ImGuiViewportFlags_NoDecoration ) ? 0 : SDL_WINDOW_RESIZABLE ;
2018-04-11 19:27:19 +00:00
# if SDL_HAS_ALWAYS_ON_TOP
2018-05-10 10:10:10 +00:00
sdl_flags | = ( viewport - > Flags & ImGuiViewportFlags_TopMost ) ? SDL_WINDOW_ALWAYS_ON_TOP : 0 ;
2018-04-11 19:27:19 +00:00
# endif
2018-04-20 19:29:16 +00:00
data - > Window = SDL_CreateWindow ( " No Title Yet " , ( int ) viewport - > Pos . x , ( int ) viewport - > Pos . y , ( int ) viewport - > Size . x , ( int ) viewport - > Size . y , sdl_flags ) ;
2018-04-09 20:01:24 +00:00
data - > WindowOwned = true ;
2018-03-15 18:25:23 +00:00
if ( use_opengl )
2018-03-13 22:16:15 +00:00
data - > GLContext = SDL_GL_CreateContext ( data - > Window ) ;
2018-03-15 18:25:23 +00:00
if ( use_opengl & & backup_context )
SDL_GL_MakeCurrent ( data - > Window , backup_context ) ;
2018-02-27 22:30:39 +00:00
viewport - > PlatformHandle = ( void * ) data - > Window ;
}
2018-03-18 17:44:57 +00:00
static void ImGui_ImplSDL2_DestroyWindow ( ImGuiViewport * viewport )
2018-02-27 22:30:39 +00:00
{
2018-03-18 21:19:02 +00:00
if ( ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData )
2018-02-16 18:55:16 +00:00
{
2018-04-09 20:01:24 +00:00
if ( data - > GLContext & & data - > WindowOwned )
2018-02-27 22:30:39 +00:00
SDL_GL_DeleteContext ( data - > GLContext ) ;
2018-04-09 20:01:24 +00:00
if ( data - > Window & & data - > WindowOwned )
2018-02-27 22:30:39 +00:00
SDL_DestroyWindow ( data - > Window ) ;
2018-04-09 20:01:24 +00:00
data - > GLContext = NULL ;
2018-02-27 22:30:39 +00:00
data - > Window = NULL ;
IM_DELETE ( data ) ;
2018-02-16 18:55:16 +00:00
}
2018-02-27 22:30:39 +00:00
viewport - > PlatformUserData = viewport - > PlatformHandle = NULL ;
}
static void ImGui_ImplSDL2_ShowWindow ( ImGuiViewport * viewport )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
# if defined(_WIN32)
SDL_SysWMinfo info ;
SDL_VERSION ( & info . version ) ;
if ( SDL_GetWindowWMInfo ( data - > Window , & info ) )
2018-02-16 17:45:31 +00:00
{
2018-02-27 22:30:39 +00:00
HWND hwnd = info . info . win . window ;
// SDL hack: Hide icon from task bar
// Note: SDL 2.0.6+ has a SDL_WINDOW_SKIP_TASKBAR flag which is supported under Windows but the way it create the window breaks our seamless transition.
2018-04-10 17:15:44 +00:00
if ( viewport - > Flags & ImGuiViewportFlags_NoTaskBarIcon )
2018-02-27 22:30:39 +00:00
{
LONG ex_style = : : GetWindowLong ( hwnd , GWL_EXSTYLE ) ;
ex_style & = ~ WS_EX_APPWINDOW ;
ex_style | = WS_EX_TOOLWINDOW ;
: : SetWindowLong ( hwnd , GWL_EXSTYLE , ex_style ) ;
2018-03-15 09:54:27 +00:00
}
2015-05-25 07:40:58 +00:00
2018-02-27 22:30:39 +00:00
// SDL hack: SDL always activate/focus windows :/
if ( viewport - > Flags & ImGuiViewportFlags_NoFocusOnAppearing )
{
: : ShowWindow ( hwnd , SW_SHOWNA ) ;
return ;
}
2018-03-15 09:54:27 +00:00
}
2018-02-27 22:30:39 +00:00
# endif
2018-03-07 13:46:53 +00:00
2018-02-27 22:30:39 +00:00
SDL_ShowWindow ( data - > Window ) ;
}
static ImVec2 ImGui_ImplSDL2_GetWindowPos ( ImGuiViewport * viewport )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
int x = 0 , y = 0 ;
SDL_GetWindowPosition ( data - > Window , & x , & y ) ;
return ImVec2 ( ( float ) x , ( float ) y ) ;
}
static void ImGui_ImplSDL2_SetWindowPos ( ImGuiViewport * viewport , ImVec2 pos )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
SDL_SetWindowPosition ( data - > Window , ( int ) pos . x , ( int ) pos . y ) ;
}
static ImVec2 ImGui_ImplSDL2_GetWindowSize ( ImGuiViewport * viewport )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
int w = 0 , h = 0 ;
SDL_GetWindowSize ( data - > Window , & w , & h ) ;
return ImVec2 ( ( float ) w , ( float ) h ) ;
}
static void ImGui_ImplSDL2_SetWindowSize ( ImGuiViewport * viewport , ImVec2 size )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
SDL_SetWindowSize ( data - > Window , ( int ) size . x , ( int ) size . y ) ;
}
static void ImGui_ImplSDL2_SetWindowTitle ( ImGuiViewport * viewport , const char * title )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-02-27 22:30:39 +00:00
SDL_SetWindowTitle ( data - > Window , title ) ;
}
2018-04-25 13:15:14 +00:00
static void ImGui_ImplSDL2_SetWindowFocus ( ImGuiViewport * viewport )
{
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
SDL_RaiseWindow ( data - > Window ) ;
}
static bool ImGui_ImplSDL2_GetWindowFocus ( ImGuiViewport * viewport )
{
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-04-26 14:07:54 +00:00
return ( SDL_GetWindowFlags ( data - > Window ) & SDL_WINDOW_INPUT_FOCUS ) ! = 0 ;
2018-04-25 13:15:14 +00:00
}
2018-03-19 14:20:47 +00:00
static void ImGui_ImplSDL2_RenderWindow ( ImGuiViewport * viewport , void * )
2018-02-27 22:30:39 +00:00
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-03-13 22:16:15 +00:00
if ( data - > GLContext )
SDL_GL_MakeCurrent ( data - > Window , data - > GLContext ) ;
2018-02-27 22:30:39 +00:00
}
2018-03-19 14:20:47 +00:00
static void ImGui_ImplSDL2_SwapBuffers ( ImGuiViewport * viewport , void * )
2018-02-27 22:30:39 +00:00
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-03-13 22:16:15 +00:00
if ( data - > GLContext )
{
2018-03-15 18:25:23 +00:00
SDL_GL_MakeCurrent ( data - > Window , data - > GLContext ) ;
2018-03-13 22:16:15 +00:00
SDL_GL_SwapWindow ( data - > Window ) ;
}
}
// Vulkan support (the Vulkan renderer needs to call a platform-side support function to create the surface)
// SDL is graceful enough to _not_ need <vulkan/vulkan.h> so we can safely include this.
# if SDL_HAS_VULKAN
# include <SDL_vulkan.h>
static int ImGui_ImplSDL2_CreateVkSurface ( ImGuiViewport * viewport , ImU64 vk_instance , const void * vk_allocator , ImU64 * out_vk_surface )
{
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = ( ImGuiViewportDataSDL2 * ) viewport - > PlatformUserData ;
2018-03-13 22:16:15 +00:00
( void ) vk_allocator ;
SDL_bool ret = SDL_Vulkan_CreateSurface ( data - > Window , ( VkInstance ) vk_instance , ( VkSurfaceKHR * ) out_vk_surface ) ;
return ret ? 0 : 1 ; // ret ? VK_SUCCESS : VK_NOT_READY
2018-02-27 22:30:39 +00:00
}
2018-03-13 22:16:15 +00:00
# endif // SDL_HAS_VULKAN
2018-02-27 22:30:39 +00:00
2018-04-26 14:07:54 +00:00
// FIXME-PLATFORM: SDL doesn't have an event to notify the application of display/monitor changes
2018-04-10 20:32:08 +00:00
static void ImGui_ImplSDL2_UpdateMonitors ( )
{
2018-04-10 20:58:39 +00:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
2018-04-23 10:38:20 +00:00
platform_io . Monitors . resize ( 0 ) ;
2018-04-10 20:32:08 +00:00
int display_count = SDL_GetNumVideoDisplays ( ) ;
for ( int n = 0 ; n < display_count ; n + + )
{
2018-04-13 16:07:23 +00:00
// Warning: the validity of monitor DPI information on Windows depends on the application DPI awareness settings, which generally needs to be set in the manifest or at runtime.
2018-04-23 10:38:20 +00:00
ImGuiPlatformMonitor monitor ;
2018-04-10 20:32:08 +00:00
SDL_Rect r ;
SDL_GetDisplayBounds ( n , & r ) ;
2018-05-10 10:10:10 +00:00
monitor . MainPos = monitor . WorkPos = ImVec2 ( ( float ) r . x , ( float ) r . y ) ;
monitor . MainSize = monitor . WorkSize = ImVec2 ( ( float ) r . w , ( float ) r . h ) ;
2018-04-23 10:38:20 +00:00
# if SDL_HAS_USABLE_DISPLAY_BOUNDS
SDL_GetDisplayUsableBounds ( n , & r ) ;
2018-05-10 10:10:10 +00:00
monitor . WorkPos = ImVec2 ( ( float ) r . x , ( float ) r . y ) ;
monitor . WorkSize = ImVec2 ( ( float ) r . w , ( float ) r . h ) ;
2018-04-23 10:38:20 +00:00
# endif
2018-04-13 16:07:23 +00:00
# if SDL_HAS_PER_MONITOR_DPI
float dpi = 0.0f ;
2018-04-23 10:38:20 +00:00
if ( SDL_GetDisplayDPI ( n , & dpi , NULL , NULL ) )
monitor . DpiScale = dpi / 96.0f ;
2018-04-13 16:07:23 +00:00
# endif
2018-04-23 10:38:20 +00:00
platform_io . Monitors . push_back ( monitor ) ;
2018-04-10 20:32:08 +00:00
}
}
2018-02-27 22:30:39 +00:00
static void ImGui_ImplSDL2_InitPlatformInterface ( SDL_Window * window , void * sdl_gl_context )
{
// Register platform interface (will be coupled with a renderer interface)
2018-03-18 17:44:57 +00:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Platform_CreateWindow = ImGui_ImplSDL2_CreateWindow ;
platform_io . Platform_DestroyWindow = ImGui_ImplSDL2_DestroyWindow ;
platform_io . Platform_ShowWindow = ImGui_ImplSDL2_ShowWindow ;
platform_io . Platform_SetWindowPos = ImGui_ImplSDL2_SetWindowPos ;
platform_io . Platform_GetWindowPos = ImGui_ImplSDL2_GetWindowPos ;
platform_io . Platform_SetWindowSize = ImGui_ImplSDL2_SetWindowSize ;
platform_io . Platform_GetWindowSize = ImGui_ImplSDL2_GetWindowSize ;
2018-04-25 13:15:14 +00:00
platform_io . Platform_SetWindowFocus = ImGui_ImplSDL2_SetWindowFocus ;
platform_io . Platform_GetWindowFocus = ImGui_ImplSDL2_GetWindowFocus ;
2018-03-18 17:44:57 +00:00
platform_io . Platform_SetWindowTitle = ImGui_ImplSDL2_SetWindowTitle ;
platform_io . Platform_RenderWindow = ImGui_ImplSDL2_RenderWindow ;
platform_io . Platform_SwapBuffers = ImGui_ImplSDL2_SwapBuffers ;
2018-03-13 22:16:15 +00:00
# if SDL_HAS_VULKAN
2018-03-18 17:44:57 +00:00
platform_io . Platform_CreateVkSurface = ImGui_ImplSDL2_CreateVkSurface ;
2018-03-13 22:16:15 +00:00
# endif
2018-02-27 22:30:39 +00:00
2018-04-23 13:54:38 +00:00
// SDL2 by default doesn't pass mouse clicks to the application when the click focused a window. This is getting in the way of our interactions and we disable that behavior.
# if SDL_HAS_MOUSE_FOCUS_CLICKTHROUGH
SDL_SetHint ( SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH , " 1 " ) ;
# endif
2018-04-10 20:32:08 +00:00
ImGui_ImplSDL2_UpdateMonitors ( ) ;
2018-04-09 20:01:24 +00:00
// Register main window handle (which is owned by the main application, not by us)
2018-02-27 22:30:39 +00:00
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2018-03-18 21:19:02 +00:00
ImGuiViewportDataSDL2 * data = IM_NEW ( ImGuiViewportDataSDL2 ) ( ) ;
2018-02-27 22:30:39 +00:00
data - > Window = window ;
data - > WindowID = SDL_GetWindowID ( window ) ;
2018-04-09 20:01:24 +00:00
data - > WindowOwned = false ;
2018-02-27 22:30:39 +00:00
data - > GLContext = sdl_gl_context ;
main_viewport - > PlatformUserData = data ;
main_viewport - > PlatformHandle = data - > Window ;
}
static void ImGui_ImplSDL2_ShutdownPlatformInterface ( )
{
2015-05-25 07:40:58 +00:00
}