2020-10-12 23:34:22 +08:00
// dear imgui: Platform Backend for GLFW
2021-01-28 19:11:26 +08:00
// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
2018-06-09 01:37:33 +08:00
// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
2019-01-02 23:04:13 +08:00
// (Requires: GLFW 3.1+)
2018-06-09 01:37:33 +08:00
// Implemented features:
2018-06-11 18:33:51 +08:00
// [X] Platform: Clipboard support.
2021-12-12 19:00:31 +08:00
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
2018-09-20 16:37:55 +08:00
// [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
2019-12-05 22:43:05 +08:00
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
2018-06-09 01:37:33 +08:00
2021-06-28 22:52:10 +08:00
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
2021-05-27 19:59:35 +08:00
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
2020-10-14 18:22:53 +08:00
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
2018-06-09 01:37:33 +08:00
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
2022-10-18 18:17:59 +08:00
// 2022-10-18: Perform a dummy glfwGetError() read to cancel missing mouse cursors errors. Using GLFW_VERSION_COMBINED directly. (#5785)
2022-10-11 18:22:29 +08:00
// 2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
2022-09-23 00:58:33 +08:00
// 2022-09-26: Inputs: Renamed ImGuiKey_ModXXX introduced in 1.87 to ImGuiMod_XXX (old names still supported).
2022-09-02 02:44:50 +08:00
// 2022-09-01: Inputs: Honor GLFW_CURSOR_DISABLED by not setting mouse position.
2022-04-30 15:21:04 +08:00
// 2022-04-30: Inputs: Fixed ImGui_ImplGlfw_TranslateUntranslatedKey() for lower case letters on OSX.
2022-03-23 21:01:57 +08:00
// 2022-03-23: Inputs: Fixed a regression in 1.87 which resulted in keyboard modifiers events being reported incorrectly on Linux/X11.
// 2022-02-07: Added ImGui_ImplGlfw_InstallCallbacks()/ImGui_ImplGlfw_RestoreCallbacks() helpers to facilitate user installing callbacks after initializing backend.
2022-09-23 00:58:33 +08:00
// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago) with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
2022-01-21 00:12:22 +08:00
// 2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
2022-01-18 00:22:37 +08:00
// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
2022-01-22 00:32:35 +08:00
// 2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
2022-01-13 00:08:37 +08:00
// 2022-01-12: *BREAKING CHANGE*: Now using glfwSetCursorPosCallback(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetCursorPosCallback() and forward it to the backend via ImGui_ImplGlfw_CursorPosCallback().
2022-01-10 23:59:31 +08:00
// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
2022-01-05 23:54:03 +08:00
// 2022-01-05: Inputs: Converting GLFW untranslated keycodes back to translated keycodes (in the ImGui_ImplGlfw_KeyCallback() function) in order to match the behavior of every other backend, and facilitate the use of GLFW with lettered-shortcuts API.
2021-08-03 02:17:26 +08:00
// 2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
// 2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
2021-06-28 22:52:10 +08:00
// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
2020-01-17 18:36:56 +08:00
// 2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
2019-12-05 22:43:05 +08:00
// 2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
2019-10-18 22:25:18 +08:00
// 2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
2019-07-22 09:39:50 +08:00
// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
2019-05-11 16:33:56 +08:00
// 2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
2019-03-13 01:27:14 +08:00
// 2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
2018-12-01 01:18:15 +08:00
// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
2018-11-08 23:24:41 +08:00
// 2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
2018-08-01 17:34:17 +08:00
// 2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
2018-06-29 22:30:41 +08:00
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
2018-06-09 01:37:33 +08:00
// 2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
// 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
// 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-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
// 2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 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.
# include "imgui.h"
# include "imgui_impl_glfw.h"
2021-12-29 19:41:34 +08:00
// Clang warnings with -Weverything
# if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wold-style-cast" // warning: use of old-style cast
# pragma clang diagnostic ignored "-Wsign-conversion" // warning: implicit conversion changes signedness
# endif
2018-06-09 01:37:33 +08:00
// GLFW
# include <GLFW/glfw3.h>
# ifdef _WIN32
# undef APIENTRY
# define GLFW_EXPOSE_NATIVE_WIN32
# include <GLFW/glfw3native.h> // for glfwGetWin32Window
# endif
2022-10-18 18:17:59 +08:00
// We gather version tests as define in order to easily see which features are version-dependent.
# define GLFW_VERSION_COMBINED (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 + GLFW_VERSION_REVISION)
# ifdef GLFW_RESIZE_NESW_CURSOR // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
# define GLFW_HAS_NEW_CURSORS (GLFW_VERSION_COMBINED >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
2019-12-06 22:08:04 +08:00
# else
2022-10-18 18:17:59 +08:00
# define GLFW_HAS_NEW_CURSORS (0)
2019-12-06 22:08:04 +08:00
# endif
2022-10-18 18:17:59 +08:00
# define GLFW_HAS_GAMEPAD_API (GLFW_VERSION_COMBINED >= 3300) // 3.3+ glfwGetGamepadState() new api
# define GLFW_HAS_GETKEYNAME (GLFW_VERSION_COMBINED >= 3200) // 3.2+ glfwGetKeyName()
2018-06-09 01:37:33 +08:00
2021-06-28 22:52:10 +08:00
// GLFW data
2018-06-09 01:37:33 +08:00
enum GlfwClientApi
{
GlfwClientApi_Unknown ,
GlfwClientApi_OpenGL ,
2021-02-11 00:27:33 +08:00
GlfwClientApi_Vulkan
2018-06-09 01:37:33 +08:00
} ;
2021-06-28 22:52:10 +08:00
struct ImGui_ImplGlfw_Data
{
GLFWwindow * Window ;
GlfwClientApi ClientApi ;
double Time ;
2021-07-30 00:59:45 +08:00
GLFWwindow * MouseWindow ;
2021-06-28 22:52:10 +08:00
GLFWcursor * MouseCursors [ ImGuiMouseCursor_COUNT ] ;
2022-02-07 23:00:13 +08:00
ImVec2 LastValidMousePos ;
2021-06-28 22:52:10 +08:00
bool InstalledCallbacks ;
// Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
2021-08-03 02:17:26 +08:00
GLFWwindowfocusfun PrevUserCallbackWindowFocus ;
2022-01-13 00:08:37 +08:00
GLFWcursorposfun PrevUserCallbackCursorPos ;
2021-07-30 00:59:45 +08:00
GLFWcursorenterfun PrevUserCallbackCursorEnter ;
2021-06-28 22:52:10 +08:00
GLFWmousebuttonfun PrevUserCallbackMousebutton ;
GLFWscrollfun PrevUserCallbackScroll ;
GLFWkeyfun PrevUserCallbackKey ;
GLFWcharfun PrevUserCallbackChar ;
2021-07-07 20:12:48 +08:00
GLFWmonitorfun PrevUserCallbackMonitor ;
2021-06-28 22:52:10 +08:00
2022-03-13 14:15:32 +08:00
ImGui_ImplGlfw_Data ( ) { memset ( ( void * ) this , 0 , sizeof ( * this ) ) ; }
2021-06-28 22:52:10 +08:00
} ;
2021-06-29 22:42:13 +08:00
// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
2021-07-07 20:12:48 +08:00
// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
// (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
2021-06-29 22:42:13 +08:00
// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
2021-06-30 21:22:15 +08:00
static ImGui_ImplGlfw_Data * ImGui_ImplGlfw_GetBackendData ( )
{
2022-10-11 18:22:29 +08:00
return ImGui : : GetCurrentContext ( ) ? ( ImGui_ImplGlfw_Data * ) ImGui : : GetIO ( ) . BackendPlatformUserData : nullptr ;
2021-06-30 21:22:15 +08:00
}
2021-06-28 22:52:10 +08:00
// Functions
2018-06-09 01:37:33 +08:00
static const char * ImGui_ImplGlfw_GetClipboardText ( void * user_data )
{
return glfwGetClipboardString ( ( GLFWwindow * ) user_data ) ;
}
static void ImGui_ImplGlfw_SetClipboardText ( void * user_data , const char * text )
{
glfwSetClipboardString ( ( GLFWwindow * ) user_data , text ) ;
}
2021-12-12 19:00:31 +08:00
static ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey ( int key )
{
switch ( key )
{
case GLFW_KEY_TAB : return ImGuiKey_Tab ;
case GLFW_KEY_LEFT : return ImGuiKey_LeftArrow ;
case GLFW_KEY_RIGHT : return ImGuiKey_RightArrow ;
case GLFW_KEY_UP : return ImGuiKey_UpArrow ;
case GLFW_KEY_DOWN : return ImGuiKey_DownArrow ;
case GLFW_KEY_PAGE_UP : return ImGuiKey_PageUp ;
case GLFW_KEY_PAGE_DOWN : return ImGuiKey_PageDown ;
case GLFW_KEY_HOME : return ImGuiKey_Home ;
case GLFW_KEY_END : return ImGuiKey_End ;
case GLFW_KEY_INSERT : return ImGuiKey_Insert ;
case GLFW_KEY_DELETE : return ImGuiKey_Delete ;
case GLFW_KEY_BACKSPACE : return ImGuiKey_Backspace ;
case GLFW_KEY_SPACE : return ImGuiKey_Space ;
case GLFW_KEY_ENTER : return ImGuiKey_Enter ;
case GLFW_KEY_ESCAPE : return ImGuiKey_Escape ;
case GLFW_KEY_APOSTROPHE : return ImGuiKey_Apostrophe ;
case GLFW_KEY_COMMA : return ImGuiKey_Comma ;
case GLFW_KEY_MINUS : return ImGuiKey_Minus ;
case GLFW_KEY_PERIOD : return ImGuiKey_Period ;
case GLFW_KEY_SLASH : return ImGuiKey_Slash ;
case GLFW_KEY_SEMICOLON : return ImGuiKey_Semicolon ;
case GLFW_KEY_EQUAL : return ImGuiKey_Equal ;
case GLFW_KEY_LEFT_BRACKET : return ImGuiKey_LeftBracket ;
case GLFW_KEY_BACKSLASH : return ImGuiKey_Backslash ;
case GLFW_KEY_RIGHT_BRACKET : return ImGuiKey_RightBracket ;
case GLFW_KEY_GRAVE_ACCENT : return ImGuiKey_GraveAccent ;
case GLFW_KEY_CAPS_LOCK : return ImGuiKey_CapsLock ;
case GLFW_KEY_SCROLL_LOCK : return ImGuiKey_ScrollLock ;
case GLFW_KEY_NUM_LOCK : return ImGuiKey_NumLock ;
case GLFW_KEY_PRINT_SCREEN : return ImGuiKey_PrintScreen ;
case GLFW_KEY_PAUSE : return ImGuiKey_Pause ;
case GLFW_KEY_KP_0 : return ImGuiKey_Keypad0 ;
case GLFW_KEY_KP_1 : return ImGuiKey_Keypad1 ;
case GLFW_KEY_KP_2 : return ImGuiKey_Keypad2 ;
case GLFW_KEY_KP_3 : return ImGuiKey_Keypad3 ;
case GLFW_KEY_KP_4 : return ImGuiKey_Keypad4 ;
case GLFW_KEY_KP_5 : return ImGuiKey_Keypad5 ;
case GLFW_KEY_KP_6 : return ImGuiKey_Keypad6 ;
case GLFW_KEY_KP_7 : return ImGuiKey_Keypad7 ;
case GLFW_KEY_KP_8 : return ImGuiKey_Keypad8 ;
case GLFW_KEY_KP_9 : return ImGuiKey_Keypad9 ;
case GLFW_KEY_KP_DECIMAL : return ImGuiKey_KeypadDecimal ;
case GLFW_KEY_KP_DIVIDE : return ImGuiKey_KeypadDivide ;
case GLFW_KEY_KP_MULTIPLY : return ImGuiKey_KeypadMultiply ;
case GLFW_KEY_KP_SUBTRACT : return ImGuiKey_KeypadSubtract ;
case GLFW_KEY_KP_ADD : return ImGuiKey_KeypadAdd ;
case GLFW_KEY_KP_ENTER : return ImGuiKey_KeypadEnter ;
case GLFW_KEY_KP_EQUAL : return ImGuiKey_KeypadEqual ;
case GLFW_KEY_LEFT_SHIFT : return ImGuiKey_LeftShift ;
2022-01-17 22:41:04 +08:00
case GLFW_KEY_LEFT_CONTROL : return ImGuiKey_LeftCtrl ;
2021-12-12 19:00:31 +08:00
case GLFW_KEY_LEFT_ALT : return ImGuiKey_LeftAlt ;
case GLFW_KEY_LEFT_SUPER : return ImGuiKey_LeftSuper ;
case GLFW_KEY_RIGHT_SHIFT : return ImGuiKey_RightShift ;
2022-01-17 22:41:04 +08:00
case GLFW_KEY_RIGHT_CONTROL : return ImGuiKey_RightCtrl ;
2021-12-12 19:00:31 +08:00
case GLFW_KEY_RIGHT_ALT : return ImGuiKey_RightAlt ;
case GLFW_KEY_RIGHT_SUPER : return ImGuiKey_RightSuper ;
case GLFW_KEY_MENU : return ImGuiKey_Menu ;
case GLFW_KEY_0 : return ImGuiKey_0 ;
case GLFW_KEY_1 : return ImGuiKey_1 ;
case GLFW_KEY_2 : return ImGuiKey_2 ;
case GLFW_KEY_3 : return ImGuiKey_3 ;
case GLFW_KEY_4 : return ImGuiKey_4 ;
case GLFW_KEY_5 : return ImGuiKey_5 ;
case GLFW_KEY_6 : return ImGuiKey_6 ;
case GLFW_KEY_7 : return ImGuiKey_7 ;
case GLFW_KEY_8 : return ImGuiKey_8 ;
case GLFW_KEY_9 : return ImGuiKey_9 ;
case GLFW_KEY_A : return ImGuiKey_A ;
case GLFW_KEY_B : return ImGuiKey_B ;
case GLFW_KEY_C : return ImGuiKey_C ;
case GLFW_KEY_D : return ImGuiKey_D ;
case GLFW_KEY_E : return ImGuiKey_E ;
case GLFW_KEY_F : return ImGuiKey_F ;
case GLFW_KEY_G : return ImGuiKey_G ;
case GLFW_KEY_H : return ImGuiKey_H ;
case GLFW_KEY_I : return ImGuiKey_I ;
case GLFW_KEY_J : return ImGuiKey_J ;
case GLFW_KEY_K : return ImGuiKey_K ;
case GLFW_KEY_L : return ImGuiKey_L ;
case GLFW_KEY_M : return ImGuiKey_M ;
case GLFW_KEY_N : return ImGuiKey_N ;
case GLFW_KEY_O : return ImGuiKey_O ;
case GLFW_KEY_P : return ImGuiKey_P ;
case GLFW_KEY_Q : return ImGuiKey_Q ;
case GLFW_KEY_R : return ImGuiKey_R ;
case GLFW_KEY_S : return ImGuiKey_S ;
case GLFW_KEY_T : return ImGuiKey_T ;
case GLFW_KEY_U : return ImGuiKey_U ;
case GLFW_KEY_V : return ImGuiKey_V ;
case GLFW_KEY_W : return ImGuiKey_W ;
case GLFW_KEY_X : return ImGuiKey_X ;
case GLFW_KEY_Y : return ImGuiKey_Y ;
case GLFW_KEY_Z : return ImGuiKey_Z ;
case GLFW_KEY_F1 : return ImGuiKey_F1 ;
case GLFW_KEY_F2 : return ImGuiKey_F2 ;
case GLFW_KEY_F3 : return ImGuiKey_F3 ;
case GLFW_KEY_F4 : return ImGuiKey_F4 ;
case GLFW_KEY_F5 : return ImGuiKey_F5 ;
case GLFW_KEY_F6 : return ImGuiKey_F6 ;
case GLFW_KEY_F7 : return ImGuiKey_F7 ;
case GLFW_KEY_F8 : return ImGuiKey_F8 ;
case GLFW_KEY_F9 : return ImGuiKey_F9 ;
case GLFW_KEY_F10 : return ImGuiKey_F10 ;
case GLFW_KEY_F11 : return ImGuiKey_F11 ;
case GLFW_KEY_F12 : return ImGuiKey_F12 ;
default : return ImGuiKey_None ;
}
}
2022-03-23 21:01:57 +08:00
static int ImGui_ImplGlfw_KeyToModifier ( int key )
{
if ( key = = GLFW_KEY_LEFT_CONTROL | | key = = GLFW_KEY_RIGHT_CONTROL )
return GLFW_MOD_CONTROL ;
if ( key = = GLFW_KEY_LEFT_SHIFT | | key = = GLFW_KEY_RIGHT_SHIFT )
return GLFW_MOD_SHIFT ;
if ( key = = GLFW_KEY_LEFT_ALT | | key = = GLFW_KEY_RIGHT_ALT )
return GLFW_MOD_ALT ;
if ( key = = GLFW_KEY_LEFT_SUPER | | key = = GLFW_KEY_RIGHT_SUPER )
return GLFW_MOD_SUPER ;
return 0 ;
}
2022-01-17 21:57:55 +08:00
static void ImGui_ImplGlfw_UpdateKeyModifiers ( int mods )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-09-23 00:58:33 +08:00
io . AddKeyEvent ( ImGuiMod_Ctrl , ( mods & GLFW_MOD_CONTROL ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiMod_Shift , ( mods & GLFW_MOD_SHIFT ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiMod_Alt , ( mods & GLFW_MOD_ALT ) ! = 0 ) ;
io . AddKeyEvent ( ImGuiMod_Super , ( mods & GLFW_MOD_SUPER ) ! = 0 ) ;
2022-01-17 21:57:55 +08:00
}
2018-11-08 23:24:41 +08:00
void ImGui_ImplGlfw_MouseButtonCallback ( GLFWwindow * window , int button , int action , int mods )
2018-06-09 01:37:33 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackMousebutton ! = nullptr & & window = = bd - > Window )
2021-06-28 22:52:10 +08:00
bd - > PrevUserCallbackMousebutton ( window , button , action , mods ) ;
2018-11-08 23:24:41 +08:00
2022-01-17 21:57:55 +08:00
ImGui_ImplGlfw_UpdateKeyModifiers ( mods ) ;
2022-01-18 00:22:37 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
if ( button > = 0 & & button < ImGuiMouseButton_COUNT )
io . AddMouseButtonEvent ( button , action = = GLFW_PRESS ) ;
2018-06-09 01:37:33 +08:00
}
2018-11-08 23:24:41 +08:00
void ImGui_ImplGlfw_ScrollCallback ( GLFWwindow * window , double xoffset , double yoffset )
2018-06-09 01:37:33 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackScroll ! = nullptr & & window = = bd - > Window )
2021-06-28 22:52:10 +08:00
bd - > PrevUserCallbackScroll ( window , xoffset , yoffset ) ;
2018-11-08 23:24:41 +08:00
2018-06-09 01:37:33 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-01-18 00:22:37 +08:00
io . AddMouseWheelEvent ( ( float ) xoffset , ( float ) yoffset ) ;
2018-06-09 01:37:33 +08:00
}
2021-12-12 19:00:31 +08:00
static int ImGui_ImplGlfw_TranslateUntranslatedKey ( int key , int scancode )
2018-06-09 01:37:33 +08:00
{
2022-10-18 18:17:59 +08:00
# if GLFW_HAS_GETKEYNAME && !defined(__EMSCRIPTEN__)
2022-01-05 23:54:03 +08:00
// GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
// (It had reasons to do so: namely GLFW is/was more likely to be used for WASD-type game controls rather than lettered shortcuts, but IHMO the 3.1 change could have been done differently)
// See https://github.com/glfw/glfw/issues/1502 for details.
// Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
// This won't cover edge cases but this is at least going to cover common cases.
2022-02-01 22:27:10 +08:00
if ( key > = GLFW_KEY_KP_0 & & key < = GLFW_KEY_KP_EQUAL )
return key ;
2022-01-05 23:54:03 +08:00
const char * key_name = glfwGetKeyName ( key , scancode ) ;
if ( key_name & & key_name [ 0 ] ! = 0 & & key_name [ 1 ] = = 0 )
{
2022-01-24 20:45:47 +08:00
const char char_names [ ] = " `-=[] \\ ,; \' ./ " ;
2022-01-05 23:54:03 +08:00
const int char_keys [ ] = { GLFW_KEY_GRAVE_ACCENT , GLFW_KEY_MINUS , GLFW_KEY_EQUAL , GLFW_KEY_LEFT_BRACKET , GLFW_KEY_RIGHT_BRACKET , GLFW_KEY_BACKSLASH , GLFW_KEY_COMMA , GLFW_KEY_SEMICOLON , GLFW_KEY_APOSTROPHE , GLFW_KEY_PERIOD , GLFW_KEY_SLASH , 0 } ;
IM_ASSERT ( IM_ARRAYSIZE ( char_names ) = = IM_ARRAYSIZE ( char_keys ) ) ;
if ( key_name [ 0 ] > = ' 0 ' & & key_name [ 0 ] < = ' 9 ' ) { key = GLFW_KEY_0 + ( key_name [ 0 ] - ' 0 ' ) ; }
else if ( key_name [ 0 ] > = ' A ' & & key_name [ 0 ] < = ' Z ' ) { key = GLFW_KEY_A + ( key_name [ 0 ] - ' A ' ) ; }
2022-04-30 15:21:04 +08:00
else if ( key_name [ 0 ] > = ' a ' & & key_name [ 0 ] < = ' z ' ) { key = GLFW_KEY_A + ( key_name [ 0 ] - ' a ' ) ; }
2022-01-05 23:54:03 +08:00
else if ( const char * p = strchr ( char_names , key_name [ 0 ] ) ) { key = char_keys [ p - char_names ] ; }
}
// if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
2022-01-14 12:47:53 +08:00
# else
IM_UNUSED ( scancode ) ;
2022-01-05 23:54:03 +08:00
# endif
2021-12-12 19:00:31 +08:00
return key ;
}
2022-01-05 23:54:03 +08:00
2021-12-12 19:00:31 +08:00
void ImGui_ImplGlfw_KeyCallback ( GLFWwindow * window , int keycode , int scancode , int action , int mods )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackKey ! = nullptr & & window = = bd - > Window )
2021-12-12 19:00:31 +08:00
bd - > PrevUserCallbackKey ( window , keycode , scancode , action , mods ) ;
2018-06-09 01:37:33 +08:00
2021-12-12 19:00:31 +08:00
if ( action ! = GLFW_PRESS & & action ! = GLFW_RELEASE )
return ;
2022-03-23 21:01:57 +08:00
// Workaround: X11 does not include current pressed/released modifier key in 'mods' flags. https://github.com/glfw/glfw/issues/1630
if ( int keycode_to_mod = ImGui_ImplGlfw_KeyToModifier ( keycode ) )
mods = ( action = = GLFW_PRESS ) ? ( mods | keycode_to_mod ) : ( mods & ~ keycode_to_mod ) ;
2022-01-17 21:57:55 +08:00
ImGui_ImplGlfw_UpdateKeyModifiers ( mods ) ;
2021-12-12 19:00:31 +08:00
keycode = ImGui_ImplGlfw_TranslateUntranslatedKey ( keycode , scancode ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey ( keycode ) ;
io . AddKeyEvent ( imgui_key , ( action = = GLFW_PRESS ) ) ;
io . SetKeyEventNativeData ( imgui_key , keycode , scancode ) ; // To support legacy indexing (<1.87 user code)
2018-06-09 01:37:33 +08:00
}
2021-08-03 02:17:26 +08:00
void ImGui_ImplGlfw_WindowFocusCallback ( GLFWwindow * window , int focused )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackWindowFocus ! = nullptr & & window = = bd - > Window )
2021-08-03 02:17:26 +08:00
bd - > PrevUserCallbackWindowFocus ( window , focused ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
io . AddFocusEvent ( focused ! = 0 ) ;
}
2022-01-13 00:08:37 +08:00
void ImGui_ImplGlfw_CursorPosCallback ( GLFWwindow * window , double x , double y )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackCursorPos ! = nullptr & & window = = bd - > Window )
2022-01-13 00:08:37 +08:00
bd - > PrevUserCallbackCursorPos ( window , x , y ) ;
2022-09-02 02:44:50 +08:00
if ( glfwGetInputMode ( window , GLFW_CURSOR ) = = GLFW_CURSOR_DISABLED )
return ;
2022-01-13 00:08:37 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( ( float ) x , ( float ) y ) ;
2022-02-07 23:00:13 +08:00
bd - > LastValidMousePos = ImVec2 ( ( float ) x , ( float ) y ) ;
2022-01-13 00:08:37 +08:00
}
2022-02-07 22:59:28 +08:00
// Workaround: X11 seems to send spurious Leave/Enter events which would make us lose our position,
// so we back it up and restore on Leave/Enter (see https://github.com/ocornut/imgui/issues/4984)
2021-07-30 00:59:45 +08:00
void ImGui_ImplGlfw_CursorEnterCallback ( GLFWwindow * window , int entered )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackCursorEnter ! = nullptr & & window = = bd - > Window )
2021-07-30 00:59:45 +08:00
bd - > PrevUserCallbackCursorEnter ( window , entered ) ;
2022-09-02 02:44:50 +08:00
if ( glfwGetInputMode ( window , GLFW_CURSOR ) = = GLFW_CURSOR_DISABLED )
return ;
2021-08-03 02:17:26 +08:00
2022-01-13 00:08:37 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-07-30 00:59:45 +08:00
if ( entered )
2022-02-07 22:59:28 +08:00
{
2021-07-30 00:59:45 +08:00
bd - > MouseWindow = window ;
2022-02-07 23:00:13 +08:00
io . AddMousePosEvent ( bd - > LastValidMousePos . x , bd - > LastValidMousePos . y ) ;
2022-02-07 22:59:28 +08:00
}
else if ( ! entered & & bd - > MouseWindow = = window )
2022-01-13 00:08:37 +08:00
{
2022-02-07 23:00:13 +08:00
bd - > LastValidMousePos = io . MousePos ;
2022-10-11 18:22:29 +08:00
bd - > MouseWindow = nullptr ;
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( - FLT_MAX , - FLT_MAX ) ;
2022-01-13 00:08:37 +08:00
}
2021-07-30 00:59:45 +08:00
}
2018-11-08 23:24:41 +08:00
void ImGui_ImplGlfw_CharCallback ( GLFWwindow * window , unsigned int c )
2018-06-09 01:37:33 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
if ( bd - > PrevUserCallbackChar ! = nullptr & & window = = bd - > Window )
2021-06-28 22:52:10 +08:00
bd - > PrevUserCallbackChar ( window , c ) ;
2018-11-08 23:24:41 +08:00
2018-06-09 01:37:33 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2019-05-11 16:33:56 +08:00
io . AddInputCharacter ( c ) ;
2018-06-09 01:37:33 +08:00
}
2021-07-07 20:12:48 +08:00
void ImGui_ImplGlfw_MonitorCallback ( GLFWmonitor * , int )
{
// Unused in 'master' branch but 'docking' branch will use this, so we declare it ahead of it so if you have to install callbacks you can install this one too.
}
2022-02-07 23:00:13 +08:00
void ImGui_ImplGlfw_InstallCallbacks ( GLFWwindow * window )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
IM_ASSERT ( bd - > InstalledCallbacks = = false & & " Callbacks already installed! " ) ;
IM_ASSERT ( bd - > Window = = window ) ;
bd - > PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback ( window , ImGui_ImplGlfw_WindowFocusCallback ) ;
bd - > PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback ( window , ImGui_ImplGlfw_CursorEnterCallback ) ;
bd - > PrevUserCallbackCursorPos = glfwSetCursorPosCallback ( window , ImGui_ImplGlfw_CursorPosCallback ) ;
bd - > PrevUserCallbackMousebutton = glfwSetMouseButtonCallback ( window , ImGui_ImplGlfw_MouseButtonCallback ) ;
bd - > PrevUserCallbackScroll = glfwSetScrollCallback ( window , ImGui_ImplGlfw_ScrollCallback ) ;
bd - > PrevUserCallbackKey = glfwSetKeyCallback ( window , ImGui_ImplGlfw_KeyCallback ) ;
bd - > PrevUserCallbackChar = glfwSetCharCallback ( window , ImGui_ImplGlfw_CharCallback ) ;
bd - > PrevUserCallbackMonitor = glfwSetMonitorCallback ( ImGui_ImplGlfw_MonitorCallback ) ;
bd - > InstalledCallbacks = true ;
}
void ImGui_ImplGlfw_RestoreCallbacks ( GLFWwindow * window )
{
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
IM_ASSERT ( bd - > InstalledCallbacks = = true & & " Callbacks not installed! " ) ;
IM_ASSERT ( bd - > Window = = window ) ;
glfwSetWindowFocusCallback ( window , bd - > PrevUserCallbackWindowFocus ) ;
glfwSetCursorEnterCallback ( window , bd - > PrevUserCallbackCursorEnter ) ;
glfwSetCursorPosCallback ( window , bd - > PrevUserCallbackCursorPos ) ;
glfwSetMouseButtonCallback ( window , bd - > PrevUserCallbackMousebutton ) ;
glfwSetScrollCallback ( window , bd - > PrevUserCallbackScroll ) ;
glfwSetKeyCallback ( window , bd - > PrevUserCallbackKey ) ;
glfwSetCharCallback ( window , bd - > PrevUserCallbackChar ) ;
glfwSetMonitorCallback ( bd - > PrevUserCallbackMonitor ) ;
bd - > InstalledCallbacks = false ;
2022-10-11 18:22:29 +08:00
bd - > PrevUserCallbackWindowFocus = nullptr ;
bd - > PrevUserCallbackCursorEnter = nullptr ;
bd - > PrevUserCallbackCursorPos = nullptr ;
bd - > PrevUserCallbackMousebutton = nullptr ;
bd - > PrevUserCallbackScroll = nullptr ;
bd - > PrevUserCallbackKey = nullptr ;
bd - > PrevUserCallbackChar = nullptr ;
bd - > PrevUserCallbackMonitor = nullptr ;
2022-02-07 23:00:13 +08:00
}
2018-06-09 01:37:33 +08:00
static bool ImGui_ImplGlfw_Init ( GLFWwindow * window , bool install_callbacks , GlfwClientApi client_api )
{
2021-06-28 22:52:10 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( io . BackendPlatformUserData = = nullptr & & " Already initialized a platform backend! " ) ;
2022-10-18 18:17:59 +08:00
//printf("GLFW_VERSION: %d.%d.%d (%d)", GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION, GLFW_VERSION_COMBINED);
2021-06-28 22:52:10 +08:00
2020-10-12 23:34:22 +08:00
// Setup backend capabilities flags
2021-06-30 21:22:15 +08:00
ImGui_ImplGlfw_Data * bd = IM_NEW ( ImGui_ImplGlfw_Data ) ( ) ;
2021-06-28 22:52:10 +08:00
io . BackendPlatformUserData = ( void * ) bd ;
io . BackendPlatformName = " imgui_impl_glfw " ;
2018-06-09 01:37:33 +08:00
io . BackendFlags | = ImGuiBackendFlags_HasMouseCursors ; // We can honor GetMouseCursor() values (optional)
io . BackendFlags | = ImGuiBackendFlags_HasSetMousePos ; // We can honor io.WantSetMousePos requests (optional, rarely used)
2021-06-30 21:22:15 +08:00
bd - > Window = window ;
bd - > Time = 0.0 ;
2018-06-09 01:37:33 +08:00
io . SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText ;
io . GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText ;
2021-06-28 22:52:10 +08:00
io . ClipboardUserData = bd - > Window ;
2022-01-05 20:03:48 +08:00
// Set platform dependent data in viewport
2018-06-09 01:37:33 +08:00
# if defined(_WIN32)
2022-01-05 20:03:48 +08:00
ImGui : : GetMainViewport ( ) - > PlatformHandleRaw = ( void * ) glfwGetWin32Window ( bd - > Window ) ;
2018-06-09 01:37:33 +08:00
# endif
2020-01-17 18:36:56 +08:00
// Create mouse cursors
// (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
// GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
2022-10-11 18:22:29 +08:00
// Missing cursors will return nullptr and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
GLFWerrorfun prev_error_callback = glfwSetErrorCallback ( nullptr ) ;
2021-06-28 22:52:10 +08:00
bd - > MouseCursors [ ImGuiMouseCursor_Arrow ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_TextInput ] = glfwCreateStandardCursor ( GLFW_IBEAM_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNS ] = glfwCreateStandardCursor ( GLFW_VRESIZE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeEW ] = glfwCreateStandardCursor ( GLFW_HRESIZE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_Hand ] = glfwCreateStandardCursor ( GLFW_HAND_CURSOR ) ;
2019-12-02 16:36:59 +08:00
# if GLFW_HAS_NEW_CURSORS
2021-06-28 22:52:10 +08:00
bd - > MouseCursors [ ImGuiMouseCursor_ResizeAll ] = glfwCreateStandardCursor ( GLFW_RESIZE_ALL_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNESW ] = glfwCreateStandardCursor ( GLFW_RESIZE_NESW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNWSE ] = glfwCreateStandardCursor ( GLFW_RESIZE_NWSE_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_NotAllowed ] = glfwCreateStandardCursor ( GLFW_NOT_ALLOWED_CURSOR ) ;
2019-12-02 16:36:59 +08:00
# else
2021-06-28 22:52:10 +08:00
bd - > MouseCursors [ ImGuiMouseCursor_ResizeAll ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNESW ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_ResizeNWSE ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
bd - > MouseCursors [ ImGuiMouseCursor_NotAllowed ] = glfwCreateStandardCursor ( GLFW_ARROW_CURSOR ) ;
2022-10-18 18:17:59 +08:00
# endif
# if (GLFW_VERSION_COMBINED >= 3300) // Eat errors (see #5785)
( void ) glfwGetError ( NULL ) ;
2019-12-02 16:36:59 +08:00
# endif
2020-01-17 18:36:56 +08:00
glfwSetErrorCallback ( prev_error_callback ) ;
2019-01-21 00:56:17 +08:00
2018-11-08 23:24:41 +08:00
// Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
2018-06-09 01:37:33 +08:00
if ( install_callbacks )
2022-02-07 23:00:13 +08:00
ImGui_ImplGlfw_InstallCallbacks ( window ) ;
2018-06-09 01:37:33 +08:00
2021-06-28 22:52:10 +08:00
bd - > ClientApi = client_api ;
2018-06-09 01:37:33 +08:00
return true ;
}
bool ImGui_ImplGlfw_InitForOpenGL ( GLFWwindow * window , bool install_callbacks )
{
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_OpenGL ) ;
}
bool ImGui_ImplGlfw_InitForVulkan ( GLFWwindow * window , bool install_callbacks )
{
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_Vulkan ) ;
}
2021-02-11 00:27:33 +08:00
bool ImGui_ImplGlfw_InitForOther ( GLFWwindow * window , bool install_callbacks )
2021-01-28 19:11:26 +08:00
{
2021-02-11 00:27:33 +08:00
return ImGui_ImplGlfw_Init ( window , install_callbacks , GlfwClientApi_Unknown ) ;
2021-01-28 19:11:26 +08:00
}
2018-06-09 01:37:33 +08:00
void ImGui_ImplGlfw_Shutdown ( )
{
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( bd ! = nullptr & & " No platform backend to shutdown, or already shutdown? " ) ;
2021-09-21 00:43:05 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 22:52:10 +08:00
if ( bd - > InstalledCallbacks )
2022-02-07 23:00:13 +08:00
ImGui_ImplGlfw_RestoreCallbacks ( bd - > Window ) ;
2019-10-18 22:25:18 +08:00
2018-06-20 17:06:29 +08:00
for ( ImGuiMouseCursor cursor_n = 0 ; cursor_n < ImGuiMouseCursor_COUNT ; cursor_n + + )
2021-06-28 22:52:10 +08:00
glfwDestroyCursor ( bd - > MouseCursors [ cursor_n ] ) ;
2022-10-11 18:22:29 +08:00
io . BackendPlatformName = nullptr ;
io . BackendPlatformUserData = nullptr ;
2021-06-30 21:22:15 +08:00
IM_DELETE ( bd ) ;
2018-06-09 01:37:33 +08:00
}
2022-01-13 00:08:37 +08:00
static void ImGui_ImplGlfw_UpdateMouseData ( )
2018-06-09 01:37:33 +08:00
{
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2018-06-09 01:37:33 +08:00
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-08-02 21:48:20 +08:00
2022-09-02 02:44:50 +08:00
if ( glfwGetInputMode ( bd - > Window , GLFW_CURSOR ) = = GLFW_CURSOR_DISABLED )
{
io . AddMousePosEvent ( - FLT_MAX , - FLT_MAX ) ;
return ;
}
2018-08-01 17:34:17 +08:00
# ifdef __EMSCRIPTEN__
2022-01-13 00:08:37 +08:00
const bool is_app_focused = true ;
2018-08-01 17:34:17 +08:00
# else
2022-01-13 00:08:37 +08:00
const bool is_app_focused = glfwGetWindowAttrib ( bd - > Window , GLFW_FOCUSED ) ! = 0 ;
2018-08-01 17:34:17 +08:00
# endif
2022-01-13 00:08:37 +08:00
if ( is_app_focused )
{
// (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if ( io . WantSetMousePos )
glfwSetCursorPos ( bd - > Window , ( double ) io . MousePos . x , ( double ) io . MousePos . y ) ;
// (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
2022-10-11 18:22:29 +08:00
if ( is_app_focused & & bd - > MouseWindow = = nullptr )
2022-01-13 00:08:37 +08:00
{
double mouse_x , mouse_y ;
glfwGetCursorPos ( bd - > Window , & mouse_x , & mouse_y ) ;
2022-01-18 00:22:37 +08:00
io . AddMousePosEvent ( ( float ) mouse_x , ( float ) mouse_y ) ;
2022-02-07 23:00:13 +08:00
bd - > LastValidMousePos = ImVec2 ( ( float ) mouse_x , ( float ) mouse_y ) ;
2022-01-13 00:08:37 +08:00
}
}
2018-06-09 01:37:33 +08:00
}
static void ImGui_ImplGlfw_UpdateMouseCursor ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
if ( ( io . ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange ) | | glfwGetInputMode ( bd - > Window , GLFW_CURSOR ) = = GLFW_CURSOR_DISABLED )
2018-06-09 01:37:33 +08:00
return ;
ImGuiMouseCursor imgui_cursor = ImGui : : GetMouseCursor ( ) ;
if ( imgui_cursor = = ImGuiMouseCursor_None | | io . MouseDrawCursor )
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
2021-06-28 22:52:10 +08:00
glfwSetInputMode ( bd - > Window , GLFW_CURSOR , GLFW_CURSOR_HIDDEN ) ;
2018-06-09 01:37:33 +08:00
}
else
{
// Show OS mouse cursor
// FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
2021-06-28 22:52:10 +08:00
glfwSetCursor ( bd - > Window , bd - > MouseCursors [ imgui_cursor ] ? bd - > MouseCursors [ imgui_cursor ] : bd - > MouseCursors [ ImGuiMouseCursor_Arrow ] ) ;
glfwSetInputMode ( bd - > Window , GLFW_CURSOR , GLFW_CURSOR_NORMAL ) ;
2018-06-09 01:37:33 +08:00
}
}
2022-01-21 00:12:22 +08:00
// Update gamepad inputs
static inline float Saturate ( float v ) { return v < 0.0f ? 0.0f : v > 1.0f ? 1.0f : v ; }
2019-02-15 01:55:08 +08:00
static void ImGui_ImplGlfw_UpdateGamepads ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2022-07-25 23:16:01 +08:00
if ( ( io . ConfigFlags & ImGuiConfigFlags_NavEnableGamepad ) = = 0 ) // FIXME: Technically feeding gamepad shouldn't depend on this now that they are regular inputs.
2019-02-15 01:55:08 +08:00
return ;
2022-01-21 00:12:22 +08:00
io . BackendFlags & = ~ ImGuiBackendFlags_HasGamepad ;
# if GLFW_HAS_GAMEPAD_API
GLFWgamepadstate gamepad ;
if ( ! glfwGetGamepadState ( GLFW_JOYSTICK_1 , & gamepad ) )
return ;
2022-01-21 00:39:25 +08:00
# define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED) do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
# define MAP_ANALOG(KEY_NO, AXIS_NO, _UNUSED, V0, V1) do { float v = gamepad.axes[AXIS_NO]; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
2022-01-21 00:12:22 +08:00
# else
2019-02-15 01:55:08 +08:00
int axes_count = 0 , buttons_count = 0 ;
const float * axes = glfwGetJoystickAxes ( GLFW_JOYSTICK_1 , & axes_count ) ;
const unsigned char * buttons = glfwGetJoystickButtons ( GLFW_JOYSTICK_1 , & buttons_count ) ;
2022-01-21 00:12:22 +08:00
if ( axes_count = = 0 | | buttons_count = = 0 )
return ;
2022-01-21 00:39:25 +08:00
# define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO) do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
# define MAP_ANALOG(KEY_NO, _UNUSED, AXIS_NO, V0, V1) do { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
2022-01-21 00:12:22 +08:00
# endif
io . BackendFlags | = ImGuiBackendFlags_HasGamepad ;
MAP_BUTTON ( ImGuiKey_GamepadStart , GLFW_GAMEPAD_BUTTON_START , 7 ) ;
MAP_BUTTON ( ImGuiKey_GamepadBack , GLFW_GAMEPAD_BUTTON_BACK , 6 ) ;
MAP_BUTTON ( ImGuiKey_GamepadFaceLeft , GLFW_GAMEPAD_BUTTON_X , 2 ) ; // Xbox X, PS Square
2022-07-06 23:13:10 +08:00
MAP_BUTTON ( ImGuiKey_GamepadFaceRight , GLFW_GAMEPAD_BUTTON_B , 1 ) ; // Xbox B, PS Circle
2022-01-21 00:12:22 +08:00
MAP_BUTTON ( ImGuiKey_GamepadFaceUp , GLFW_GAMEPAD_BUTTON_Y , 3 ) ; // Xbox Y, PS Triangle
2022-07-06 23:13:10 +08:00
MAP_BUTTON ( ImGuiKey_GamepadFaceDown , GLFW_GAMEPAD_BUTTON_A , 0 ) ; // Xbox A, PS Cross
2022-01-21 00:12:22 +08:00
MAP_BUTTON ( ImGuiKey_GamepadDpadLeft , GLFW_GAMEPAD_BUTTON_DPAD_LEFT , 13 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadRight , GLFW_GAMEPAD_BUTTON_DPAD_RIGHT , 11 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadUp , GLFW_GAMEPAD_BUTTON_DPAD_UP , 10 ) ;
MAP_BUTTON ( ImGuiKey_GamepadDpadDown , GLFW_GAMEPAD_BUTTON_DPAD_DOWN , 12 ) ;
MAP_BUTTON ( ImGuiKey_GamepadL1 , GLFW_GAMEPAD_BUTTON_LEFT_BUMPER , 4 ) ;
MAP_BUTTON ( ImGuiKey_GamepadR1 , GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER , 5 ) ;
MAP_ANALOG ( ImGuiKey_GamepadL2 , GLFW_GAMEPAD_AXIS_LEFT_TRIGGER , 4 , - 0.75f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadR2 , GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER , 5 , - 0.75f , + 1.0f ) ;
MAP_BUTTON ( ImGuiKey_GamepadL3 , GLFW_GAMEPAD_BUTTON_LEFT_THUMB , 8 ) ;
MAP_BUTTON ( ImGuiKey_GamepadR3 , GLFW_GAMEPAD_BUTTON_RIGHT_THUMB , 9 ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickLeft , GLFW_GAMEPAD_AXIS_LEFT_X , 0 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickRight , GLFW_GAMEPAD_AXIS_LEFT_X , 0 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickUp , GLFW_GAMEPAD_AXIS_LEFT_Y , 1 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadLStickDown , GLFW_GAMEPAD_AXIS_LEFT_Y , 1 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickLeft , GLFW_GAMEPAD_AXIS_RIGHT_X , 2 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickRight , GLFW_GAMEPAD_AXIS_RIGHT_X , 2 , + 0.25f , + 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickUp , GLFW_GAMEPAD_AXIS_RIGHT_Y , 3 , - 0.25f , - 1.0f ) ;
MAP_ANALOG ( ImGuiKey_GamepadRStickDown , GLFW_GAMEPAD_AXIS_RIGHT_Y , 3 , + 0.25f , + 1.0f ) ;
2019-02-15 01:55:08 +08:00
# undef MAP_BUTTON
# undef MAP_ANALOG
}
2018-06-09 01:37:33 +08:00
void ImGui_ImplGlfw_NewFrame ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2021-06-28 22:52:10 +08:00
ImGui_ImplGlfw_Data * bd = ImGui_ImplGlfw_GetBackendData ( ) ;
2022-10-11 18:22:29 +08:00
IM_ASSERT ( bd ! = nullptr & & " Did you call ImGui_ImplGlfw_InitForXXX()? " ) ;
2018-06-09 01:37:33 +08:00
2018-12-24 00:39:04 +08:00
// Setup display size (every frame to accommodate for window resizing)
2018-06-09 01:37:33 +08:00
int w , h ;
int display_w , display_h ;
2021-06-28 22:52:10 +08:00
glfwGetWindowSize ( bd - > Window , & w , & h ) ;
glfwGetFramebufferSize ( bd - > Window , & display_w , & display_h ) ;
2018-06-09 01:37:33 +08:00
io . DisplaySize = ImVec2 ( ( float ) w , ( float ) h ) ;
2019-03-13 01:27:14 +08:00
if ( w > 0 & & h > 0 )
2021-12-29 19:41:34 +08:00
io . DisplayFramebufferScale = ImVec2 ( ( float ) display_w / ( float ) w , ( float ) display_h / ( float ) h ) ;
2018-06-09 01:37:33 +08:00
// Setup time step
double current_time = glfwGetTime ( ) ;
2021-06-28 22:52:10 +08:00
io . DeltaTime = bd - > Time > 0.0 ? ( float ) ( current_time - bd - > Time ) : ( float ) ( 1.0f / 60.0f ) ;
bd - > Time = current_time ;
2018-06-09 01:37:33 +08:00
2022-01-13 00:08:37 +08:00
ImGui_ImplGlfw_UpdateMouseData ( ) ;
2018-06-09 01:37:33 +08:00
ImGui_ImplGlfw_UpdateMouseCursor ( ) ;
2019-04-23 18:26:14 +08:00
// Update game controllers (if enabled and available)
2019-02-15 01:55:08 +08:00
ImGui_ImplGlfw_UpdateGamepads ( ) ;
2018-06-09 01:37:33 +08:00
}
2021-12-29 19:41:34 +08:00
# if defined(__clang__)
# pragma clang diagnostic pop
# endif