From ebfa7edeb1903dc419bb68845f61f67b160e1992 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sat, 16 Aug 2025 14:32:52 +1000 Subject: [PATCH] Cleanup: use snake case, replace "m_" prefix with "_" suffix Follow our own C++ conventions for GHOST. --- intern/ghost/GHOST_C-api.h | 40 +- intern/ghost/GHOST_ISystem.hh | 36 +- intern/ghost/GHOST_ISystemPaths.hh | 2 +- intern/ghost/GHOST_ITimerTask.hh | 10 +- intern/ghost/GHOST_IWindow.hh | 28 +- intern/ghost/GHOST_Rect.hh | 84 +-- intern/ghost/GHOST_Types.h | 14 +- intern/ghost/intern/GHOST_Buttons.cc | 42 +- intern/ghost/intern/GHOST_Buttons.hh | 14 +- intern/ghost/intern/GHOST_C-api.cc | 39 +- .../intern/GHOST_CallbackEventConsumer.cc | 8 +- .../intern/GHOST_CallbackEventConsumer.hh | 8 +- intern/ghost/intern/GHOST_Context.hh | 16 +- intern/ghost/intern/GHOST_ContextD3D.cc | 156 ++--- intern/ghost/intern/GHOST_ContextD3D.hh | 8 +- intern/ghost/intern/GHOST_ContextEGL.cc | 241 ++++---- intern/ghost/intern/GHOST_ContextEGL.hh | 40 +- intern/ghost/intern/GHOST_ContextGLX.cc | 120 ++-- intern/ghost/intern/GHOST_ContextGLX.hh | 22 +- intern/ghost/intern/GHOST_ContextMTL.hh | 16 +- intern/ghost/intern/GHOST_ContextMTL.mm | 112 ++-- intern/ghost/intern/GHOST_ContextNone.cc | 6 +- intern/ghost/intern/GHOST_ContextNone.hh | 6 +- intern/ghost/intern/GHOST_ContextSDL.cc | 84 +-- intern/ghost/intern/GHOST_ContextSDL.hh | 20 +- intern/ghost/intern/GHOST_ContextVK.cc | 238 ++++---- intern/ghost/intern/GHOST_ContextVK.hh | 48 +- intern/ghost/intern/GHOST_ContextWGL.cc | 124 ++-- intern/ghost/intern/GHOST_ContextWGL.hh | 28 +- intern/ghost/intern/GHOST_DropTargetWin32.cc | 40 +- intern/ghost/intern/GHOST_DropTargetWin32.hh | 10 +- intern/ghost/intern/GHOST_DropTargetX11.cc | 86 +-- intern/ghost/intern/GHOST_DropTargetX11.hh | 18 +- intern/ghost/intern/GHOST_Event.hh | 18 +- intern/ghost/intern/GHOST_EventButton.hh | 6 +- intern/ghost/intern/GHOST_EventCursor.hh | 6 +- intern/ghost/intern/GHOST_EventDragnDrop.hh | 22 +- intern/ghost/intern/GHOST_EventKey.hh | 20 +- intern/ghost/intern/GHOST_EventManager.cc | 69 ++- intern/ghost/intern/GHOST_EventManager.hh | 6 +- intern/ghost/intern/GHOST_EventNDOF.hh | 8 +- intern/ghost/intern/GHOST_EventString.hh | 6 +- intern/ghost/intern/GHOST_EventTrackpad.hh | 16 +- intern/ghost/intern/GHOST_EventWheel.hh | 8 +- intern/ghost/intern/GHOST_ISystem.cc | 78 +-- intern/ghost/intern/GHOST_ISystemPaths.cc | 22 +- intern/ghost/intern/GHOST_ImeWin32.cc | 8 +- intern/ghost/intern/GHOST_ImeWin32.hh | 2 +- intern/ghost/intern/GHOST_ModifierKeys.cc | 70 +-- intern/ghost/intern/GHOST_ModifierKeys.hh | 20 +- intern/ghost/intern/GHOST_Rect.cc | 70 +-- intern/ghost/intern/GHOST_System.cc | 122 ++-- intern/ghost/intern/GHOST_System.hh | 40 +- intern/ghost/intern/GHOST_SystemCocoa.hh | 24 +- intern/ghost/intern/GHOST_SystemCocoa.mm | 176 +++--- intern/ghost/intern/GHOST_SystemHeadless.hh | 23 +- intern/ghost/intern/GHOST_SystemSDL.cc | 40 +- intern/ghost/intern/GHOST_SystemSDL.hh | 8 +- intern/ghost/intern/GHOST_SystemWayland.cc | 74 +-- intern/ghost/intern/GHOST_SystemWayland.hh | 8 +- intern/ghost/intern/GHOST_SystemWin32.cc | 116 ++-- intern/ghost/intern/GHOST_SystemWin32.hh | 38 +- intern/ghost/intern/GHOST_SystemX11.cc | 496 ++++++++-------- intern/ghost/intern/GHOST_SystemX11.hh | 44 +- intern/ghost/intern/GHOST_TimerManager.cc | 28 +- intern/ghost/intern/GHOST_TimerManager.hh | 2 +- intern/ghost/intern/GHOST_TimerTask.hh | 70 +-- intern/ghost/intern/GHOST_TrackpadWin32.cc | 73 +-- intern/ghost/intern/GHOST_TrackpadWin32.hh | 18 +- intern/ghost/intern/GHOST_Window.cc | 158 +++--- intern/ghost/intern/GHOST_Window.hh | 92 +-- intern/ghost/intern/GHOST_WindowCocoa.hh | 36 +- intern/ghost/intern/GHOST_WindowCocoa.mm | 390 ++++++------- intern/ghost/intern/GHOST_WindowManager.cc | 31 +- intern/ghost/intern/GHOST_WindowManager.hh | 4 +- intern/ghost/intern/GHOST_WindowNULL.hh | 4 +- intern/ghost/intern/GHOST_WindowSDL.cc | 98 ++-- intern/ghost/intern/GHOST_WindowSDL.hh | 16 +- intern/ghost/intern/GHOST_WindowViewCocoa.hh | 30 +- intern/ghost/intern/GHOST_WindowWayland.cc | 46 +- intern/ghost/intern/GHOST_WindowWayland.hh | 4 +- intern/ghost/intern/GHOST_WindowWin32.cc | 403 +++++++------ intern/ghost/intern/GHOST_WindowWin32.hh | 48 +- intern/ghost/intern/GHOST_WindowX11.cc | 535 +++++++++--------- intern/ghost/intern/GHOST_WindowX11.hh | 48 +- intern/ghost/intern/GHOST_Wintab.cc | 198 +++---- intern/ghost/intern/GHOST_Wintab.hh | 42 +- intern/ghost/intern/GHOST_XrAction.cc | 162 +++--- intern/ghost/intern/GHOST_XrAction.hh | 32 +- intern/ghost/intern/GHOST_XrContext.cc | 181 +++--- intern/ghost/intern/GHOST_XrContext.hh | 18 +- .../ghost/intern/GHOST_XrControllerModel.cc | 72 +-- .../ghost/intern/GHOST_XrControllerModel.hh | 18 +- intern/ghost/intern/GHOST_XrException.hh | 9 +- .../ghost/intern/GHOST_XrGraphicsBinding.cc | 44 +- .../intern/GHOST_XrGraphicsBindingD3D.cc | 52 +- .../intern/GHOST_XrGraphicsBindingD3D.hh | 10 +- .../intern/GHOST_XrGraphicsBindingVulkan.cc | 190 +++---- .../intern/GHOST_XrGraphicsBindingVulkan.hh | 30 +- intern/ghost/intern/GHOST_XrSession.cc | 314 +++++----- intern/ghost/intern/GHOST_XrSession.hh | 10 +- intern/ghost/intern/GHOST_XrSwapchain.cc | 46 +- intern/ghost/intern/GHOST_XrSwapchain.hh | 8 +- intern/ghost/test/gears/GHOST_C-Test.c | 10 +- intern/ghost/test/gears/GHOST_Test.cpp | 98 ++-- intern/ghost/test/multitest/MultiTest.c | 12 +- source/blender/gpu/tests/gpu_testing.cc | 8 +- .../windowmanager/intern/wm_playanim.cc | 16 +- .../blender/windowmanager/intern/wm_window.cc | 38 +- 109 files changed, 3571 insertions(+), 3609 deletions(-) diff --git a/intern/ghost/GHOST_C-api.h b/intern/ghost/GHOST_C-api.h index 7a93e87e340..758d65acc01 100644 --- a/intern/ghost/GHOST_C-api.h +++ b/intern/ghost/GHOST_C-api.h @@ -93,16 +93,16 @@ extern uint64_t GHOST_GetMilliSeconds(GHOST_SystemHandle systemhandle); * Note that, on most operating systems, messages need to be processed in order * for the timer callbacks to be invoked. * \param systemhandle: The handle to the system. - * \param delay: The time to wait for the first call to the timerProc (in milliseconds). - * \param interval: The interval between calls to the timerProc (in milliseconds). - * \param timerProc: The callback invoked when the interval expires. - * \param userData: Placeholder for user data. + * \param delay: The time to wait for the first call to the timer_proc (in milliseconds). + * \param interval: The interval between calls to the timer_proc (in milliseconds). + * \param timer_proc: The callback invoked when the interval expires. + * \param user_data: Placeholder for user data. * \return A timer task (0 if timer task installation failed). */ extern GHOST_TimerTaskHandle GHOST_InstallTimer(GHOST_SystemHandle systemhandle, uint64_t delay, uint64_t interval, - GHOST_TimerProcPtr timerProc, + GHOST_TimerProcPtr timer_proc, GHOST_TUserDataPtr user_data); /** @@ -162,7 +162,7 @@ extern GHOST_TSuccess GHOST_GetAllDisplayDimensions(GHOST_SystemHandle systemhan * \param height: The height the window. * \param state: The state of the window when opened. * \param is_dialog: Stay on top of parent window, no icon in taskbar, can't be minimized. - * \param gpuSettings: Misc GPU options. + * \param gpu_settings: Misc GPU options. * \return A handle to the new window ( == nullptr if creation failed). */ extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle, @@ -174,17 +174,17 @@ extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle, uint32_t height, GHOST_TWindowState state, bool is_dialog, - GHOST_GPUSettings gpuSettings); + GHOST_GPUSettings gpu_settings); /** * Create a new off-screen context. * Never explicitly delete the context, use #disposeContext() instead. * \param systemhandle: The handle to the system. - * \param gpuSettings: Misc GPU options. + * \param gpu_settings: Misc GPU options. * \return A handle to the new context ( == nullptr if creation failed). */ extern GHOST_ContextHandle GHOST_CreateGPUContext(GHOST_SystemHandle systemhandle, - GHOST_GPUSettings gpuSettings); + GHOST_GPUSettings gpu_settings); /** * Dispose of a context. @@ -433,7 +433,7 @@ extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle, * Returns the state of a modifier key (outside the message queue). * \param systemhandle: The handle to the system. * \param mask: The modifier key state to retrieve. - * \param isDown: Pointer to return modifier state in. + * \param is_down: Pointer to return modifier state in. * \return Indication of success. */ extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle, @@ -444,7 +444,7 @@ extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle, * Returns the state of a mouse button (outside the message queue). * \param systemhandle: The handle to the system. * \param mask: The button state to retrieve. - * \param isDown: Pointer to return button state in. + * \param is_down: Pointer to return button state in. * \return Indication of success. */ extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle, @@ -511,10 +511,10 @@ extern GHOST_TimerProcPtr GHOST_GetTimerProc(GHOST_TimerTaskHandle timertaskhand /** * Changes the timer callback. * \param timertaskhandle: The handle to the timer-task. - * \param timerProc: The timer callback. + * \param timer_proc: The timer callback. */ extern void GHOST_SetTimerProc(GHOST_TimerTaskHandle timertaskhandle, - GHOST_TimerProcPtr timerProc); + GHOST_TimerProcPtr timer_proc); /** * Returns the timer user data. @@ -592,17 +592,17 @@ extern GHOST_TWindowDecorationStyleFlags GHOST_GetWindowDecorationStyleFlags( /** * Set the window decoration style flags. - * \param styleFlags: Window decoration style flags. + * \param style_flags: Window decoration style flags. */ extern void GHOST_SetWindowDecorationStyleFlags(GHOST_WindowHandle windowhandle, - GHOST_TWindowDecorationStyleFlags styleFlags); + GHOST_TWindowDecorationStyleFlags style_flags); /** * Set the window decoration style settings. - * \param decorationSettings: Window decoration style settings. + * \param decoration_settings: Window decoration style settings. */ extern void GHOST_SetWindowDecorationStyleSettings( - GHOST_WindowHandle windowhandle, GHOST_WindowDecorationStyleSettings decorationSettings); + GHOST_WindowHandle windowhandle, GHOST_WindowDecorationStyleSettings decoration_settings); /** * Apply the window decoration style using the current flags and settings. @@ -699,11 +699,11 @@ extern GHOST_TSuccess GHOST_SetWindowState(GHOST_WindowHandle windowhandle, /** * Sets the window "modified" status, indicating unsaved changes. * \param windowhandle: The handle to the window. - * \param isUnsavedChanges: Unsaved changes or not. + * \param is_unsaved_changes: Unsaved changes or not. * \return Indication of success. */ extern GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle, - bool isUnsavedChanges); + bool is_unsaved_changes); /** * Sets the order of the window (bottom, top). @@ -847,7 +847,7 @@ extern GHOST_TSuccess GHOST_IsEmptyRectangle(GHOST_RectangleHandle rectanglehand /** * Returns whether this rectangle is valid. - * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. + * Valid rectangles are rectangles that have l_ <= r_ and t_ <= b_. * Thus, empty rectangles are valid. * \param rectanglehandle: The handle to the rectangle. * \return Success value (true == valid rectangle) diff --git a/intern/ghost/GHOST_ISystem.hh b/intern/ghost/GHOST_ISystem.hh index 2a10e1b3581..810b4d0418e 100644 --- a/intern/ghost/GHOST_ISystem.hh +++ b/intern/ghost/GHOST_ISystem.hh @@ -184,16 +184,16 @@ class GHOST_ISystem { * \note On most operating systems, messages need to be processed in order * for the timer callbacks to be invoked. * - * \param delay: The time to wait for the first call to the #timerProc (in milliseconds). - * \param interval: The interval between calls to the #timerProc. - * \param timerProc: The callback invoked when the interval expires. - * \param userData: Placeholder for user data. + * \param delay: The time to wait for the first call to the #timer_proc (in milliseconds). + * \param interval: The interval between calls to the #timer_proc. + * \param timer_proc: The callback invoked when the interval expires. + * \param user_data: Placeholder for user data. * \return A timer task (0 if timer task installation failed). */ virtual GHOST_ITimerTask *installTimer(uint64_t delay, uint64_t interval, - GHOST_TimerProcPtr timerProc, - GHOST_TUserDataPtr userData = nullptr) = 0; + GHOST_TimerProcPtr timer_proc, + GHOST_TUserDataPtr user_data = nullptr) = 0; /** * Removes a timer. @@ -235,10 +235,10 @@ class GHOST_ISystem { * \param width: The width the window. * \param height: The height the window. * \param state: The state of the window when opened. - * \param gpuSettings: Misc GPU settings. + * \param gpu_settings: Misc GPU settings. * \param exclusive: Use to show the window on top and ignore others (used full-screen). * \param is_dialog: Stay on top of parent window, no icon in taskbar, can't be minimized. - * \param parentWindow: Parent (embedder) window + * \param parent_window: Parent (embedder) window * \return The new window (or 0 if creation failed). */ virtual GHOST_IWindow *createWindow(const char *title, @@ -247,10 +247,10 @@ class GHOST_ISystem { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive = false, const bool is_dialog = false, - const GHOST_IWindow *parentWindow = nullptr) = 0; + const GHOST_IWindow *parent_window = nullptr) = 0; /** * Dispose a window. @@ -264,7 +264,7 @@ class GHOST_ISystem { * Never explicitly delete the context, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ - virtual GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) = 0; + virtual GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) = 0; /** * Dispose of a context. @@ -397,18 +397,18 @@ class GHOST_ISystem { /** * Returns the state of a modifier key (outside the message queue). * \param mask: The modifier key state to retrieve. - * \param isDown: The state of a modifier key (true == pressed). + * \param is_down: The state of a modifier key (true == pressed). * \return Indication of success. */ - virtual GHOST_TSuccess getModifierKeyState(GHOST_TModifierKey mask, bool &isDown) const = 0; + virtual GHOST_TSuccess getModifierKeyState(GHOST_TModifierKey mask, bool &is_down) const = 0; /** * Returns the state of a mouse button (outside the message queue). * \param mask: The button state to retrieve. - * \param isDown: Button state. + * \param is_down: Button state. * \return Indication of success. */ - virtual GHOST_TSuccess getButtonState(GHOST_TButton mask, bool &isDown) const = 0; + virtual GHOST_TSuccess getButtonState(GHOST_TButton mask, bool &is_down) const = 0; /** * Enable multi-touch gestures if supported. @@ -535,11 +535,11 @@ class GHOST_ISystem { virtual GHOST_TSuccess exit() = 0; /** The one and only system */ - static GHOST_ISystem *m_system; - static const char *m_system_backend_id; + static GHOST_ISystem *system_; + static const char *system_backend_id_; /** Function to call that sets the back-trace. */ - static GHOST_TBacktraceFn m_backtrace_fn; + static GHOST_TBacktraceFn backtrace_fn_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_ISystem") }; diff --git a/intern/ghost/GHOST_ISystemPaths.hh b/intern/ghost/GHOST_ISystemPaths.hh index 80c2f1acb03..3ca311390cf 100644 --- a/intern/ghost/GHOST_ISystemPaths.hh +++ b/intern/ghost/GHOST_ISystemPaths.hh @@ -80,7 +80,7 @@ class GHOST_ISystemPaths { private: /** The one and only system paths. */ - static GHOST_ISystemPaths *m_systemPaths; + static GHOST_ISystemPaths *system_paths_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_ISystemPaths") }; diff --git a/intern/ghost/GHOST_ITimerTask.hh b/intern/ghost/GHOST_ITimerTask.hh index 3d6a7594899..fc97ccfbd10 100644 --- a/intern/ghost/GHOST_ITimerTask.hh +++ b/intern/ghost/GHOST_ITimerTask.hh @@ -14,7 +14,7 @@ /** * Interface for a timer task. * Timer tasks are created by the system and can be installed by the system. - * After installation, the timer callback-procedure or "timerProc" will be called + * After installation, the timer callback-procedure or "timer_proc" will be called * periodically. You should not need to inherit this class. It is passed to the * application in the timer-callback.
*
@@ -38,9 +38,9 @@ class GHOST_ITimerTask { /** * Changes the timer callback. - * \param timerProc: The timer callback. + * \param timer_proc: The timer callback. */ - virtual void setTimerProc(const GHOST_TimerProcPtr timerProc) = 0; + virtual void setTimerProc(const GHOST_TimerProcPtr timer_proc) = 0; /** * Returns the timer user data. @@ -50,9 +50,9 @@ class GHOST_ITimerTask { /** * Changes the time user data. - * \param userData: The timer user data. + * \param user_data: The timer user data. */ - virtual void setUserData(const GHOST_TUserDataPtr userData) = 0; + virtual void setUserData(const GHOST_TUserDataPtr user_data) = 0; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_ITimerTask") }; diff --git a/intern/ghost/GHOST_IWindow.hh b/intern/ghost/GHOST_IWindow.hh index d11f9d6f89a..3b04edf2471 100644 --- a/intern/ghost/GHOST_IWindow.hh +++ b/intern/ghost/GHOST_IWindow.hh @@ -94,16 +94,16 @@ class GHOST_IWindow { /** * Set the window decoration style flags. - * \param styleFlags: Window decoration style flags. + * \param style_flags: Window decoration style flags. */ - virtual void setWindowDecorationStyleFlags(GHOST_TWindowDecorationStyleFlags styleFlags) = 0; + virtual void setWindowDecorationStyleFlags(GHOST_TWindowDecorationStyleFlags style_flags) = 0; /** * Set the window decoration style settings. - * \param decorationSettings: Window decoration style settings. + * \param decoration_settings: Window decoration style settings. */ virtual void setWindowDecorationStyleSettings( - GHOST_WindowDecorationStyleSettings decorationSettings) = 0; + GHOST_WindowDecorationStyleSettings decoration_settings) = 0; /** * Apply the window decoration style using the current flags and settings. @@ -164,7 +164,7 @@ class GHOST_IWindow { /** * Tells if the ongoing drag & drop object can be accepted upon mouse drop */ - virtual void setAcceptDragOperation(bool canAccept) = 0; + virtual void setAcceptDragOperation(bool can_accept) = 0; /** * Returns acceptance of the dropped object. @@ -187,10 +187,10 @@ class GHOST_IWindow { /** * Sets the window "modified" status, indicating unsaved changes. - * \param isUnsavedChanges: Unsaved changes or not. + * \param is_unsaved_changes: Unsaved changes or not. * \return Indication of success. */ - virtual GHOST_TSuccess setModifiedState(bool isUnsavedChanges) = 0; + virtual GHOST_TSuccess setModifiedState(bool is_unsaved_changes) = 0; /** * Gets the window "modified" status, indicating unsaved changes. @@ -220,11 +220,11 @@ class GHOST_IWindow { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: pointer to location to return swap interval. + * \param interval_out: pointer to location to return swap interval. * (left untouched if there is an error) * \return A boolean success indicator of if swap interval was successfully read. */ - virtual GHOST_TSuccess getSwapInterval(int &intervalOut) = 0; + virtual GHOST_TSuccess getSwapInterval(int &interval_out) = 0; /** * Activates the drawing context of this window. @@ -258,9 +258,9 @@ class GHOST_IWindow { /** * Changes the window user data. - * \param userData: The window user data. + * \param user_data: The window user data. */ - virtual void setUserData(const GHOST_TUserDataPtr userData) = 0; + virtual void setUserData(const GHOST_TUserDataPtr user_data) = 0; virtual bool isDialog() const = 0; @@ -291,10 +291,10 @@ class GHOST_IWindow { /** * Set the shape of the cursor. - * \param cursorShape: The new cursor shape type id. + * \param cursor_shape: The new cursor shape type id. * \return Indication of success. */ - virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape) = 0; + virtual GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursor_shape) = 0; /** * Gets the cursor grab region, if unset the window is used. @@ -316,7 +316,7 @@ class GHOST_IWindow { * Test if the standard cursor shape is supported by current platform. * \return Indication of success. */ - virtual GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor cursorShape) = 0; + virtual GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor cursor_shape) = 0; /** * Set the shape of the cursor to a custom cursor. diff --git a/intern/ghost/GHOST_Rect.hh b/intern/ghost/GHOST_Rect.hh index c00bc933a1b..7577d221f7d 100644 --- a/intern/ghost/GHOST_Rect.hh +++ b/intern/ghost/GHOST_Rect.hh @@ -27,7 +27,7 @@ class GHOST_Rect { * \param b: requested bottom coordinate of the rectangle. */ GHOST_Rect(int32_t l = 0, int32_t t = 0, int32_t r = 0, int32_t b = 0) - : m_l(l), m_t(t), m_r(r), m_b(b) + : l_(l), t_(t), r_(r), b_(b) { } @@ -66,7 +66,7 @@ class GHOST_Rect { /** * Returns whether this rectangle is valid. - * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. + * Valid rectangles are rectangles that have l_ <= r_ and t_ <= b_. * Thus, empty rectangles are valid. * \return boolean value (true==valid rectangle) */ @@ -151,33 +151,33 @@ class GHOST_Rect { virtual bool clip(GHOST_Rect &r) const; /** Left coordinate of the rectangle */ - int32_t m_l; + int32_t l_; /** Top coordinate of the rectangle */ - int32_t m_t; + int32_t t_; /** Right coordinate of the rectangle */ - int32_t m_r; + int32_t r_; /** Bottom coordinate of the rectangle */ - int32_t m_b; + int32_t b_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_Rect") }; inline int32_t GHOST_Rect::getWidth() const { - return m_r - m_l; + return r_ - l_; } inline int32_t GHOST_Rect::getHeight() const { - return m_b - m_t; + return b_ - t_; } inline void GHOST_Rect::set(int32_t l, int32_t t, int32_t r, int32_t b) { - m_l = l; - m_t = t; - m_r = r; - m_b = b; + l_ = l; + t_ = t; + r_ = r; + b_ = b; } inline bool GHOST_Rect::isEmpty() const @@ -187,38 +187,38 @@ inline bool GHOST_Rect::isEmpty() const inline bool GHOST_Rect::isValid() const { - return (m_l <= m_r) && (m_t <= m_b); + return (l_ <= r_) && (t_ <= b_); } inline void GHOST_Rect::unionRect(const GHOST_Rect &r) { - if (r.m_l < m_l) { - m_l = r.m_l; + if (r.l_ < l_) { + l_ = r.l_; } - if (r.m_r > m_r) { - m_r = r.m_r; + if (r.r_ > r_) { + r_ = r.r_; } - if (r.m_t < m_t) { - m_t = r.m_t; + if (r.t_ < t_) { + t_ = r.t_; } - if (r.m_b > m_b) { - m_b = r.m_b; + if (r.b_ > b_) { + b_ = r.b_; } } inline void GHOST_Rect::unionPoint(int32_t x, int32_t y) { - if (x < m_l) { - m_l = x; + if (x < l_) { + l_ = x; } - if (x > m_r) { - m_r = x; + if (x > r_) { + r_ = x; } - if (y < m_t) { - m_t = y; + if (y < t_) { + t_ = y; } - if (y > m_b) { - m_b = y; + if (y > b_) { + b_ = y; } } @@ -233,18 +233,18 @@ inline void GHOST_Rect::wrapPoint(int32_t &x, int32_t &y, int32_t ofs, GHOST_TAx } if (axis & GHOST_kAxisX) { - while (x - ofs < m_l) { + while (x - ofs < l_) { x += w - (ofs * 2); } - while (x + ofs > m_r) { + while (x + ofs > r_) { x -= w - (ofs * 2); } } if (axis & GHOST_kAxisY) { - while (y - ofs < m_t) { + while (y - ofs < t_) { y += h - (ofs * 2); } - while (y + ofs > m_b) { + while (y + ofs > b_) { y -= h - (ofs * 2); } } @@ -252,22 +252,22 @@ inline void GHOST_Rect::wrapPoint(int32_t &x, int32_t &y, int32_t ofs, GHOST_TAx inline void GHOST_Rect::clampPoint(int32_t &x, int32_t &y) { - if (x < m_l) { - x = m_l; + if (x < l_) { + x = l_; } - else if (x > m_r) { - x = m_r; + else if (x > r_) { + x = r_; } - if (y < m_t) { - y = m_t; + if (y < t_) { + y = t_; } - else if (y > m_b) { - y = m_b; + else if (y > b_) { + y = b_; } } inline bool GHOST_Rect::isInside(int32_t x, int32_t y) const { - return (x >= m_l) && (x <= m_r) && (y >= m_t) && (y <= m_b); + return (x >= l_) && (x <= r_) && (y >= t_) && (y <= b_); } diff --git a/intern/ghost/GHOST_Types.h b/intern/ghost/GHOST_Types.h index 187394a3ba3..691e3c9a4c9 100644 --- a/intern/ghost/GHOST_Types.h +++ b/intern/ghost/GHOST_Types.h @@ -822,19 +822,19 @@ typedef struct { /*is_stereo_visual*/ false, /*is_debug*/ false, /*vsync*/ GHOST_kVSyncModeUnset, \ } -#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings) \ +#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings) \ { \ /*is_stereo_visual*/ false, \ - /*is_debug*/ (((gpuSettings).flags & GHOST_gpuDebugContext) != 0), \ + /*is_debug*/ (((gpu_settings).flags & GHOST_gpuDebugContext) != 0), \ /*vsync*/ GHOST_kVSyncModeUnset, \ } -#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings) \ +#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings) \ { \ - /*is_stereo_visual*/ (((gpuSettings).flags & GHOST_gpuStereoVisual) != 0), \ - /*is_debug*/ (((gpuSettings).flags & GHOST_gpuDebugContext) != 0), /*vsync*/ \ - (((gpuSettings).flags & GHOST_gpuVSyncIsOverridden) ? (gpuSettings).vsync : \ - GHOST_kVSyncModeUnset), \ + /*is_stereo_visual*/ (((gpu_settings).flags & GHOST_gpuStereoVisual) != 0), \ + /*is_debug*/ (((gpu_settings).flags & GHOST_gpuDebugContext) != 0), /*vsync*/ \ + (((gpu_settings).flags & GHOST_gpuVSyncIsOverridden) ? (gpu_settings).vsync : \ + GHOST_kVSyncModeUnset), \ } typedef struct { diff --git a/intern/ghost/intern/GHOST_Buttons.cc b/intern/ghost/intern/GHOST_Buttons.cc index 633d110a9d3..5f56e97db5f 100644 --- a/intern/ghost/intern/GHOST_Buttons.cc +++ b/intern/ghost/intern/GHOST_Buttons.cc @@ -17,19 +17,19 @@ bool GHOST_Buttons::get(GHOST_TButton mask) const { switch (mask) { case GHOST_kButtonMaskLeft: - return m_ButtonLeft; + return button_left_; case GHOST_kButtonMaskMiddle: - return m_ButtonMiddle; + return button_middle_; case GHOST_kButtonMaskRight: - return m_ButtonRight; + return button_right_; case GHOST_kButtonMaskButton4: - return m_Button4; + return button4_; case GHOST_kButtonMaskButton5: - return m_Button5; + return button5_; case GHOST_kButtonMaskButton6: - return m_Button6; + return button6_; case GHOST_kButtonMaskButton7: - return m_Button7; + return button7_; default: return false; } @@ -39,25 +39,25 @@ void GHOST_Buttons::set(GHOST_TButton mask, bool down) { switch (mask) { case GHOST_kButtonMaskLeft: - m_ButtonLeft = down; + button_left_ = down; break; case GHOST_kButtonMaskMiddle: - m_ButtonMiddle = down; + button_middle_ = down; break; case GHOST_kButtonMaskRight: - m_ButtonRight = down; + button_right_ = down; break; case GHOST_kButtonMaskButton4: - m_Button4 = down; + button4_ = down; break; case GHOST_kButtonMaskButton5: - m_Button5 = down; + button5_ = down; break; case GHOST_kButtonMaskButton6: - m_Button6 = down; + button6_ = down; break; case GHOST_kButtonMaskButton7: - m_Button7 = down; + button7_ = down; break; default: break; @@ -66,13 +66,13 @@ void GHOST_Buttons::set(GHOST_TButton mask, bool down) void GHOST_Buttons::clear() { - m_ButtonLeft = false; - m_ButtonMiddle = false; - m_ButtonRight = false; - m_Button4 = false; - m_Button5 = false; - m_Button6 = false; - m_Button7 = false; + button_left_ = false; + button_middle_ = false; + button_right_ = false; + button4_ = false; + button5_ = false; + button6_ = false; + button7_ = false; } GHOST_Buttons::~GHOST_Buttons() = default; diff --git a/intern/ghost/intern/GHOST_Buttons.hh b/intern/ghost/intern/GHOST_Buttons.hh index f56a02f1c0f..d69f49f9ba2 100644 --- a/intern/ghost/intern/GHOST_Buttons.hh +++ b/intern/ghost/intern/GHOST_Buttons.hh @@ -42,11 +42,11 @@ struct GHOST_Buttons { */ void clear(); - uint8_t m_ButtonLeft : 1; - uint8_t m_ButtonMiddle : 1; - uint8_t m_ButtonRight : 1; - uint8_t m_Button4 : 1; - uint8_t m_Button5 : 1; - uint8_t m_Button6 : 1; - uint8_t m_Button7 : 1; + uint8_t button_left_ : 1; + uint8_t button_middle_ : 1; + uint8_t button_right_ : 1; + uint8_t button4_ : 1; + uint8_t button5_ : 1; + uint8_t button6_ : 1; + uint8_t button7_ : 1; }; diff --git a/intern/ghost/intern/GHOST_C-api.cc b/intern/ghost/intern/GHOST_C-api.cc index 81023424944..e9686336d88 100644 --- a/intern/ghost/intern/GHOST_C-api.cc +++ b/intern/ghost/intern/GHOST_C-api.cc @@ -139,11 +139,11 @@ GHOST_TSuccess GHOST_GetAllDisplayDimensions(GHOST_SystemHandle systemhandle, } GHOST_ContextHandle GHOST_CreateGPUContext(GHOST_SystemHandle systemhandle, - GHOST_GPUSettings gpuSettings) + GHOST_GPUSettings gpu_settings) { GHOST_ISystem *system = (GHOST_ISystem *)systemhandle; - return (GHOST_ContextHandle)system->createOffscreenContext(gpuSettings); + return (GHOST_ContextHandle)system->createOffscreenContext(gpu_settings); } GHOST_TSuccess GHOST_DisposeGPUContext(GHOST_SystemHandle systemhandle, @@ -164,7 +164,7 @@ GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle, uint32_t height, GHOST_TWindowState state, bool is_dialog, - GHOST_GPUSettings gpuSettings) + GHOST_GPUSettings gpu_settings) { GHOST_ISystem *system = (GHOST_ISystem *)systemhandle; @@ -174,7 +174,7 @@ GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle, width, height, state, - gpuSettings, + gpu_settings, false, is_dialog, (GHOST_IWindow *)parent_windowhandle); @@ -417,10 +417,10 @@ void GHOST_GetCursorGrabState(GHOST_WindowHandle windowhandle, GHOST_Rect bounds_rect; bool use_software_cursor; window->getCursorGrabState(*r_mode, *r_axis_flag, bounds_rect, use_software_cursor); - r_bounds[0] = bounds_rect.m_l; - r_bounds[1] = bounds_rect.m_t; - r_bounds[2] = bounds_rect.m_r; - r_bounds[3] = bounds_rect.m_b; + r_bounds[0] = bounds_rect.l_; + r_bounds[1] = bounds_rect.t_; + r_bounds[2] = bounds_rect.r_; + r_bounds[3] = bounds_rect.b_; *r_use_software_cursor = use_software_cursor; } @@ -591,17 +591,17 @@ GHOST_TWindowDecorationStyleFlags GHOST_GetWindowDecorationStyleFlags( } void GHOST_SetWindowDecorationStyleFlags(GHOST_WindowHandle windowhandle, - GHOST_TWindowDecorationStyleFlags styleFlags) + GHOST_TWindowDecorationStyleFlags style_flags) { GHOST_IWindow *window = (GHOST_IWindow *)windowhandle; - window->setWindowDecorationStyleFlags(styleFlags); + window->setWindowDecorationStyleFlags(style_flags); } -void GHOST_SetWindowDecorationStyleSettings(GHOST_WindowHandle windowhandle, - GHOST_WindowDecorationStyleSettings decorationSettings) +void GHOST_SetWindowDecorationStyleSettings( + GHOST_WindowHandle windowhandle, GHOST_WindowDecorationStyleSettings decoration_settings) { GHOST_IWindow *window = (GHOST_IWindow *)windowhandle; - window->setWindowDecorationStyleSettings(decorationSettings); + window->setWindowDecorationStyleSettings(decoration_settings); } GHOST_TSuccess GHOST_ApplyWindowDecorationStyle(GHOST_WindowHandle windowhandle) @@ -690,11 +690,12 @@ GHOST_TSuccess GHOST_SetWindowState(GHOST_WindowHandle windowhandle, GHOST_TWind return window->setState(state); } -GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle, bool isUnsavedChanges) +GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle, + bool is_unsaved_changes) { GHOST_IWindow *window = (GHOST_IWindow *)windowhandle; - return window->setModifiedState(isUnsavedChanges); + return window->setModifiedState(is_unsaved_changes); } GHOST_TSuccess GHOST_SetWindowOrder(GHOST_WindowHandle windowhandle, GHOST_TWindowOrder order) @@ -808,10 +809,10 @@ void GHOST_GetRectangle( { const GHOST_Rect *rect = (GHOST_Rect *)rectanglehandle; - *l = rect->m_l; - *t = rect->m_t; - *r = rect->m_r; - *b = rect->m_b; + *l = rect->l_; + *t = rect->t_; + *r = rect->r_; + *b = rect->b_; } void GHOST_SetRectangle( diff --git a/intern/ghost/intern/GHOST_CallbackEventConsumer.cc b/intern/ghost/intern/GHOST_CallbackEventConsumer.cc index 25cf79823ed..628245e62b3 100644 --- a/intern/ghost/intern/GHOST_CallbackEventConsumer.cc +++ b/intern/ghost/intern/GHOST_CallbackEventConsumer.cc @@ -15,13 +15,13 @@ #include "GHOST_Debug.hh" GHOST_CallbackEventConsumer::GHOST_CallbackEventConsumer(GHOST_EventCallbackProcPtr eventCallback, - GHOST_TUserDataPtr userData) + GHOST_TUserDataPtr user_data) { - m_eventCallback = eventCallback; - m_userData = userData; + event_callback_ = eventCallback; + user_data_ = user_data; } bool GHOST_CallbackEventConsumer::processEvent(const GHOST_IEvent *event) { - return m_eventCallback((GHOST_EventHandle)event, m_userData); + return event_callback_((GHOST_EventHandle)event, user_data_); } diff --git a/intern/ghost/intern/GHOST_CallbackEventConsumer.hh b/intern/ghost/intern/GHOST_CallbackEventConsumer.hh index 699a0ec118e..d20a3776742 100644 --- a/intern/ghost/intern/GHOST_CallbackEventConsumer.hh +++ b/intern/ghost/intern/GHOST_CallbackEventConsumer.hh @@ -21,10 +21,10 @@ class GHOST_CallbackEventConsumer : public GHOST_IEventConsumer { /** * Constructor. * \param eventCallback: The call-back routine invoked. - * \param userData: The data passed back through the call-back routine. + * \param user_data: The data passed back through the call-back routine. */ GHOST_CallbackEventConsumer(GHOST_EventCallbackProcPtr eventCallback, - GHOST_TUserDataPtr userData); + GHOST_TUserDataPtr user_data); /** * Destructor. @@ -40,9 +40,9 @@ class GHOST_CallbackEventConsumer : public GHOST_IEventConsumer { protected: /** The call-back routine invoked. */ - GHOST_EventCallbackProcPtr m_eventCallback; + GHOST_EventCallbackProcPtr event_callback_; /** The data passed back through the call-back routine. */ - GHOST_TUserDataPtr m_userData; + GHOST_TUserDataPtr user_data_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_CallbackEventConsumer") }; diff --git a/intern/ghost/intern/GHOST_Context.hh b/intern/ghost/intern/GHOST_Context.hh index 926e40e8d6a..2214d86fa6d 100644 --- a/intern/ghost/intern/GHOST_Context.hh +++ b/intern/ghost/intern/GHOST_Context.hh @@ -23,7 +23,7 @@ class GHOST_Context : public GHOST_IContext { * Constructor. * \param context_params: Parameters to use when initializing the context. */ - GHOST_Context(const GHOST_ContextParams &context_params) : m_context_params(context_params) {} + GHOST_Context(const GHOST_ContextParams &context_params) : context_params_(context_params) {} /** * Destructor. @@ -86,7 +86,7 @@ class GHOST_Context : public GHOST_IContext { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ virtual GHOST_TSuccess getSwapInterval(int & /*interval*/) @@ -99,7 +99,7 @@ class GHOST_Context : public GHOST_IContext { */ void *getUserData() { - return m_user_data; + return user_data_; } /** @@ -107,7 +107,7 @@ class GHOST_Context : public GHOST_IContext { */ void setUserData(void *user_data) { - m_user_data = user_data; + user_data_ = user_data; } /** @@ -117,13 +117,13 @@ class GHOST_Context : public GHOST_IContext { */ bool isStereoVisual() const { - return m_context_params.is_stereo_visual; + return context_params_.is_stereo_visual; } /** Get the VSync value. */ virtual GHOST_TVSyncModes getVSync() { - return m_context_params.vsync; + return context_params_.vsync; } /** @@ -166,10 +166,10 @@ class GHOST_Context : public GHOST_IContext { #endif protected: - GHOST_ContextParams m_context_params; + GHOST_ContextParams context_params_; /** Caller specified, not for internal use. */ - void *m_user_data = nullptr; + void *user_data_ = nullptr; #ifdef WITH_OPENGL_BACKEND static void initClearGL(); diff --git a/intern/ghost/intern/GHOST_ContextD3D.cc b/intern/ghost/intern/GHOST_ContextD3D.cc index 211254f012a..e50d555d5b0 100644 --- a/intern/ghost/intern/GHOST_ContextD3D.cc +++ b/intern/ghost/intern/GHOST_ContextD3D.cc @@ -21,15 +21,15 @@ HMODULE GHOST_ContextD3D::s_d3d_lib = nullptr; PFN_D3D11_CREATE_DEVICE GHOST_ContextD3D::s_D3D11CreateDeviceFn = nullptr; GHOST_ContextD3D::GHOST_ContextD3D(const GHOST_ContextParams &context_params, HWND hWnd) - : GHOST_Context(context_params), m_hWnd(hWnd) + : GHOST_Context(context_params), h_wnd_(hWnd) { } GHOST_ContextD3D::~GHOST_ContextD3D() { - m_device->Release(); - m_device_ctx->ClearState(); - m_device_ctx->Release(); + device_->Release(); + device_ctx_->ClearState(); + device_ctx_->Release(); } GHOST_TSuccess GHOST_ContextD3D::swapBuffers() @@ -95,9 +95,9 @@ GHOST_TSuccess GHOST_ContextD3D::initializeDrawingContext() nullptr, 0, D3D11_SDK_VERSION, - &m_device, + &device_, nullptr, - &m_device_ctx); + &device_ctx_); WIN32_CHK(hres == S_OK); @@ -115,7 +115,7 @@ class GHOST_SharedOpenGLResource { HANDLE device; GLuint fbo; HANDLE render_target{nullptr}; - } m_shared; + } shared_; enum RenderTarget { TARGET_RENDERBUF, TARGET_TEX2D }; @@ -126,7 +126,7 @@ class GHOST_SharedOpenGLResource { unsigned int height, DXGI_FORMAT format, ID3D11RenderTargetView *render_target = nullptr) - : m_device(device), m_device_ctx(device_ctx), m_cur_width(width), m_cur_height(height) + : device_(device), device_ctx_(device_ctx), cur_width_(width), cur_height_(height) { if (!render_target) { D3D11_TEXTURE2D_DESC texDesc{}; @@ -158,17 +158,17 @@ class GHOST_SharedOpenGLResource { tex->Release(); } - m_render_target = render_target; - if (m_render_target) { + render_target_ = render_target; + if (render_target_) { ID3D11Resource *backbuffer_res = nullptr; - m_render_target->GetResource(&backbuffer_res); + render_target_->GetResource(&backbuffer_res); if (backbuffer_res) { - backbuffer_res->QueryInterface(&m_render_target_tex); + backbuffer_res->QueryInterface(&render_target_tex_); backbuffer_res->Release(); } } - if (!m_render_target || !m_render_target_tex) { + if (!render_target_ || !render_target_tex_) { fprintf(stderr, "Error creating render target for shared DirectX-OpenGL resource\n"); return; } @@ -176,39 +176,39 @@ class GHOST_SharedOpenGLResource { ~GHOST_SharedOpenGLResource() { - if (m_render_target_tex) { - m_render_target_tex->Release(); + if (render_target_tex_) { + render_target_tex_->Release(); } - if (m_render_target) { - m_render_target->Release(); + if (render_target_) { + render_target_->Release(); } - if (m_is_initialized) { + if (is_initialized_) { #if 0 /* TODO: Causes an access violation since Blender 3.4 (a296b8f694d1). */ - if (m_shared.render_target + if (shared_.render_target # if 1 /* TODO: #wglDXUnregisterObjectNV() causes an access violation on AMD when the shared * resource is a GL texture. Since there is currently no good alternative, just skip * unregistering the shared resource. */ - && !m_use_gl_texture2d + && !use_gl_texture2d_ # endif ) { - wglDXUnregisterObjectNV(m_shared.device, m_shared.render_target); + wglDXUnregisterObjectNV(shared_.device, shared_.render_target); } - if (m_shared.device) { - wglDXCloseDeviceNV(m_shared.device); + if (shared_.device) { + wglDXCloseDeviceNV(shared_.device); } - glDeleteFramebuffers(1, &m_shared.fbo); - if (m_use_gl_texture2d) { - glDeleteTextures(1, &m_gl_render_target); + glDeleteFramebuffers(1, &shared_.fbo); + if (use_gl_texture2d_) { + glDeleteTextures(1, &gl_render_target_); } else { - glDeleteRenderbuffers(1, &m_gl_render_target); + glDeleteRenderbuffers(1, &gl_render_target_); } #else - glDeleteFramebuffers(1, &m_shared.fbo); - if (m_use_gl_texture2d) { - glDeleteTextures(1, &m_gl_render_target); + glDeleteFramebuffers(1, &shared_.fbo); + if (use_gl_texture2d_) { + glDeleteTextures(1, &gl_render_target_); } #endif } @@ -217,11 +217,11 @@ class GHOST_SharedOpenGLResource { /* Returns true if the shared object was successfully registered, false otherwise. */ bool reregisterSharedObject(RenderTarget target) { - if (m_shared.render_target) { - wglDXUnregisterObjectNV(m_shared.device, m_shared.render_target); + if (shared_.render_target) { + wglDXUnregisterObjectNV(shared_.device, shared_.render_target); } - if (!m_render_target_tex) { + if (!render_target_tex_) { return false; } @@ -229,21 +229,21 @@ class GHOST_SharedOpenGLResource { glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, - m_cur_width, - m_cur_height, + cur_width_, + cur_height_, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); } - m_shared.render_target = wglDXRegisterObjectNV(m_shared.device, - m_render_target_tex, - m_gl_render_target, - (target == TARGET_TEX2D) ? GL_TEXTURE_2D : - GL_RENDERBUFFER, - WGL_ACCESS_READ_WRITE_NV); - if (!m_shared.render_target) { + shared_.render_target = wglDXRegisterObjectNV(shared_.device, + render_target_tex_, + gl_render_target_, + (target == TARGET_TEX2D) ? GL_TEXTURE_2D : + GL_RENDERBUFFER, + WGL_ACCESS_READ_WRITE_NV); + if (!shared_.render_target) { fprintf(stderr, "Error registering shared object using wglDXRegisterObjectNV()\n"); return false; } @@ -253,55 +253,55 @@ class GHOST_SharedOpenGLResource { GHOST_TSuccess initialize() { - m_shared.device = wglDXOpenDeviceNV(m_device); - if (m_shared.device == nullptr) { + shared_.device = wglDXOpenDeviceNV(device_); + if (shared_.device == nullptr) { fprintf(stderr, "Error opening shared device using wglDXOpenDeviceNV()\n"); return GHOST_kFailure; } /* Build the render-buffer. */ - glGenRenderbuffers(1, &m_gl_render_target); - glBindRenderbuffer(GL_RENDERBUFFER, m_gl_render_target); + glGenRenderbuffers(1, &gl_render_target_); + glBindRenderbuffer(GL_RENDERBUFFER, gl_render_target_); if (!reregisterSharedObject(TARGET_RENDERBUF)) { glBindRenderbuffer(GL_RENDERBUFFER, 0); - if (m_gl_render_target) { - glDeleteRenderbuffers(1, &m_gl_render_target); + if (gl_render_target_) { + glDeleteRenderbuffers(1, &gl_render_target_); } /* Fall back to texture 2d. */ - m_use_gl_texture2d = true; - glGenTextures(1, &m_gl_render_target); - glBindTexture(GL_TEXTURE_2D, m_gl_render_target); + use_gl_texture2d_ = true; + glGenTextures(1, &gl_render_target_); + glBindTexture(GL_TEXTURE_2D, gl_render_target_); reregisterSharedObject(TARGET_TEX2D); } /* Build the frame-buffer. */ - glGenFramebuffers(1, &m_shared.fbo); - glBindFramebuffer(GL_FRAMEBUFFER, m_shared.fbo); - if (m_use_gl_texture2d) { + glGenFramebuffers(1, &shared_.fbo); + glBindFramebuffer(GL_FRAMEBUFFER, shared_.fbo); + if (use_gl_texture2d_) { glFramebufferTexture2D( - GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_gl_render_target, 0); + GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl_render_target_, 0); } else { glFramebufferRenderbuffer( - GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_gl_render_target); + GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, gl_render_target_); } - m_is_initialized = true; + is_initialized_ = true; return GHOST_kSuccess; } void ensureUpdated(unsigned int width, unsigned int height) { - if (m_is_initialized == false) { + if (is_initialized_ == false) { initialize(); } - if ((m_cur_width != width) || (m_cur_height != height)) { - m_cur_width = width; - m_cur_height = height; - reregisterSharedObject(m_use_gl_texture2d ? TARGET_TEX2D : TARGET_RENDERBUF); + if ((cur_width_ != width) || (cur_height_ != height)) { + cur_width_ = width; + cur_height_ = height; + reregisterSharedObject(use_gl_texture2d_ ? TARGET_TEX2D : TARGET_RENDERBUF); } } @@ -310,7 +310,7 @@ class GHOST_SharedOpenGLResource { GLint fbo; glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &fbo); - if (!m_render_target || !m_render_target_tex) { + if (!render_target_ || !render_target_tex_) { return GHOST_kFailure; } @@ -318,13 +318,13 @@ class GHOST_SharedOpenGLResource { #ifdef NDEBUG const float clear_col[] = {0.8f, 0.5f, 1.0f, 1.0f}; - m_device_ctx->ClearRenderTargetView(m_render_target, clear_col); + device_ctx_->ClearRenderTargetView(render_target_, clear_col); #endif - m_device_ctx->OMSetRenderTargets(1, &m_render_target, nullptr); + device_ctx_->OMSetRenderTargets(1, &render_target_, nullptr); beginGLOnly(); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_shared.fbo); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, shared_.fbo); GLenum err = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (err != GL_FRAMEBUFFER_COMPLETE) { fprintf( @@ -343,25 +343,25 @@ class GHOST_SharedOpenGLResource { return GHOST_kSuccess; } - ID3D11RenderTargetView *m_render_target{nullptr}; - ID3D11Texture2D *m_render_target_tex{nullptr}; + ID3D11RenderTargetView *render_target_{nullptr}; + ID3D11Texture2D *render_target_tex_{nullptr}; private: void beginGLOnly() { - wglDXLockObjectsNV(m_shared.device, 1, &m_shared.render_target); + wglDXLockObjectsNV(shared_.device, 1, &shared_.render_target); } void endGLOnly() { - wglDXUnlockObjectsNV(m_shared.device, 1, &m_shared.render_target); + wglDXUnlockObjectsNV(shared_.device, 1, &shared_.render_target); } - ID3D11Device *m_device; - ID3D11DeviceContext *m_device_ctx; - GLuint m_gl_render_target; - unsigned int m_cur_width, m_cur_height; - bool m_is_initialized{false}; - bool m_use_gl_texture2d{false}; + ID3D11Device *device_; + ID3D11DeviceContext *device_ctx_; + GLuint gl_render_target_; + unsigned int cur_width_, cur_height_; + bool is_initialized_{false}; + bool use_gl_texture2d_{false}; }; GHOST_SharedOpenGLResource *GHOST_ContextD3D::createSharedOpenGLResource( @@ -377,7 +377,7 @@ GHOST_SharedOpenGLResource *GHOST_ContextD3D::createSharedOpenGLResource( return nullptr; } GHOST_SharedOpenGLResource *shared_res = new GHOST_SharedOpenGLResource( - m_device, m_device_ctx, width, height, format, render_target); + device_, device_ctx_, width, height, format, render_target); return shared_res; } @@ -402,5 +402,5 @@ GHOST_TSuccess GHOST_ContextD3D::blitFromOpenGLContext(GHOST_SharedOpenGLResourc ID3D11Texture2D *GHOST_ContextD3D::getSharedTexture2D(GHOST_SharedOpenGLResource *shared_res) { - return shared_res->m_render_target_tex; + return shared_res->render_target_tex_; } diff --git a/intern/ghost/intern/GHOST_ContextD3D.hh b/intern/ghost/intern/GHOST_ContextD3D.hh index 990774e11cc..feb811a9f7e 100644 --- a/intern/ghost/intern/GHOST_ContextD3D.hh +++ b/intern/ghost/intern/GHOST_ContextD3D.hh @@ -78,7 +78,7 @@ class GHOST_ContextD3D : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ GHOST_TSuccess getSwapInterval(int & /*unused*/) override @@ -120,8 +120,8 @@ class GHOST_ContextD3D : public GHOST_Context { static HMODULE s_d3d_lib; static PFN_D3D11_CREATE_DEVICE s_D3D11CreateDeviceFn; - HWND m_hWnd; + HWND h_wnd_; - ID3D11Device *m_device; - ID3D11DeviceContext *m_device_ctx; + ID3D11Device *device_; + ID3D11DeviceContext *device_ctx_; }; diff --git a/intern/ghost/intern/GHOST_ContextEGL.cc b/intern/ghost/intern/GHOST_ContextEGL.cc index 49b5a6a643d..4c623c64bc3 100644 --- a/intern/ghost/intern/GHOST_ContextEGL.cc +++ b/intern/ghost/intern/GHOST_ContextEGL.cc @@ -197,65 +197,65 @@ GHOST_ContextEGL::GHOST_ContextEGL(const GHOST_System *const system, EGLint contextResetNotificationStrategy, EGLenum api) : GHOST_Context(context_params), - m_system(system), - m_nativeDisplay(nativeDisplay), - m_nativeWindow(nativeWindow), - m_contextProfileMask(contextProfileMask), - m_contextMajorVersion(contextMajorVersion), - m_contextMinorVersion(contextMinorVersion), - m_contextFlags(contextFlags), - m_contextResetNotificationStrategy(contextResetNotificationStrategy), - m_api(api), - m_context(EGL_NO_CONTEXT), - m_surface(EGL_NO_SURFACE), - m_display(EGL_NO_DISPLAY), - m_config(EGL_NO_CONFIG_KHR), - m_swap_interval(1), - m_sharedContext( + system_(system), + native_display_(nativeDisplay), + native_window_(nativeWindow), + context_profile_mask_(contextProfileMask), + context_major_version_(contextMajorVersion), + context_minor_version_(contextMinorVersion), + context_flags_(contextFlags), + context_reset_notification_strategy_(contextResetNotificationStrategy), + api_(api), + context_(EGL_NO_CONTEXT), + surface_(EGL_NO_SURFACE), + display_(EGL_NO_DISPLAY), + config_(EGL_NO_CONFIG_KHR), + swap_interval_(1), + shared_context_( choose_api(api, s_gl_sharedContext, s_gles_sharedContext, s_vg_sharedContext)), - m_sharedCount(choose_api(api, s_gl_sharedCount, s_gles_sharedCount, s_vg_sharedCount)), - m_surface_from_native_window(false) + shared_count_(choose_api(api, s_gl_sharedCount, s_gles_sharedCount, s_vg_sharedCount)), + surface_from_native_window_(false) { } GHOST_ContextEGL::~GHOST_ContextEGL() { - if (m_display != EGL_NO_DISPLAY) { + if (display_ != EGL_NO_DISPLAY) { - bindAPI(m_api); + bindAPI(api_); - if (m_context != EGL_NO_CONTEXT) { - if (m_context == ::eglGetCurrentContext()) { - EGL_CHK(::eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); + if (context_ != EGL_NO_CONTEXT) { + if (context_ == ::eglGetCurrentContext()) { + EGL_CHK(::eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); } - if (m_context != m_sharedContext || m_sharedCount == 1) { - assert(m_sharedCount > 0); + if (context_ != shared_context_ || shared_count_ == 1) { + assert(shared_count_ > 0); - m_sharedCount--; + shared_count_--; - if (m_sharedCount == 0) { - m_sharedContext = EGL_NO_CONTEXT; + if (shared_count_ == 0) { + shared_context_ = EGL_NO_CONTEXT; } - EGL_CHK(::eglDestroyContext(m_display, m_context)); + EGL_CHK(::eglDestroyContext(display_, context_)); } } - if (m_surface != EGL_NO_SURFACE) { - EGL_CHK(::eglDestroySurface(m_display, m_surface)); + if (surface_ != EGL_NO_SURFACE) { + EGL_CHK(::eglDestroySurface(display_, surface_)); } } } GHOST_TSuccess GHOST_ContextEGL::swapBuffers() { - return EGL_CHK(::eglSwapBuffers(m_display, m_surface)) ? GHOST_kSuccess : GHOST_kFailure; + return EGL_CHK(::eglSwapBuffers(display_, surface_)) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_ContextEGL::setSwapInterval(int interval) { - if (epoxy_egl_version(m_display) >= 11) { - if (EGL_CHK(::eglSwapInterval(m_display, interval))) { - m_swap_interval = interval; + if (epoxy_egl_version(display_) >= 11) { + if (EGL_CHK(::eglSwapInterval(display_, interval))) { + swap_interval_ = interval; return GHOST_kSuccess; } @@ -264,48 +264,48 @@ GHOST_TSuccess GHOST_ContextEGL::setSwapInterval(int interval) return GHOST_kFailure; } -GHOST_TSuccess GHOST_ContextEGL::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextEGL::getSwapInterval(int &interval_out) { /* This is a bit of a kludge because there does not seem to * be a way to query the swap interval with EGL. */ - intervalOut = m_swap_interval; + interval_out = swap_interval_; return GHOST_kSuccess; } EGLDisplay GHOST_ContextEGL::getDisplay() const { - return m_display; + return display_; } EGLConfig GHOST_ContextEGL::getConfig() const { - return m_config; + return config_; } EGLContext GHOST_ContextEGL::getContext() const { - return m_context; + return context_; } GHOST_TSuccess GHOST_ContextEGL::activateDrawingContext() { - if (m_display) { + if (display_) { active_context_ = this; - bindAPI(m_api); - return EGL_CHK(::eglMakeCurrent(m_display, m_surface, m_surface, m_context)) ? GHOST_kSuccess : - GHOST_kFailure; + bindAPI(api_); + return EGL_CHK(::eglMakeCurrent(display_, surface_, surface_, context_)) ? GHOST_kSuccess : + GHOST_kFailure; } return GHOST_kFailure; } GHOST_TSuccess GHOST_ContextEGL::releaseDrawingContext() { - if (m_display) { + if (display_) { active_context_ = nullptr; - bindAPI(m_api); + bindAPI(api_); - return EGL_CHK(::eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) ? + return EGL_CHK(::eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)) ? GHOST_kSuccess : GHOST_kFailure; } @@ -314,7 +314,7 @@ GHOST_TSuccess GHOST_ContextEGL::releaseDrawingContext() inline bool GHOST_ContextEGL::bindAPI(EGLenum api) { - if (epoxy_egl_version(m_display) >= 12) { + if (epoxy_egl_version(display_) >= 12) { return (EGL_CHK(eglBindAPI(api)) == EGL_TRUE); } @@ -336,10 +336,10 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() std::vector attrib_list; EGLint num_config = 0; - if (m_context_params.is_stereo_visual) { + if (context_params_.is_stereo_visual) { fprintf(stderr, "Warning! Stereo OpenGL ES contexts are not supported.\n"); } - m_context_params.is_stereo_visual = false; /* It doesn't matter what the Window wants. */ + context_params_.is_stereo_visual = false; /* It doesn't matter what the Window wants. */ EGLDisplay prev_display = eglGetCurrentDisplay(); EGLSurface prev_draw = eglGetCurrentSurface(EGL_DRAW); @@ -348,18 +348,18 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() EGLint egl_major = 0, egl_minor = 0; - if (!EGL_CHK((m_display = ::eglGetDisplay(m_nativeDisplay)) != EGL_NO_DISPLAY)) { + if (!EGL_CHK((display_ = ::eglGetDisplay(native_display_)) != EGL_NO_DISPLAY)) { goto error; } { - const EGLBoolean init_display_result = ::eglInitialize(m_display, &egl_major, &egl_minor); + const EGLBoolean init_display_result = ::eglInitialize(display_, &egl_major, &egl_minor); const EGLint init_display_error = (init_display_result) ? 0 : eglGetError(); if (!init_display_result || (egl_major == 0 && egl_minor == 0)) { /* We failed to create a regular render window, retry and see if we can create a headless * render context. */ - ::eglTerminate(m_display); + ::eglTerminate(display_); const char *egl_extension_st = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); assert(egl_extension_st != nullptr); @@ -375,10 +375,10 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() goto error; } - m_display = eglGetPlatformDisplayEXT( + display_ = eglGetPlatformDisplayEXT( EGL_PLATFORM_SURFACELESS_MESA, EGL_DEFAULT_DISPLAY, nullptr); - const EGLBoolean headless_result = ::eglInitialize(m_display, &egl_major, &egl_minor); + const EGLBoolean headless_result = ::eglInitialize(display_, &egl_major, &egl_minor); const EGLint init_headless_error = (headless_result) ? 0 : eglGetError(); if (!headless_result) { @@ -393,10 +393,10 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() fprintf(stderr, "EGL Version %d.%d\n", egl_major, egl_minor); #endif - if (!EGL_CHK(::eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))) { + if (!EGL_CHK(::eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))) { goto error; } - if (!bindAPI(m_api)) { + if (!bindAPI(api_)) { goto error; } @@ -404,40 +404,40 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() attrib_list.reserve(20); - if (m_api == EGL_OPENGL_ES_API && epoxy_egl_version(m_display) >= 12) { + if (api_ == EGL_OPENGL_ES_API && epoxy_egl_version(display_) >= 12) { /* According to the spec it seems that you are required to set EGL_RENDERABLE_TYPE, * but some implementations (ANGLE) do not seem to care. */ - if (m_contextMajorVersion == 1) { + if (context_major_version_ == 1) { attrib_list.push_back(EGL_RENDERABLE_TYPE); attrib_list.push_back(EGL_OPENGL_ES_BIT); } - else if (m_contextMajorVersion == 2) { + else if (context_major_version_ == 2) { attrib_list.push_back(EGL_RENDERABLE_TYPE); attrib_list.push_back(EGL_OPENGL_ES2_BIT); } - else if (m_contextMajorVersion == 3) { + else if (context_major_version_ == 3) { attrib_list.push_back(EGL_RENDERABLE_TYPE); attrib_list.push_back(EGL_OPENGL_ES3_BIT_KHR); } else { fprintf(stderr, "Warning! Unable to request an ES context of version %d.%d\n", - m_contextMajorVersion, - m_contextMinorVersion); + context_major_version_, + context_minor_version_); } - if (!((m_contextMajorVersion == 1) || - (m_contextMajorVersion == 2 && epoxy_egl_version(m_display) >= 13) || - (m_contextMajorVersion == 3 && - epoxy_has_egl_extension(m_display, "KHR_create_context")) || - (m_contextMajorVersion == 3 && epoxy_egl_version(m_display) >= 15))) + if (!((context_major_version_ == 1) || + (context_major_version_ == 2 && epoxy_egl_version(display_) >= 13) || + (context_major_version_ == 3 && + epoxy_has_egl_extension(display_, "KHR_create_context")) || + (context_major_version_ == 3 && epoxy_egl_version(display_) >= 15))) { fprintf(stderr, "Warning! May not be able to create a version %d.%d ES context with version %d.%d " "of EGL\n", - m_contextMajorVersion, - m_contextMinorVersion, + context_major_version_, + context_minor_version_, egl_major, egl_minor); } @@ -456,7 +456,7 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() attrib_list.push_back(EGL_BLUE_SIZE); attrib_list.push_back(8); - if (m_nativeWindow == 0) { + if (native_window_ == 0) { /* Off-screen surface. */ attrib_list.push_back(EGL_SURFACE_TYPE); attrib_list.push_back(EGL_PBUFFER_BIT); @@ -464,7 +464,7 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() attrib_list.push_back(EGL_NONE); - if (!EGL_CHK(::eglChooseConfig(m_display, &(attrib_list[0]), &m_config, 1, &num_config))) { + if (!EGL_CHK(::eglChooseConfig(display_, &(attrib_list[0]), &config_, 1, &num_config))) { goto error; } @@ -473,7 +473,7 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() goto error; } - if (m_nativeWindow != 0) { + if (native_window_ != 0) { std::vector surface_attrib_list; surface_attrib_list.reserve(3); #ifdef WITH_GHOST_WAYLAND @@ -483,7 +483,7 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() * See #102994. */ /* EGL_EXT_present_opaque isn't added to the latest release of epoxy, but is part of the latest * EGL https://github.com/KhronosGroup/EGL-Registry/blob/main/api/egl.xml */ - if (epoxy_has_egl_extension(m_display, "EGL_EXT_present_opaque")) { + if (epoxy_has_egl_extension(display_, "EGL_EXT_present_opaque")) { # ifndef EGL_PRESENT_OPAQUE_EXT # define EGL_PRESENT_OPAQUE_EXT 0x31DF # endif @@ -493,9 +493,9 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() #endif surface_attrib_list.push_back(EGL_NONE); - m_surface = ::eglCreateWindowSurface( - m_display, m_config, m_nativeWindow, surface_attrib_list.data()); - m_surface_from_native_window = true; + surface_ = ::eglCreateWindowSurface( + display_, config_, native_window_, surface_attrib_list.data()); + surface_from_native_window_ = true; } else { static const EGLint pb_attrib_list[] = { @@ -505,101 +505,100 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() 1, EGL_NONE, }; - m_surface = ::eglCreatePbufferSurface(m_display, m_config, pb_attrib_list); + surface_ = ::eglCreatePbufferSurface(display_, config_, pb_attrib_list); } - if (!EGL_CHK(m_surface != EGL_NO_SURFACE)) { + if (!EGL_CHK(surface_ != EGL_NO_SURFACE)) { goto error; } attrib_list.clear(); - if (epoxy_egl_version(m_display) >= 15 || - epoxy_has_egl_extension(m_display, "KHR_create_context")) + if (epoxy_egl_version(display_) >= 15 || epoxy_has_egl_extension(display_, "KHR_create_context")) { - if (m_api == EGL_OPENGL_API || m_api == EGL_OPENGL_ES_API) { - if (m_contextMajorVersion != 0) { + if (api_ == EGL_OPENGL_API || api_ == EGL_OPENGL_ES_API) { + if (context_major_version_ != 0) { attrib_list.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR); - attrib_list.push_back(m_contextMajorVersion); + attrib_list.push_back(context_major_version_); } - if (m_contextMinorVersion != 0) { + if (context_minor_version_ != 0) { attrib_list.push_back(EGL_CONTEXT_MINOR_VERSION_KHR); - attrib_list.push_back(m_contextMinorVersion); + attrib_list.push_back(context_minor_version_); } - if (m_contextFlags != 0) { + if (context_flags_ != 0) { attrib_list.push_back(EGL_CONTEXT_FLAGS_KHR); - attrib_list.push_back(m_contextFlags); + attrib_list.push_back(context_flags_); } } else { - if (m_contextMajorVersion != 0 || m_contextMinorVersion != 0) { + if (context_major_version_ != 0 || context_minor_version_ != 0) { fprintf(stderr, "Warning! Cannot request specific versions of %s contexts.", - api_string(m_api).c_str()); + api_string(api_).c_str()); } - if (m_contextFlags != 0) { - fprintf(stderr, "Warning! Flags cannot be set on %s contexts.", api_string(m_api).c_str()); + if (context_flags_ != 0) { + fprintf(stderr, "Warning! Flags cannot be set on %s contexts.", api_string(api_).c_str()); } } - if (m_api == EGL_OPENGL_API) { - if (m_contextProfileMask != 0) { + if (api_ == EGL_OPENGL_API) { + if (context_profile_mask_ != 0) { attrib_list.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR); - attrib_list.push_back(m_contextProfileMask); + attrib_list.push_back(context_profile_mask_); } } else { - if (m_contextProfileMask != 0) { + if (context_profile_mask_ != 0) { fprintf( - stderr, "Warning! Cannot select profile for %s contexts.", api_string(m_api).c_str()); + stderr, "Warning! Cannot select profile for %s contexts.", api_string(api_).c_str()); } } - if (m_api == EGL_OPENGL_API || epoxy_egl_version(m_display) >= 15) { - if (m_contextResetNotificationStrategy != 0) { + if (api_ == EGL_OPENGL_API || epoxy_egl_version(display_) >= 15) { + if (context_reset_notification_strategy_ != 0) { attrib_list.push_back(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR); - attrib_list.push_back(m_contextResetNotificationStrategy); + attrib_list.push_back(context_reset_notification_strategy_); } } else { - if (m_contextResetNotificationStrategy != 0) { + if (context_reset_notification_strategy_ != 0) { fprintf(stderr, "Warning! EGL %d.%d cannot set the reset notification strategy on %s contexts.", egl_major, egl_minor, - api_string(m_api).c_str()); + api_string(api_).c_str()); } } } else { - if (m_api == EGL_OPENGL_ES_API) { - if (m_contextMajorVersion != 0) { + if (api_ == EGL_OPENGL_ES_API) { + if (context_major_version_ != 0) { attrib_list.push_back(EGL_CONTEXT_CLIENT_VERSION); - attrib_list.push_back(m_contextMajorVersion); + attrib_list.push_back(context_major_version_); } } else { - if (m_contextMajorVersion != 0 || m_contextMinorVersion != 0) { + if (context_major_version_ != 0 || context_minor_version_ != 0) { fprintf(stderr, "Warning! EGL %d.%d is unable to select between versions of %s.", egl_major, egl_minor, - api_string(m_api).c_str()); + api_string(api_).c_str()); } } - if (m_contextFlags != 0) { + if (context_flags_ != 0) { fprintf(stderr, "Warning! EGL %d.%d is unable to set context flags.", egl_major, egl_minor); } - if (m_contextProfileMask != 0) { + if (context_profile_mask_ != 0) { fprintf(stderr, "Warning! EGL %d.%d is unable to select between profiles.", egl_major, egl_minor); } - if (m_contextResetNotificationStrategy != 0) { + if (context_reset_notification_strategy_ != 0) { fprintf(stderr, "Warning! EGL %d.%d is unable to set the reset notification strategies.", egl_major, @@ -609,19 +608,19 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() attrib_list.push_back(EGL_NONE); - m_context = ::eglCreateContext(m_display, m_config, m_sharedContext, &(attrib_list[0])); + context_ = ::eglCreateContext(display_, config_, shared_context_, &(attrib_list[0])); - if (!EGL_CHK(m_context != EGL_NO_CONTEXT)) { + if (!EGL_CHK(context_ != EGL_NO_CONTEXT)) { goto error; } - if (m_sharedContext == EGL_NO_CONTEXT) { - m_sharedContext = m_context; + if (shared_context_ == EGL_NO_CONTEXT) { + shared_context_ = context_; } - m_sharedCount++; + shared_count_++; - if (!EGL_CHK(::eglMakeCurrent(m_display, m_surface, m_surface, m_context))) { + if (!EGL_CHK(::eglMakeCurrent(display_, surface_, surface_, context_))) { goto error; } @@ -632,9 +631,9 @@ GHOST_TSuccess GHOST_ContextEGL::initializeDrawingContext() } } - if (m_nativeWindow != 0) { + if (native_window_ != 0) { initClearGL(); - ::eglSwapBuffers(m_display, m_surface); + ::eglSwapBuffers(display_, surface_); } active_context_ = this; @@ -649,11 +648,11 @@ error: GHOST_TSuccess GHOST_ContextEGL::releaseNativeHandles() { - m_nativeDisplay = nullptr; + native_display_ = nullptr; - m_nativeWindow = 0; - if (m_surface_from_native_window) { - m_surface = EGL_NO_SURFACE; + native_window_ = 0; + if (surface_from_native_window_) { + surface_ = EGL_NO_SURFACE; } return GHOST_kSuccess; diff --git a/intern/ghost/intern/GHOST_ContextEGL.hh b/intern/ghost/intern/GHOST_ContextEGL.hh index ea9338fc9e3..5f5f620ec7b 100644 --- a/intern/ghost/intern/GHOST_ContextEGL.hh +++ b/intern/ghost/intern/GHOST_ContextEGL.hh @@ -90,10 +90,10 @@ class GHOST_ContextEGL : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; EGLDisplay getDisplay() const; @@ -104,33 +104,33 @@ class GHOST_ContextEGL : public GHOST_Context { private: bool bindAPI(EGLenum api); - const GHOST_System *const m_system; + const GHOST_System *const system_; - EGLNativeDisplayType m_nativeDisplay; - EGLNativeWindowType m_nativeWindow; + EGLNativeDisplayType native_display_; + EGLNativeWindowType native_window_; - const EGLint m_contextProfileMask; - const EGLint m_contextMajorVersion; - const EGLint m_contextMinorVersion; - const EGLint m_contextFlags; - const EGLint m_contextResetNotificationStrategy; + const EGLint context_profile_mask_; + const EGLint context_major_version_; + const EGLint context_minor_version_; + const EGLint context_flags_; + const EGLint context_reset_notification_strategy_; - const EGLenum m_api; + const EGLenum api_; - EGLContext m_context; - EGLSurface m_surface; - EGLDisplay m_display; - EGLConfig m_config; + EGLContext context_; + EGLSurface surface_; + EGLDisplay display_; + EGLConfig config_; - EGLint m_swap_interval; + EGLint swap_interval_; - EGLContext &m_sharedContext; - EGLint &m_sharedCount; + EGLContext &shared_context_; + EGLint &shared_count_; /** - * True when the surface is created from `m_nativeWindow`. + * True when the surface is created from `native_window_`. */ - bool m_surface_from_native_window; + bool surface_from_native_window_; static EGLContext s_gl_sharedContext; static EGLint s_gl_sharedCount; diff --git a/intern/ghost/intern/GHOST_ContextGLX.cc b/intern/ghost/intern/GHOST_ContextGLX.cc index fe9ad5dbe28..bd5ed6c16a2 100644 --- a/intern/ghost/intern/GHOST_ContextGLX.cc +++ b/intern/ghost/intern/GHOST_ContextGLX.cc @@ -38,27 +38,27 @@ GHOST_ContextGLX::GHOST_ContextGLX(const GHOST_ContextParams &context_params, int contextFlags, int contextResetNotificationStrategy) : GHOST_Context(context_params), - m_display(display), - m_fbconfig(fbconfig), - m_window(window), - m_contextProfileMask(contextProfileMask), - m_contextMajorVersion(contextMajorVersion), - m_contextMinorVersion(contextMinorVersion), - m_contextFlags(contextFlags), - m_contextResetNotificationStrategy(contextResetNotificationStrategy), - m_context(None) + display_(display), + fbconfig_(fbconfig), + window_(window), + context_profile_mask_(contextProfileMask), + context_major_version_(contextMajorVersion), + context_minor_version_(contextMinorVersion), + context_flags_(contextFlags), + context_reset_notification_strategy_(contextResetNotificationStrategy), + context_(None) { - assert(m_display != nullptr); + assert(display_ != nullptr); } GHOST_ContextGLX::~GHOST_ContextGLX() { - if (m_display != nullptr) { - if (m_context != None) { - if (m_window != 0 && m_context == ::glXGetCurrentContext()) { - ::glXMakeCurrent(m_display, None, nullptr); + if (display_ != nullptr) { + if (context_ != None) { + if (window_ != 0 && context_ == ::glXGetCurrentContext()) { + ::glXMakeCurrent(display_, None, nullptr); } - if (m_context != s_sharedContext || s_sharedCount == 1) { + if (context_ != s_sharedContext || s_sharedCount == 1) { assert(s_sharedCount > 0); s_sharedCount--; @@ -67,7 +67,7 @@ GHOST_ContextGLX::~GHOST_ContextGLX() s_sharedContext = nullptr; } - ::glXDestroyContext(m_display, m_context); + ::glXDestroyContext(display_, context_); } } } @@ -75,27 +75,27 @@ GHOST_ContextGLX::~GHOST_ContextGLX() GHOST_TSuccess GHOST_ContextGLX::swapBuffers() { - ::glXSwapBuffers(m_display, m_window); + ::glXSwapBuffers(display_, window_); return GHOST_kSuccess; } GHOST_TSuccess GHOST_ContextGLX::activateDrawingContext() { - if (m_display == nullptr) { + if (display_ == nullptr) { return GHOST_kFailure; } active_context_ = this; - return ::glXMakeCurrent(m_display, m_window, m_context) ? GHOST_kSuccess : GHOST_kFailure; + return ::glXMakeCurrent(display_, window_, context_) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_ContextGLX::releaseDrawingContext() { - if (m_display == nullptr) { + if (display_ == nullptr) { return GHOST_kFailure; } active_context_ = nullptr; - return ::glXMakeCurrent(m_display, None, nullptr) ? GHOST_kSuccess : GHOST_kFailure; + return ::glXMakeCurrent(display_, None, nullptr) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() @@ -108,8 +108,8 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() #ifdef USE_GLXEW_INIT_WORKAROUND const GLubyte *extStart = (GLubyte *)""; const GLubyte *extEnd; - if (glXQueryExtension(m_display, nullptr, nullptr)) { - extStart = (const GLubyte *)glXGetClientString(m_display, GLX_EXTENSIONS); + if (glXQueryExtension(display_, nullptr, nullptr)) { + extStart = (const GLubyte *)glXGetClientString(display_, GLX_EXTENSIONS); if ((extStart == nullptr) || (glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glXGetProcAddressARB( (const GLubyte *)"glXChooseFBConfig")) == nullptr || @@ -150,11 +150,11 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() #endif /* USE_GLXEW_INIT_WORKAROUND */ if (GLXEW_ARB_create_context) { - int profileBitCore = m_contextProfileMask & GLX_CONTEXT_CORE_PROFILE_BIT_ARB; - int profileBitCompat = m_contextProfileMask & GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; + int profileBitCore = context_profile_mask_ & GLX_CONTEXT_CORE_PROFILE_BIT_ARB; + int profileBitCompat = context_profile_mask_ & GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; #ifdef WITH_GLEW_ES - int profileBitES = m_contextProfileMask & GLX_CONTEXT_ES_PROFILE_BIT_EXT; + int profileBitES = context_profile_mask_ & GLX_CONTEXT_ES_PROFILE_BIT_EXT; #endif if (!GLXEW_ARB_create_context_profile && profileBitCore) { @@ -165,11 +165,11 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() } #ifdef WITH_GLEW_ES - if (!GLXEW_EXT_create_context_es_profile && profileBitES && m_contextMajorVersion == 1) { + if (!GLXEW_EXT_create_context_es_profile && profileBitES && context_major_version_ == 1) { fprintf(stderr, "Warning! OpenGL ES profile not available.\n"); } - if (!GLXEW_EXT_create_context_es2_profile && profileBitES && m_contextMajorVersion == 2) { + if (!GLXEW_EXT_create_context_es2_profile && profileBitES && context_major_version_ == 2) { fprintf(stderr, "Warning! OpenGL ES2 profile not available.\n"); } #endif @@ -189,7 +189,7 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() } #endif - if (profileMask != m_contextProfileMask) { + if (profileMask != context_profile_mask_) { fprintf(stderr, "Warning! Ignoring untested OpenGL context profile mask bits."); } /* max 10 attributes plus terminator */ @@ -201,22 +201,22 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() attribs[i++] = profileMask; } - if (m_contextMajorVersion != 0) { + if (context_major_version_ != 0) { attribs[i++] = GLX_CONTEXT_MAJOR_VERSION_ARB; - attribs[i++] = m_contextMajorVersion; + attribs[i++] = context_major_version_; attribs[i++] = GLX_CONTEXT_MINOR_VERSION_ARB; - attribs[i++] = m_contextMinorVersion; + attribs[i++] = context_minor_version_; } - if (m_contextFlags != 0) { + if (context_flags_ != 0) { attribs[i++] = GLX_CONTEXT_FLAGS_ARB; - attribs[i++] = m_contextFlags; + attribs[i++] = context_flags_; } - if (m_contextResetNotificationStrategy != 0) { + if (context_reset_notification_strategy_ != 0) { if (GLXEW_ARB_create_context_robustness) { attribs[i++] = GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB; - attribs[i++] = m_contextResetNotificationStrategy; + attribs[i++] = context_reset_notification_strategy_; } else { fprintf(stderr, "Warning! Cannot set the reset notification strategy."); @@ -230,12 +230,11 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() int pbuffer_attribs[] = {GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, None}; /* Create a GL 3.x context */ - if (m_fbconfig) { - m_context = glXCreateContextAttribsARB( - m_display, m_fbconfig, s_sharedContext, true, attribs); + if (fbconfig_) { + context_ = glXCreateContextAttribsARB(display_, fbconfig_, s_sharedContext, true, attribs); - if (!m_window) { - m_window = (Window)glXCreatePbuffer(m_display, m_fbconfig, pbuffer_attribs); + if (!window_) { + window_ = (Window)glXCreatePbuffer(display_, fbconfig_, pbuffer_attribs); } } else { @@ -244,22 +243,21 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() int glx_attribs[64]; int fbcount = 0; - GHOST_X11_GL_GetAttributes( - glx_attribs, 64, m_context_params.is_stereo_visual, false, true); + GHOST_X11_GL_GetAttributes(glx_attribs, 64, context_params_.is_stereo_visual, false, true); framebuffer_config = glXChooseFBConfig( - m_display, DefaultScreen(m_display), glx_attribs, &fbcount); + display_, DefaultScreen(display_), glx_attribs, &fbcount); } if (framebuffer_config) { - m_context = glXCreateContextAttribsARB( - m_display, framebuffer_config[0], s_sharedContext, True, attribs); + context_ = glXCreateContextAttribsARB( + display_, framebuffer_config[0], s_sharedContext, True, attribs); - if (!m_window) { - m_window = (Window)glXCreatePbuffer(m_display, framebuffer_config[0], pbuffer_attribs); + if (!window_) { + window_ = (Window)glXCreatePbuffer(display_, framebuffer_config[0], pbuffer_attribs); } - m_fbconfig = framebuffer_config[0]; + fbconfig_ = framebuffer_config[0]; XFree(framebuffer_config); } } @@ -271,15 +269,15 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() GHOST_TSuccess success; - if (m_context != nullptr) { + if (context_ != nullptr) { const uchar *version; if (!s_sharedContext) { - s_sharedContext = m_context; + s_sharedContext = context_; } s_sharedCount++; - glXMakeCurrent(m_display, m_window, m_context); + glXMakeCurrent(display_, window_, context_); /* For performance measurements with VSync disabled. */ { @@ -289,9 +287,9 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() } } - if (m_window) { + if (window_) { initClearGL(); - ::glXSwapBuffers(m_display, m_window); + ::glXSwapBuffers(display_, window_); } version = glGetString(GL_VERSION); @@ -316,28 +314,28 @@ GHOST_TSuccess GHOST_ContextGLX::initializeDrawingContext() GHOST_TSuccess GHOST_ContextGLX::releaseNativeHandles() { - m_window = 0; + window_ = 0; return GHOST_kSuccess; } GHOST_TSuccess GHOST_ContextGLX::setSwapInterval(int interval) { - if (epoxy_has_glx_extension(m_display, DefaultScreen(m_display), "GLX_EXT_swap_control")) { - ::glXSwapIntervalEXT(m_display, m_window, interval); + if (epoxy_has_glx_extension(display_, DefaultScreen(display_), "GLX_EXT_swap_control")) { + ::glXSwapIntervalEXT(display_, window_, interval); return GHOST_kSuccess; } return GHOST_kFailure; } -GHOST_TSuccess GHOST_ContextGLX::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextGLX::getSwapInterval(int &interval_out) { - if (epoxy_has_glx_extension(m_display, DefaultScreen(m_display), "GLX_EXT_swap_control")) { + if (epoxy_has_glx_extension(display_, DefaultScreen(display_), "GLX_EXT_swap_control")) { uint interval = 0; - ::glXQueryDrawable(m_display, m_window, GLX_SWAP_INTERVAL_EXT, &interval); + ::glXQueryDrawable(display_, window_, GLX_SWAP_INTERVAL_EXT, &interval); - intervalOut = int(interval); + interval_out = int(interval); return GHOST_kSuccess; } diff --git a/intern/ghost/intern/GHOST_ContextGLX.hh b/intern/ghost/intern/GHOST_ContextGLX.hh index 0db3b947b53..2707dc2e24e 100644 --- a/intern/ghost/intern/GHOST_ContextGLX.hh +++ b/intern/ghost/intern/GHOST_ContextGLX.hh @@ -84,23 +84,23 @@ class GHOST_ContextGLX : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; private: - Display *m_display; - GLXFBConfig m_fbconfig; - Window m_window; + Display *display_; + GLXFBConfig fbconfig_; + Window window_; - const int m_contextProfileMask; - const int m_contextMajorVersion; - const int m_contextMinorVersion; - const int m_contextFlags; - const int m_contextResetNotificationStrategy; + const int context_profile_mask_; + const int context_major_version_; + const int context_minor_version_; + const int context_flags_; + const int context_reset_notification_strategy_; - GLXContext m_context; + GLXContext context_; /** The first created OpenGL context (for sharing display lists) */ static GLXContext s_sharedContext; diff --git a/intern/ghost/intern/GHOST_ContextMTL.hh b/intern/ghost/intern/GHOST_ContextMTL.hh index e047ec53431..28cb6431412 100644 --- a/intern/ghost/intern/GHOST_ContextMTL.hh +++ b/intern/ghost/intern/GHOST_ContextMTL.hh @@ -92,10 +92,10 @@ class GHOST_ContextMTL : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; /** * Updates the drawing context of this window. @@ -129,15 +129,15 @@ class GHOST_ContextMTL : public GHOST_Context { private: /** Metal state */ - NSView *m_metalView; - CAMetalLayer *m_metalLayer; - MTLRenderPipelineState *m_metalRenderPipeline; - bool m_ownsMetalDevice; + NSView *metal_view_; + CAMetalLayer *metal_layer_; + MTLRenderPipelineState *metal_render_pipeline_; + bool owns_metal_device_; /** The virtualized default frame-buffer's texture. */ /** * Texture that you can render into with Metal. The texture will be - * composited on top of `m_defaultFramebufferMetalTexture` whenever + * composited on top of `default_framebuffer_metal_texture_` whenever * `swapBuffers` is called. */ static const int METAL_SWAPCHAIN_SIZE = 3; @@ -145,7 +145,7 @@ class GHOST_ContextMTL : public GHOST_Context { id texture; unsigned int index; }; - MTLSwapchainTexture m_defaultFramebufferMetalTexture[METAL_SWAPCHAIN_SIZE]; + MTLSwapchainTexture default_framebuffer_metal_texture_[METAL_SWAPCHAIN_SIZE]; unsigned int current_swapchain_index = 0; /* Present callback. diff --git a/intern/ghost/intern/GHOST_ContextMTL.mm b/intern/ghost/intern/GHOST_ContextMTL.mm index 89154f852db..051add2bf4a 100644 --- a/intern/ghost/intern/GHOST_ContextMTL.mm +++ b/intern/ghost/intern/GHOST_ContextMTL.mm @@ -50,46 +50,46 @@ GHOST_ContextMTL::GHOST_ContextMTL(const GHOST_ContextParams &context_params, NSView *metalView, CAMetalLayer *metalLayer) : GHOST_Context(context_params), - m_metalView(metalView), - m_metalLayer(metalLayer), - m_metalRenderPipeline(nil) + metal_view_(metalView), + metal_layer_(metalLayer), + metal_render_pipeline_(nil) { @autoreleasepool { /* Initialize Metal Swap-chain. */ current_swapchain_index = 0; for (int i = 0; i < METAL_SWAPCHAIN_SIZE; i++) { - m_defaultFramebufferMetalTexture[i].texture = nil; - m_defaultFramebufferMetalTexture[i].index = i; + default_framebuffer_metal_texture_[i].texture = nil; + default_framebuffer_metal_texture_[i].index = i; } - if (m_metalView) { - m_ownsMetalDevice = false; + if (metal_view_) { + owns_metal_device_ = false; metalInit(); } else { /* Prepare offscreen GHOST Context Metal device. */ id metalDevice = MTLCreateSystemDefaultDevice(); - if (m_context_params.is_debug) { + if (context_params_.is_debug) { printf("Selected Metal Device: %s\n", [metalDevice.name UTF8String]); } - m_ownsMetalDevice = true; + owns_metal_device_ = true; if (metalDevice) { - m_metalLayer = [[CAMetalLayer alloc] init]; - m_metalLayer.edgeAntialiasingMask = 0; - m_metalLayer.masksToBounds = NO; - m_metalLayer.opaque = YES; - m_metalLayer.framebufferOnly = YES; - m_metalLayer.presentsWithTransaction = NO; - [m_metalLayer removeAllAnimations]; - m_metalLayer.device = metalDevice; - m_metalLayer.allowsNextDrawableTimeout = NO; + metal_layer_ = [[CAMetalLayer alloc] init]; + metal_layer_.edgeAntialiasingMask = 0; + metal_layer_.masksToBounds = NO; + metal_layer_.opaque = YES; + metal_layer_.framebufferOnly = YES; + metal_layer_.presentsWithTransaction = NO; + [metal_layer_ removeAllAnimations]; + metal_layer_.device = metalDevice; + metal_layer_.allowsNextDrawableTimeout = NO; { const GHOST_TVSyncModes vsync = getVSync(); if (vsync != GHOST_kVSyncModeUnset) { - m_metalLayer.displaySyncEnabled = (vsync == GHOST_kVSyncModeOff) ? NO : YES; + metal_layer_.displaySyncEnabled = (vsync == GHOST_kVSyncModeOff) ? NO : YES; } } @@ -99,11 +99,11 @@ GHOST_ContextMTL::GHOST_ContextMTL(const GHOST_ContextParams &context_params, * 3. Setting the extended sRGB color space so that the OS knows how to interpret the * values. */ - m_metalLayer.wantsExtendedDynamicRangeContent = YES; - m_metalLayer.pixelFormat = METAL_FRAMEBUFFERPIXEL_FORMAT_EDR; + metal_layer_.wantsExtendedDynamicRangeContent = YES; + metal_layer_.pixelFormat = METAL_FRAMEBUFFERPIXEL_FORMAT_EDR; const CFStringRef name = kCGColorSpaceExtendedSRGB; CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(name); - m_metalLayer.colorspace = colorspace; + metal_layer_.colorspace = colorspace; CGColorSpaceRelease(colorspace); metalInit(); @@ -123,10 +123,10 @@ GHOST_ContextMTL::~GHOST_ContextMTL() { metalFree(); - if (m_ownsMetalDevice) { - if (m_metalLayer) { - [m_metalLayer release]; - m_metalLayer = nil; + if (owns_metal_device_) { + if (metal_layer_) { + [metal_layer_ release]; + metal_layer_ = nil; } } assert(s_sharedCount); @@ -140,7 +140,7 @@ GHOST_ContextMTL::~GHOST_ContextMTL() GHOST_TSuccess GHOST_ContextMTL::swapBuffers() { - if (m_metalView) { + if (metal_view_) { metalSwapBuffers(); } return GHOST_kSuccess; @@ -152,9 +152,9 @@ GHOST_TSuccess GHOST_ContextMTL::setSwapInterval(int interval) return GHOST_kSuccess; } -GHOST_TSuccess GHOST_ContextMTL::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextMTL::getSwapInterval(int &interval_out) { - intervalOut = mtl_SwapInterval; + interval_out = mtl_SwapInterval; return GHOST_kSuccess; } @@ -178,7 +178,7 @@ unsigned int GHOST_ContextMTL::getDefaultFramebuffer() GHOST_TSuccess GHOST_ContextMTL::updateDrawingContext() { - if (m_metalView) { + if (metal_view_) { metalUpdateFramebuffer(); return GHOST_kSuccess; } @@ -194,7 +194,7 @@ id GHOST_ContextMTL::metalOverlayTexture() updateDrawingContext(); /* Return texture. */ - return m_defaultFramebufferMetalTexture[current_swapchain_index].texture; + return default_framebuffer_metal_texture_[current_swapchain_index].texture; } MTLCommandQueue *GHOST_ContextMTL::metalCommandQueue() @@ -203,7 +203,7 @@ MTLCommandQueue *GHOST_ContextMTL::metalCommandQueue() } MTLDevice *GHOST_ContextMTL::metalDevice() { - id device = m_metalLayer.device; + id device = metal_layer_.device; return (MTLDevice *)device; } @@ -216,7 +216,7 @@ void GHOST_ContextMTL::metalRegisterPresentCallback(void (*callback)( GHOST_TSuccess GHOST_ContextMTL::initializeDrawingContext() { @autoreleasepool { - if (m_metalView) { + if (metal_view_) { metalInitFramebuffer(); } } @@ -226,7 +226,7 @@ GHOST_TSuccess GHOST_ContextMTL::initializeDrawingContext() GHOST_TSuccess GHOST_ContextMTL::releaseNativeHandles() { - m_metalView = nil; + metal_view_ = nil; return GHOST_kSuccess; } @@ -234,7 +234,7 @@ GHOST_TSuccess GHOST_ContextMTL::releaseNativeHandles() void GHOST_ContextMTL::metalInit() { @autoreleasepool { - id device = m_metalLayer.device; + id device = metal_layer_.device; /* Create a command queue for blit/present operation. * NOTE: All context should share a single command queue @@ -303,7 +303,7 @@ void GHOST_ContextMTL::metalInit() /* Ensure library is released. */ [library autorelease]; - m_metalRenderPipeline = (MTLRenderPipelineState *)[device + metal_render_pipeline_ = (MTLRenderPipelineState *)[device newRenderPipelineStateWithDescriptor:desc error:&error]; if (error) { @@ -332,15 +332,15 @@ void GHOST_ContextMTL::metalInit() void GHOST_ContextMTL::metalFree() { - if (m_metalRenderPipeline) { - [m_metalRenderPipeline release]; - m_metalRenderPipeline = nil; + if (metal_render_pipeline_) { + [metal_render_pipeline_ release]; + metal_render_pipeline_ = nil; } for (int i = 0; i < METAL_SWAPCHAIN_SIZE; i++) { - if (m_defaultFramebufferMetalTexture[i].texture) { - [m_defaultFramebufferMetalTexture[i].texture release]; - m_defaultFramebufferMetalTexture[i].texture = nil; + if (default_framebuffer_metal_texture_[i].texture) { + [default_framebuffer_metal_texture_[i].texture release]; + default_framebuffer_metal_texture_[i].texture = nil; } } } @@ -353,22 +353,22 @@ void GHOST_ContextMTL::metalInitFramebuffer() void GHOST_ContextMTL::metalUpdateFramebuffer() { @autoreleasepool { - const NSRect bounds = [m_metalView bounds]; - const NSSize backingSize = [m_metalView convertSizeToBacking:bounds.size]; + const NSRect bounds = [metal_view_ bounds]; + const NSSize backingSize = [metal_view_ convertSizeToBacking:bounds.size]; const size_t width = size_t(backingSize.width); const size_t height = size_t(backingSize.height); - if (m_defaultFramebufferMetalTexture[current_swapchain_index].texture && - m_defaultFramebufferMetalTexture[current_swapchain_index].texture.width == width && - m_defaultFramebufferMetalTexture[current_swapchain_index].texture.height == height) + if (default_framebuffer_metal_texture_[current_swapchain_index].texture && + default_framebuffer_metal_texture_[current_swapchain_index].texture.width == width && + default_framebuffer_metal_texture_[current_swapchain_index].texture.height == height) { return; } /* Free old texture */ - [m_defaultFramebufferMetalTexture[current_swapchain_index].texture release]; + [default_framebuffer_metal_texture_[current_swapchain_index].texture release]; - id device = m_metalLayer.device; + id device = metal_layer_.device; MTLTextureDescriptor *overlayDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:METAL_FRAMEBUFFERPIXEL_FORMAT_EDR width:width @@ -387,14 +387,14 @@ void GHOST_ContextMTL::metalUpdateFramebuffer() stringWithFormat:@"Metal Overlay for GHOST Context %p", this]; //@""; } - m_defaultFramebufferMetalTexture[current_swapchain_index].texture = overlayTex; + default_framebuffer_metal_texture_[current_swapchain_index].texture = overlayTex; /* Clear texture on create */ id cmdBuffer = [s_sharedMetalCommandQueue commandBuffer]; MTLRenderPassDescriptor *passDescriptor = [MTLRenderPassDescriptor renderPassDescriptor]; { auto attachment = [passDescriptor.colorAttachments objectAtIndexedSubscript:0]; - attachment.texture = m_defaultFramebufferMetalTexture[current_swapchain_index].texture; + attachment.texture = default_framebuffer_metal_texture_[current_swapchain_index].texture; attachment.loadAction = MTLLoadActionClear; attachment.clearColor = MTLClearColorMake(0.294, 0.294, 0.294, 1.000); attachment.storeAction = MTLStoreActionStore; @@ -406,7 +406,7 @@ void GHOST_ContextMTL::metalUpdateFramebuffer() } [cmdBuffer commit]; - m_metalLayer.drawableSize = CGSizeMake(CGFloat(width), CGFloat(height)); + metal_layer_.drawableSize = CGSizeMake(CGFloat(width), CGFloat(height)); } } @@ -415,7 +415,7 @@ void GHOST_ContextMTL::metalSwapBuffers() @autoreleasepool { updateDrawingContext(); - id drawable = [m_metalLayer nextDrawable]; + id drawable = [metal_layer_ nextDrawable]; if (!drawable) { return; } @@ -430,10 +430,10 @@ void GHOST_ContextMTL::metalSwapBuffers() } assert(contextPresentCallback); - assert(m_defaultFramebufferMetalTexture[current_swapchain_index].texture != nil); + assert(default_framebuffer_metal_texture_[current_swapchain_index].texture != nil); (*contextPresentCallback)(passDescriptor, - (id)m_metalRenderPipeline, - m_defaultFramebufferMetalTexture[current_swapchain_index].texture, + (id)metal_render_pipeline_, + default_framebuffer_metal_texture_[current_swapchain_index].texture, drawable); } } diff --git a/intern/ghost/intern/GHOST_ContextNone.cc b/intern/ghost/intern/GHOST_ContextNone.cc index c351f793540..25614d4ac4e 100644 --- a/intern/ghost/intern/GHOST_ContextNone.cc +++ b/intern/ghost/intern/GHOST_ContextNone.cc @@ -45,13 +45,13 @@ GHOST_TSuccess GHOST_ContextNone::releaseNativeHandles() GHOST_TSuccess GHOST_ContextNone::setSwapInterval(int interval) { - m_swapInterval = interval; + swap_interval_ = interval; return GHOST_kSuccess; } -GHOST_TSuccess GHOST_ContextNone::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextNone::getSwapInterval(int &interval_out) { - intervalOut = m_swapInterval; + interval_out = swap_interval_; return GHOST_kSuccess; } diff --git a/intern/ghost/intern/GHOST_ContextNone.hh b/intern/ghost/intern/GHOST_ContextNone.hh index ccd2e56dc2f..55ca1807e5c 100644 --- a/intern/ghost/intern/GHOST_ContextNone.hh +++ b/intern/ghost/intern/GHOST_ContextNone.hh @@ -60,11 +60,11 @@ class GHOST_ContextNone : public GHOST_Context { /** * Dummy function - * \param intervalOut: Gets whatever was set by #setSwapInterval. + * \param interval_out: Gets whatever was set by #setSwapInterval. * \return Always succeeds. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; private: - int m_swapInterval = 1; + int swap_interval_ = 1; }; diff --git a/intern/ghost/intern/GHOST_ContextSDL.cc b/intern/ghost/intern/GHOST_ContextSDL.cc index 1763018b02b..5b7a51cc5df 100644 --- a/intern/ghost/intern/GHOST_ContextSDL.cc +++ b/intern/ghost/intern/GHOST_ContextSDL.cc @@ -24,28 +24,28 @@ GHOST_ContextSDL::GHOST_ContextSDL(const GHOST_ContextParams &context_params, int contextFlags, int contextResetNotificationStrategy) : GHOST_Context(context_params), - m_window(window), - m_hidden_window(nullptr), - m_contextProfileMask(contextProfileMask), - m_contextMajorVersion(contextMajorVersion), - m_contextMinorVersion(contextMinorVersion), - m_contextFlags(contextFlags), - m_contextResetNotificationStrategy(contextResetNotificationStrategy), - m_context(nullptr) + window_(window), + hidden_window_(nullptr), + context_profile_mask_(contextProfileMask), + context_major_version_(contextMajorVersion), + context_minor_version_(contextMinorVersion), + context_flags_(contextFlags), + context_reset_notification_strategy_(contextResetNotificationStrategy), + context_(nullptr) { - // assert(m_window != nullptr); + // assert(window_ != nullptr); } GHOST_ContextSDL::~GHOST_ContextSDL() { - if (m_context == nullptr) { + if (context_ == nullptr) { return; } - if (m_window != nullptr && m_context == SDL_GL_GetCurrentContext()) { - SDL_GL_MakeCurrent(m_window, nullptr); + if (window_ != nullptr && context_ == SDL_GL_GetCurrentContext()) { + SDL_GL_MakeCurrent(window_, nullptr); } - if (m_context != s_sharedContext || s_sharedCount == 1) { + if (context_ != s_sharedContext || s_sharedCount == 1) { assert(s_sharedCount > 0); s_sharedCount--; @@ -53,33 +53,33 @@ GHOST_ContextSDL::~GHOST_ContextSDL() if (s_sharedCount == 0) { s_sharedContext = nullptr; } - SDL_GL_DeleteContext(m_context); + SDL_GL_DeleteContext(context_); } - if (m_hidden_window != nullptr) { - SDL_DestroyWindow(m_hidden_window); + if (hidden_window_ != nullptr) { + SDL_DestroyWindow(hidden_window_); } } GHOST_TSuccess GHOST_ContextSDL::swapBuffers() { - SDL_GL_SwapWindow(m_window); + SDL_GL_SwapWindow(window_); return GHOST_kSuccess; } GHOST_TSuccess GHOST_ContextSDL::activateDrawingContext() { - if (m_context == nullptr) { + if (context_ == nullptr) { return GHOST_kFailure; } active_context_ = this; - return SDL_GL_MakeCurrent(m_window, m_context) ? GHOST_kSuccess : GHOST_kFailure; + return SDL_GL_MakeCurrent(window_, context_) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_ContextSDL::releaseDrawingContext() { - if (m_context == nullptr) { + if (context_ == nullptr) { return GHOST_kFailure; } active_context_ = nullptr; @@ -91,10 +91,10 @@ GHOST_TSuccess GHOST_ContextSDL::initializeDrawingContext() { const bool needAlpha = false; - SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, m_contextProfileMask); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, m_contextMajorVersion); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, m_contextMinorVersion); - SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, m_contextFlags); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, context_profile_mask_); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, context_major_version_); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, context_minor_version_); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, context_flags_); SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); @@ -106,33 +106,33 @@ GHOST_TSuccess GHOST_ContextSDL::initializeDrawingContext() SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); } - if (m_context_params.is_stereo_visual) { + if (context_params_.is_stereo_visual) { SDL_GL_SetAttribute(SDL_GL_STEREO, 1); } - if (m_window == nullptr) { - m_hidden_window = SDL_CreateWindow("Offscreen Context Windows", - SDL_WINDOWPOS_UNDEFINED, - SDL_WINDOWPOS_UNDEFINED, - 1, - 1, - SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS | - SDL_WINDOW_HIDDEN); + if (window_ == nullptr) { + hidden_window_ = SDL_CreateWindow("Offscreen Context Windows", + SDL_WINDOWPOS_UNDEFINED, + SDL_WINDOWPOS_UNDEFINED, + 1, + 1, + SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS | + SDL_WINDOW_HIDDEN); - m_window = m_hidden_window; + window_ = hidden_window_; } - m_context = SDL_GL_CreateContext(m_window); + context_ = SDL_GL_CreateContext(window_); GHOST_TSuccess success; - if (m_context != nullptr) { + if (context_ != nullptr) { if (!s_sharedContext) { - s_sharedContext = m_context; + s_sharedContext = context_; } s_sharedCount++; - success = (SDL_GL_MakeCurrent(m_window, m_context) < 0) ? GHOST_kFailure : GHOST_kSuccess; + success = (SDL_GL_MakeCurrent(window_, context_) < 0) ? GHOST_kFailure : GHOST_kSuccess; { const GHOST_TVSyncModes vsync = getVSync(); @@ -142,7 +142,7 @@ GHOST_TSuccess GHOST_ContextSDL::initializeDrawingContext() } initClearGL(); - SDL_GL_SwapWindow(m_window); + SDL_GL_SwapWindow(window_); active_context_ = this; success = GHOST_kSuccess; @@ -156,7 +156,7 @@ GHOST_TSuccess GHOST_ContextSDL::initializeDrawingContext() GHOST_TSuccess GHOST_ContextSDL::releaseNativeHandles() { - m_window = nullptr; + window_ = nullptr; return GHOST_kSuccess; } @@ -169,8 +169,8 @@ GHOST_TSuccess GHOST_ContextSDL::setSwapInterval(int interval) return GHOST_kSuccess; } -GHOST_TSuccess GHOST_ContextSDL::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextSDL::getSwapInterval(int &interval_out) { - intervalOut = SDL_GL_GetSwapInterval(); + interval_out = SDL_GL_GetSwapInterval(); return GHOST_kSuccess; } diff --git a/intern/ghost/intern/GHOST_ContextSDL.hh b/intern/ghost/intern/GHOST_ContextSDL.hh index 606b0157e6c..e504235c038 100644 --- a/intern/ghost/intern/GHOST_ContextSDL.hh +++ b/intern/ghost/intern/GHOST_ContextSDL.hh @@ -84,22 +84,22 @@ class GHOST_ContextSDL : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; private: - SDL_Window *m_window; - SDL_Window *m_hidden_window; + SDL_Window *window_; + SDL_Window *hidden_window_; - const int m_contextProfileMask; - const int m_contextMajorVersion; - const int m_contextMinorVersion; - const int m_contextFlags; - const int m_contextResetNotificationStrategy; + const int context_profile_mask_; + const int context_major_version_; + const int context_minor_version_; + const int context_flags_; + const int context_reset_notification_strategy_; - SDL_GLContext m_context; /* m_sdl_glcontext */ + SDL_GLContext context_; /* sdl_glcontext_ */ /** The first created OpenGL context (for sharing display lists) */ static SDL_GLContext s_sharedContext; diff --git a/intern/ghost/intern/GHOST_ContextVK.cc b/intern/ghost/intern/GHOST_ContextVK.cc index 17804681da1..64c8c17ec69 100644 --- a/intern/ghost/intern/GHOST_ContextVK.cc +++ b/intern/ghost/intern/GHOST_ContextVK.cc @@ -569,26 +569,26 @@ GHOST_ContextVK::GHOST_ContextVK(const GHOST_ContextParams &context_params, const GHOST_GPUDevice &preferred_device) : GHOST_Context(context_params), #ifdef _WIN32 - m_hwnd(hwnd), + hwnd_(hwnd), #elif defined(__APPLE__) - m_metal_layer(metal_layer), + metal_layer_(metal_layer), #else - m_platform(platform), + platform_(platform), /* X11 */ - m_display(display), - m_window(window), + display_(display), + window_(window), /* Wayland */ - m_wayland_surface(wayland_surface), - m_wayland_display(wayland_display), - m_wayland_window_info(wayland_window_info), + wayland_surface_(wayland_surface), + wayland_display_(wayland_display), + wayland_window_info_(wayland_window_info), #endif - m_context_major_version(contextMajorVersion), - m_context_minor_version(contextMinorVersion), - m_preferred_device(preferred_device), - m_surface(VK_NULL_HANDLE), - m_swapchain(VK_NULL_HANDLE), - m_frame_data(GHOST_FRAMES_IN_FLIGHT), - m_render_frame(0) + context_major_version_(contextMajorVersion), + context_minor_version_(contextMinorVersion), + preferred_device_(preferred_device), + surface_(VK_NULL_HANDLE), + swapchain_(VK_NULL_HANDLE), + frame_data_(GHOST_FRAMES_IN_FLIGHT), + render_frame_(0) { } @@ -600,8 +600,8 @@ GHOST_ContextVK::~GHOST_ContextVK() destroySwapchain(); - if (m_surface != VK_NULL_HANDLE) { - vkDestroySurfaceKHR(device_vk.instance, m_surface, nullptr); + if (surface_ != VK_NULL_HANDLE) { + vkDestroySurfaceKHR(device_vk.instance, surface_, nullptr); } device_vk.users--; @@ -629,8 +629,8 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() * to be complete, it is also safe in the callback to clean up resources associated with the next * frame. */ - m_render_frame = (m_render_frame + 1) % m_frame_data.size(); - GHOST_Frame &submission_frame_data = m_frame_data[m_render_frame]; + render_frame_ = (render_frame_ + 1) % frame_data_.size(); + GHOST_Frame &submission_frame_data = frame_data_[render_frame_]; /* Wait for previous time that the frame was used to finish rendering. Presenting can * still happen in parallel, but acquiring needs can only happen when the frame acquire semaphore * has been signaled and waited for. */ @@ -641,13 +641,12 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() /* Wayland doesn't provide a WSI with windowing capabilities, therefore cannot detect whether the * swap-chain needs to be recreated. But as a side effect we can recreate the swap-chain before * presenting. */ - if (m_wayland_window_info) { - const bool recreate_swapchain = - ((m_wayland_window_info->size[0] != - std::max(m_render_extent.width, m_render_extent_min.width)) || - (m_wayland_window_info->size[1] != - std::max(m_render_extent.height, m_render_extent_min.height))); - use_hdr_swapchain = m_wayland_window_info->is_color_managed; + if (wayland_window_info_) { + const bool recreate_swapchain = ((wayland_window_info_->size[0] != + std::max(render_extent_.width, render_extent_min_.width)) || + (wayland_window_info_->size[1] != + std::max(render_extent_.height, render_extent_min_.height))); + use_hdr_swapchain = wayland_window_info_->is_color_managed; if (recreate_swapchain) { /* Swap-chain is out of date. Recreate swap-chain. */ @@ -657,21 +656,21 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() #endif /* There is no valid swapchain as the previous window was minimized. User can have maximized the * window so we need to check if the swapchain can be created. */ - if (m_swapchain == VK_NULL_HANDLE) { + if (swapchain_ == VK_NULL_HANDLE) { recreateSwapchain(use_hdr_swapchain); } /* Acquiree next image, swapchain can be (or become) invalid when minimizing window.*/ uint32_t image_index = 0; - if (m_swapchain != VK_NULL_HANDLE) { + if (swapchain_ != VK_NULL_HANDLE) { /* Some platforms (NVIDIA/Wayland) can receive an out of date swapchain when acquiring the next * swapchain image. Other do it when calling vkQueuePresent. */ VkResult acquire_result = VK_ERROR_OUT_OF_DATE_KHR; - while (m_swapchain != VK_NULL_HANDLE && + while (swapchain_ != VK_NULL_HANDLE && (acquire_result == VK_ERROR_OUT_OF_DATE_KHR || acquire_result == VK_SUBOPTIMAL_KHR)) { acquire_result = vkAcquireNextImageKHR(device, - m_swapchain, + swapchain_, UINT64_MAX, submission_frame_data.acquire_semaphore, VK_NULL_HANDLE, @@ -684,7 +683,7 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() /* Fast path for invalid swapchains. When not valid we don't acquire/present, but we do render to * make sure the render graphs don't keep memory allocated that isn't used. */ - if (m_swapchain == VK_NULL_HANDLE) { + if (swapchain_ == VK_NULL_HANDLE) { CLOG_TRACE( &LOG, "Swap-chain invalid (due to minimized window), perform rendering to reduce render graph " @@ -702,14 +701,14 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() CLOG_DEBUG(&LOG, "Acquired swap-chain image (render_frame=%lu, image_index=%u)", - m_render_frame, + render_frame_, image_index); - GHOST_SwapchainImage &swapchain_image = m_swapchain_images[image_index]; + GHOST_SwapchainImage &swapchain_image = swapchain_images_[image_index]; GHOST_VulkanSwapChainData swap_chain_data; swap_chain_data.image = swapchain_image.vk_image; - swap_chain_data.surface_format = m_surface_format; - swap_chain_data.extent = m_render_extent; + swap_chain_data.surface_format = surface_format_; + swap_chain_data.extent = render_extent_; swap_chain_data.submission_fence = submission_frame_data.submission_fence; swap_chain_data.acquire_semaphore = submission_frame_data.acquire_semaphore; swap_chain_data.present_semaphore = swapchain_image.present_semaphore; @@ -724,14 +723,14 @@ GHOST_TSuccess GHOST_ContextVK::swapBuffers() present_info.waitSemaphoreCount = 1; present_info.pWaitSemaphores = &swapchain_image.present_semaphore; present_info.swapchainCount = 1; - present_info.pSwapchains = &m_swapchain; + present_info.pSwapchains = &swapchain_; present_info.pImageIndices = &image_index; present_info.pResults = nullptr; VkResult present_result = VK_SUCCESS; { std::scoped_lock lock(vulkan_device->queue_mutex); - present_result = vkQueuePresentKHR(m_present_queue, &present_info); + present_result = vkQueuePresentKHR(present_queue_, &present_info); } if (present_result == VK_ERROR_OUT_OF_DATE_KHR || present_result == VK_SUBOPTIMAL_KHR) { @@ -758,8 +757,8 @@ GHOST_TSuccess GHOST_ContextVK::getVulkanSwapChainFormat( GHOST_VulkanSwapChainData *r_swap_chain_data) { r_swap_chain_data->image = VK_NULL_HANDLE; - r_swap_chain_data->surface_format = m_surface_format; - r_swap_chain_data->extent = m_render_extent; + r_swap_chain_data->surface_format = surface_format_; + r_swap_chain_data->extent = render_extent_; return GHOST_kSuccess; } @@ -781,7 +780,7 @@ GHOST_TSuccess GHOST_ContextVK::getVulkanHandles(GHOST_VulkanHandles &r_handles) vulkan_device->physical_device, vulkan_device->device, vulkan_device->generic_queue_family, - m_graphic_queue, + graphic_queue_, &vulkan_device->queue_mutex, }; } @@ -938,7 +937,7 @@ GHOST_TSuccess GHOST_ContextVK::initializeFrameData() VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0}; const VkFenceCreateInfo vk_fence_create_info = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr, VK_FENCE_CREATE_SIGNALED_BIT}; - for (GHOST_SwapchainImage &swapchain_image : m_swapchain_images) { + for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) { /* VK_EXT_swapchain_maintenance1 reuses present semaphores. */ if (swapchain_image.present_semaphore == VK_NULL_HANDLE) { VK_CHECK(vkCreateSemaphore( @@ -946,8 +945,8 @@ GHOST_TSuccess GHOST_ContextVK::initializeFrameData() } } - for (int index = 0; index < m_frame_data.size(); index++) { - GHOST_Frame &frame_data = m_frame_data[index]; + for (int index = 0; index < frame_data_.size(); index++) { + GHOST_Frame &frame_data = frame_data_[index]; /* VK_EXT_swapchain_maintenance1 reuses acquire semaphores. */ if (frame_data.acquire_semaphore == VK_NULL_HANDLE) { VK_CHECK(vkCreateSemaphore( @@ -968,13 +967,13 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) VkPhysicalDevice physical_device = vulkan_device->physical_device; - m_surface_format = {}; - if (!selectSurfaceFormat(physical_device, m_surface, use_hdr_swapchain, m_surface_format)) { + surface_format_ = {}; + if (!selectSurfaceFormat(physical_device, surface_, use_hdr_swapchain, surface_format_)) { return GHOST_kFailure; } VkPresentModeKHR present_mode; - if (!selectPresentMode(getVSync(), physical_device, m_surface, &present_mode)) { + if (!selectPresentMode(getVSync(), physical_device, surface_, &present_mode)) { return GHOST_kFailure; } @@ -989,7 +988,7 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) VkSurfacePresentModeEXT vk_surface_present_mode = { VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, nullptr, present_mode}; VkPhysicalDeviceSurfaceInfo2KHR vk_physical_device_surface_info = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, &vk_surface_present_mode, m_surface}; + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, &vk_surface_present_mode, surface_}; VkSurfaceCapabilitiesKHR capabilities = {}; if (vulkan_device->use_vk_ext_swapchain_maintenance_1) { @@ -998,12 +997,12 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) capabilities = vk_surface_capabilities.surfaceCapabilities; } else { - vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, m_surface, &capabilities); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface_, &capabilities); } - m_render_extent = capabilities.currentExtent; - m_render_extent_min = capabilities.minImageExtent; - if (m_render_extent.width == UINT32_MAX) { + render_extent_ = capabilities.currentExtent; + render_extent_min_ = capabilities.minImageExtent; + if (render_extent_.width == UINT32_MAX) { /* Window Manager is going to set the surface size based on the given size. * Choose something between minImageExtent and maxImageExtent. */ int width = 0; @@ -1011,9 +1010,9 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) #ifdef WITH_GHOST_WAYLAND /* Wayland doesn't provide a windowing API via WSI. */ - if (m_wayland_window_info) { - width = m_wayland_window_info->size[0]; - height = m_wayland_window_info->size[1]; + if (wayland_window_info_) { + width = wayland_window_info_->size[0]; + height = wayland_window_info_->size[1]; } #endif @@ -1022,32 +1021,32 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) height = 720; } - m_render_extent.width = width; - m_render_extent.height = height; + render_extent_.width = width; + render_extent_.height = height; - if (capabilities.minImageExtent.width > m_render_extent.width) { - m_render_extent.width = capabilities.minImageExtent.width; + if (capabilities.minImageExtent.width > render_extent_.width) { + render_extent_.width = capabilities.minImageExtent.width; } - if (capabilities.minImageExtent.height > m_render_extent.height) { - m_render_extent.height = capabilities.minImageExtent.height; + if (capabilities.minImageExtent.height > render_extent_.height) { + render_extent_.height = capabilities.minImageExtent.height; } } if (vulkan_device->use_vk_ext_swapchain_maintenance_1) { - if (vk_surface_present_scaling_capabilities.minScaledImageExtent.width > m_render_extent.width) + if (vk_surface_present_scaling_capabilities.minScaledImageExtent.width > render_extent_.width) { - m_render_extent.width = vk_surface_present_scaling_capabilities.minScaledImageExtent.width; + render_extent_.width = vk_surface_present_scaling_capabilities.minScaledImageExtent.width; } if (vk_surface_present_scaling_capabilities.minScaledImageExtent.height > - m_render_extent.height) + render_extent_.height) { - m_render_extent.height = vk_surface_present_scaling_capabilities.minScaledImageExtent.height; + render_extent_.height = vk_surface_present_scaling_capabilities.minScaledImageExtent.height; } } /* Discard swapchain resources of current swapchain. */ - GHOST_FrameDiscard &discard_pile = m_frame_data[m_render_frame].discard_pile; - for (GHOST_SwapchainImage &swapchain_image : m_swapchain_images) { + GHOST_FrameDiscard &discard_pile = frame_data_[render_frame_].discard_pile; + for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) { swapchain_image.vk_image = VK_NULL_HANDLE; if (swapchain_image.present_semaphore != VK_NULL_HANDLE) { discard_pile.semaphores.push_back(swapchain_image.present_semaphore); @@ -1060,10 +1059,10 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) * * VUID-VkSwapchainCreateInfoKHR-imageExtent-01689 */ - if (m_render_extent.width == 0 || m_render_extent.height == 0) { - if (m_swapchain) { - discard_pile.swapchains.push_back(m_swapchain); - m_swapchain = VK_NULL_HANDLE; + if (render_extent_.width == 0 || render_extent_.height == 0) { + if (swapchain_) { + discard_pile.swapchains.push_back(swapchain_); + swapchain_ = VK_NULL_HANDLE; } return GHOST_kFailure; } @@ -1080,7 +1079,7 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) image_count_requested = capabilities.maxImageCount; } - VkSwapchainKHR old_swapchain = m_swapchain; + VkSwapchainKHR old_swapchain = swapchain_; /* First time we stretch the swapchain image as it can happen that the first frame size isn't * correctly reported by the initial swapchain. All subsequent creations will use one to one as @@ -1106,11 +1105,11 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) if (vulkan_device->use_vk_ext_swapchain_maintenance_1) { create_info.pNext = &vk_swapchain_present_scaling; } - create_info.surface = m_surface; + create_info.surface = surface_; create_info.minImageCount = image_count_requested; - create_info.imageFormat = m_surface_format.format; - create_info.imageColorSpace = m_surface_format.colorSpace; - create_info.imageExtent = m_render_extent; + create_info.imageFormat = surface_format_.format; + create_info.imageColorSpace = surface_format_.colorSpace; + create_info.imageExtent = render_extent_; create_info.imageArrayLayers = 1; create_info.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; create_info.preTransform = capabilities.currentTransform; @@ -1123,38 +1122,38 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) create_info.pQueueFamilyIndices = nullptr; VkDevice device = vulkan_device->device; - VK_CHECK(vkCreateSwapchainKHR(device, &create_info, nullptr, &m_swapchain)); + VK_CHECK(vkCreateSwapchainKHR(device, &create_info, nullptr, &swapchain_)); /* image_count may not be what we requested! Getter for final value. */ uint32_t actual_image_count = 0; - vkGetSwapchainImagesKHR(device, m_swapchain, &actual_image_count, nullptr); + vkGetSwapchainImagesKHR(device, swapchain_, &actual_image_count, nullptr); /* Some platforms require a minimum amount of render frames that is larger than we expect. When * that happens we should increase the number of frames in flight. We could also consider * splitting the frame in flight and image specific data. */ assert(actual_image_count <= GHOST_FRAMES_IN_FLIGHT); - m_swapchain_images.resize(actual_image_count); + swapchain_images_.resize(actual_image_count); std::vector swapchain_images(actual_image_count); - vkGetSwapchainImagesKHR(device, m_swapchain, &actual_image_count, swapchain_images.data()); + vkGetSwapchainImagesKHR(device, swapchain_, &actual_image_count, swapchain_images.data()); for (int index = 0; index < actual_image_count; index++) { - m_swapchain_images[index].vk_image = swapchain_images[index]; + swapchain_images_[index].vk_image = swapchain_images[index]; } CLOG_DEBUG(&LOG, "Vulkan: recreating swapchain: width=%u, height=%u, format=%d, colorSpace=%d, " "present_mode=%d, image_count_requested=%u, image_count_acquired=%u, swapchain=%lx, " "old_swapchain=%lx", - m_render_extent.width, - m_render_extent.height, - m_surface_format.format, - m_surface_format.colorSpace, + render_extent_.width, + render_extent_.height, + surface_format_.format, + surface_format_.colorSpace, present_mode, image_count_requested, actual_image_count, - uint64_t(m_swapchain), + uint64_t(swapchain_), uint64_t(old_swapchain)); /* Construct new semaphores. It can be that image_count is larger than previously. We only need * to fill in where the handle is `VK_NULL_HANDLE`. */ /* Previous handles from the frame data cannot be used and should be discarded. */ - for (GHOST_Frame &frame : m_frame_data) { + for (GHOST_Frame &frame : frame_data_) { discard_pile.semaphores.push_back(frame.acquire_semaphore); frame.acquire_semaphore = VK_NULL_HANDLE; } @@ -1163,7 +1162,7 @@ GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(bool use_hdr_swapchain) } initializeFrameData(); - m_image_count = actual_image_count; + image_count_ = actual_image_count; return GHOST_kSuccess; } @@ -1173,18 +1172,18 @@ GHOST_TSuccess GHOST_ContextVK::destroySwapchain() assert(vulkan_device.has_value() && vulkan_device->device != VK_NULL_HANDLE); VkDevice device = vulkan_device->device; - if (m_swapchain != VK_NULL_HANDLE) { - vkDestroySwapchainKHR(device, m_swapchain, nullptr); + if (swapchain_ != VK_NULL_HANDLE) { + vkDestroySwapchainKHR(device, swapchain_, nullptr); } VK_CHECK(vkDeviceWaitIdle(device)); - for (GHOST_SwapchainImage &swapchain_image : m_swapchain_images) { + for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) { swapchain_image.destroy(device); } - m_swapchain_images.clear(); - for (GHOST_Frame &frame_data : m_frame_data) { + swapchain_images_.clear(); + for (GHOST_Frame &frame_data : frame_data_) { frame_data.destroy(device); } - m_frame_data.clear(); + frame_data_.clear(); return GHOST_kSuccess; } @@ -1196,7 +1195,7 @@ const char *GHOST_ContextVK::getPlatformSpecificSurfaceExtension() const #elif defined(__APPLE__) return VK_EXT_METAL_SURFACE_EXTENSION_NAME; #else /* UNIX/Linux */ - switch (m_platform) { + switch (platform_) { # ifdef WITH_GHOST_X11 case GHOST_kVulkanPlatformX11: return VK_KHR_XLIB_SURFACE_EXTENSION_NAME; @@ -1218,22 +1217,22 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() { bool use_hdr_swapchain = false; #ifdef _WIN32 - const bool use_window_surface = (m_hwnd != nullptr); + const bool use_window_surface = (hwnd_ != nullptr); #elif defined(__APPLE__) - const bool use_window_surface = (m_metal_layer != nullptr); + const bool use_window_surface = (metal_layer_ != nullptr); #else /* UNIX/Linux */ bool use_window_surface = false; - switch (m_platform) { + switch (platform_) { # ifdef WITH_GHOST_X11 case GHOST_kVulkanPlatformX11: - use_window_surface = (m_display != nullptr) && (m_window != (Window) nullptr); + use_window_surface = (display_ != nullptr) && (window_ != (Window) nullptr); break; # endif # ifdef WITH_GHOST_WAYLAND case GHOST_kVulkanPlatformWayland: - use_window_surface = (m_wayland_display != nullptr) && (m_wayland_surface != nullptr); - if (m_wayland_window_info) { - use_hdr_swapchain = m_wayland_window_info->is_color_managed; + use_window_surface = (wayland_display_ != nullptr) && (wayland_surface_ != nullptr); + if (wayland_window_info_) { + use_hdr_swapchain = wayland_window_info_->is_color_managed; } break; # endif @@ -1248,7 +1247,7 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() vector optional_device_extensions; vector extensions_enabled; - if (m_context_params.is_debug) { + if (context_params_.is_debug) { requireExtension(extensions_available, extensions_enabled, VK_EXT_DEBUG_UTILS_EXTENSION_NAME); } @@ -1262,7 +1261,7 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() /* X11 doesn't use the correct swapchain offset, flipping can squash the first frames. */ const bool use_swapchain_maintenance1 = #ifdef WITH_GHOST_X11 - m_platform != GHOST_kVulkanPlatformX11 && + platform_ != GHOST_kVulkanPlatformX11 && #endif contains_extension(extensions_available, VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) && contains_extension(extensions_available, VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME); @@ -1309,7 +1308,7 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() app_info.applicationVersion = VK_MAKE_VERSION(1, 0, 0); app_info.pEngineName = "Blender"; app_info.engineVersion = VK_MAKE_VERSION(1, 0, 0); - app_info.apiVersion = VK_MAKE_VERSION(m_context_major_version, m_context_minor_version, 0); + app_info.apiVersion = VK_MAKE_VERSION(context_major_version_, context_minor_version_, 0); /* Create Instance */ VkInstanceCreateInfo create_info = {}; @@ -1333,24 +1332,24 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() VkWin32SurfaceCreateInfoKHR surface_create_info = {}; surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; surface_create_info.hinstance = GetModuleHandle(nullptr); - surface_create_info.hwnd = m_hwnd; - VK_CHECK(vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &m_surface)); + surface_create_info.hwnd = hwnd_; + VK_CHECK(vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &surface_)); #elif defined(__APPLE__) VkMetalSurfaceCreateInfoEXT info = {}; info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; info.pNext = nullptr; info.flags = 0; - info.pLayer = m_metal_layer; - VK_CHECK(vkCreateMetalSurfaceEXT(instance, &info, nullptr, &m_surface)); + info.pLayer = metal_layer_; + VK_CHECK(vkCreateMetalSurfaceEXT(instance, &info, nullptr, &surface_)); #else - switch (m_platform) { + switch (platform_) { # ifdef WITH_GHOST_X11 case GHOST_kVulkanPlatformX11: { VkXlibSurfaceCreateInfoKHR surface_create_info = {}; surface_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; - surface_create_info.dpy = m_display; - surface_create_info.window = m_window; - VK_CHECK(vkCreateXlibSurfaceKHR(instance, &surface_create_info, nullptr, &m_surface)); + surface_create_info.dpy = display_; + surface_create_info.window = window_; + VK_CHECK(vkCreateXlibSurfaceKHR(instance, &surface_create_info, nullptr, &surface_)); break; } # endif @@ -1358,14 +1357,14 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() case GHOST_kVulkanPlatformWayland: { VkWaylandSurfaceCreateInfoKHR surface_create_info = {}; surface_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; - surface_create_info.display = m_wayland_display; - surface_create_info.surface = m_wayland_surface; - VK_CHECK(vkCreateWaylandSurfaceKHR(instance, &surface_create_info, nullptr, &m_surface)); + surface_create_info.display = wayland_display_; + surface_create_info.surface = wayland_surface_; + VK_CHECK(vkCreateWaylandSurfaceKHR(instance, &surface_create_info, nullptr, &surface_)); break; } # endif case GHOST_kVulkanPlatformHeadless: { - m_surface = VK_NULL_HANDLE; + surface_ = VK_NULL_HANDLE; break; } } @@ -1373,19 +1372,18 @@ GHOST_TSuccess GHOST_ContextVK::initializeDrawingContext() #endif } - if (!ensure_vulkan_device(instance, m_surface, m_preferred_device, required_device_extensions)) { + if (!ensure_vulkan_device(instance, surface_, preferred_device_, required_device_extensions)) { return GHOST_kFailure; } vulkan_device->users++; vulkan_device->ensure_device(required_device_extensions, optional_device_extensions); - vkGetDeviceQueue( - vulkan_device->device, vulkan_device->generic_queue_family, 0, &m_graphic_queue); + vkGetDeviceQueue(vulkan_device->device, vulkan_device->generic_queue_family, 0, &graphic_queue_); if (use_window_surface) { vkGetDeviceQueue( - vulkan_device->device, vulkan_device->generic_queue_family, 0, &m_present_queue); + vulkan_device->device, vulkan_device->generic_queue_family, 0, &present_queue_); recreateSwapchain(use_hdr_swapchain); } diff --git a/intern/ghost/intern/GHOST_ContextVK.hh b/intern/ghost/intern/GHOST_ContextVK.hh index 8b7672165ca..51ece73aceb 100644 --- a/intern/ghost/intern/GHOST_ContextVK.hh +++ b/intern/ghost/intern/GHOST_ContextVK.hh @@ -192,10 +192,10 @@ class GHOST_ContextVK : public GHOST_Context { /** * Gets the current swap interval for swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int & /*intervalOut*/) override + GHOST_TSuccess getSwapInterval(int & /*interval_out*/) override { return GHOST_kFailure; }; @@ -212,38 +212,38 @@ class GHOST_ContextVK : public GHOST_Context { private: #ifdef _WIN32 - HWND m_hwnd; + HWND hwnd_; #elif defined(__APPLE__) - CAMetalLayer *m_metal_layer; + CAMetalLayer *metal_layer_; #else /* Linux */ - GHOST_TVulkanPlatformType m_platform; + GHOST_TVulkanPlatformType platform_; /* X11 */ - Display *m_display; - Window m_window; + Display *display_; + Window window_; /* Wayland */ - wl_surface *m_wayland_surface; - wl_display *m_wayland_display; - const GHOST_ContextVK_WindowInfo *m_wayland_window_info; + wl_surface *wayland_surface_; + wl_display *wayland_display_; + const GHOST_ContextVK_WindowInfo *wayland_window_info_; #endif - const int m_context_major_version; - const int m_context_minor_version; - const GHOST_GPUDevice m_preferred_device; + const int context_major_version_; + const int context_minor_version_; + const GHOST_GPUDevice preferred_device_; - VkQueue m_graphic_queue; - VkQueue m_present_queue; + VkQueue graphic_queue_; + VkQueue present_queue_; /* For display only. */ - VkSurfaceKHR m_surface; - VkSwapchainKHR m_swapchain; - std::vector m_swapchain_images; - std::vector m_frame_data; - uint64_t m_render_frame; - uint64_t m_image_count; + VkSurfaceKHR surface_; + VkSwapchainKHR swapchain_; + std::vector swapchain_images_; + std::vector frame_data_; + uint64_t render_frame_; + uint64_t image_count_; - VkExtent2D m_render_extent; - VkExtent2D m_render_extent_min; - VkSurfaceFormatKHR m_surface_format; + VkExtent2D render_extent_; + VkExtent2D render_extent_min_; + VkSurfaceFormatKHR surface_format_; std::function swap_buffers_pre_callback_; std::function swap_buffers_post_callback_; diff --git a/intern/ghost/intern/GHOST_ContextWGL.cc b/intern/ghost/intern/GHOST_ContextWGL.cc index 3101b099968..0762b577145 100644 --- a/intern/ghost/intern/GHOST_ContextWGL.cc +++ b/intern/ghost/intern/GHOST_ContextWGL.cc @@ -35,33 +35,33 @@ GHOST_ContextWGL::GHOST_ContextWGL(const GHOST_ContextParams &context_params, int contextFlags, int contextResetNotificationStrategy) : GHOST_Context(context_params), - m_hWnd(hWnd), - m_hDC(hDC), - m_contextProfileMask(contextProfileMask), - m_contextMajorVersion(contextMajorVersion), - m_contextMinorVersion(contextMinorVersion), - m_contextFlags(contextFlags), - m_alphaBackground(alphaBackground), - m_contextResetNotificationStrategy(contextResetNotificationStrategy), - m_hGLRC(nullptr) + h_wnd_(hWnd), + h_DC_(hDC), + context_profile_mask_(contextProfileMask), + context_major_version_(contextMajorVersion), + context_minor_version_(contextMinorVersion), + context_flags_(contextFlags), + alpha_background_(alphaBackground), + context_reset_notification_strategy_(contextResetNotificationStrategy), + h_GLRC_(nullptr) #ifndef NDEBUG , - m_dummyVendor(nullptr), - m_dummyRenderer(nullptr), - m_dummyVersion(nullptr) + dummy_vendor_(nullptr), + dummy_renderer_(nullptr), + dummy_version_(nullptr) #endif { - assert(m_hDC != nullptr); + assert(h_DC_ != nullptr); } GHOST_ContextWGL::~GHOST_ContextWGL() { - if (m_hGLRC != nullptr) { - if (m_hGLRC == ::wglGetCurrentContext()) { + if (h_GLRC_ != nullptr) { + if (h_GLRC_ == ::wglGetCurrentContext()) { WIN32_CHK(::wglMakeCurrent(nullptr, nullptr)); } - if (m_hGLRC != s_sharedHGLRC || s_sharedCount == 1) { + if (h_GLRC_ != s_sharedHGLRC || s_sharedCount == 1) { assert(s_sharedCount > 0); s_sharedCount--; @@ -70,27 +70,27 @@ GHOST_ContextWGL::~GHOST_ContextWGL() s_sharedHGLRC = nullptr; } - WIN32_CHK(::wglDeleteContext(m_hGLRC)); + WIN32_CHK(::wglDeleteContext(h_GLRC_)); } } #ifndef NDEBUG - if (m_dummyRenderer) { - free((void *)m_dummyRenderer); - free((void *)m_dummyVendor); - free((void *)m_dummyVersion); + if (dummy_renderer_) { + free((void *)dummy_renderer_); + free((void *)dummy_vendor_); + free((void *)dummy_version_); } #endif } GHOST_TSuccess GHOST_ContextWGL::swapBuffers() { - return WIN32_CHK(::SwapBuffers(m_hDC)) ? GHOST_kSuccess : GHOST_kFailure; + return WIN32_CHK(::SwapBuffers(h_DC_)) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_ContextWGL::setSwapInterval(int interval) { - if (epoxy_has_wgl_extension(m_hDC, "WGL_EXT_swap_control")) { + if (epoxy_has_wgl_extension(h_DC_, "WGL_EXT_swap_control")) { return WIN32_CHK(::wglSwapIntervalEXT(interval)) == TRUE ? GHOST_kSuccess : GHOST_kFailure; } else { @@ -98,10 +98,10 @@ GHOST_TSuccess GHOST_ContextWGL::setSwapInterval(int interval) } } -GHOST_TSuccess GHOST_ContextWGL::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_ContextWGL::getSwapInterval(int &interval_out) { - if (epoxy_has_wgl_extension(m_hDC, "WGL_EXT_swap_control")) { - intervalOut = ::wglGetSwapIntervalEXT(); + if (epoxy_has_wgl_extension(h_DC_, "WGL_EXT_swap_control")) { + interval_out = ::wglGetSwapIntervalEXT(); return GHOST_kSuccess; } else { @@ -111,7 +111,7 @@ GHOST_TSuccess GHOST_ContextWGL::getSwapInterval(int &intervalOut) GHOST_TSuccess GHOST_ContextWGL::activateDrawingContext() { - if (WIN32_CHK(::wglMakeCurrent(m_hDC, m_hGLRC))) { + if (WIN32_CHK(::wglMakeCurrent(h_DC_, h_GLRC_))) { active_context_ = this; return GHOST_kSuccess; } @@ -124,7 +124,7 @@ GHOST_TSuccess GHOST_ContextWGL::releaseDrawingContext() { /* Calling wglMakeCurrent(nullptr, nullptr) without an active context returns an error, * so we always pass the device context handle. */ - if (WIN32_CHK(::wglMakeCurrent(m_hDC, nullptr))) { + if (WIN32_CHK(::wglMakeCurrent(h_DC_, nullptr))) { active_context_ = nullptr; return GHOST_kSuccess; } @@ -450,7 +450,7 @@ int GHOST_ContextWGL::_choose_pixel_format_arb_1(bool stereoVisual, bool needAlp uint nNumFormats; WIN32_CHK(wglChoosePixelFormatARB( - m_hDC, &(iAttributes[0]), nullptr, _MAX_PIXEL_FORMATS, iPixelFormats, &nNumFormats)); + h_DC_, &(iAttributes[0]), nullptr, _MAX_PIXEL_FORMATS, iPixelFormats, &nNumFormats)); if (nNumFormats > 0) { iPixelFormat = iPixelFormats[0]; @@ -460,7 +460,7 @@ int GHOST_ContextWGL::_choose_pixel_format_arb_1(bool stereoVisual, bool needAlp if (iPixelFormat != 0) { if (needAlpha) { int alphaBits, iQuery = WGL_ALPHA_BITS_ARB; - wglGetPixelFormatAttribivARB(m_hDC, iPixelFormat, 0, 1, &iQuery, &alphaBits); + wglGetPixelFormatAttribivARB(h_DC_, iPixelFormat, 0, 1, &iQuery, &alphaBits); if (alphaBits == 0) { fprintf(stderr, "Warning! Unable to find a frame buffer with alpha channel.\n"); } @@ -480,7 +480,7 @@ int GHOST_ContextWGL::choose_pixel_format_arb(bool stereoVisual, bool needAlpha) iPixelFormat = _choose_pixel_format_arb_1(false, needAlpha); - m_context_params.is_stereo_visual = false; /* Set context property to actual value. */ + context_params_.is_stereo_visual = false; /* Set context property to actual value. */ } return iPixelFormat; @@ -508,18 +508,18 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() WIN32_CHK(GetLastError() == NO_ERROR); { - const bool needAlpha = m_alphaBackground; - DummyContextWGL dummy(m_hDC, m_hWnd, m_context_params.is_stereo_visual, needAlpha); + const bool needAlpha = alpha_background_; + DummyContextWGL dummy(h_DC_, h_wnd_, context_params_.is_stereo_visual, needAlpha); - if (!dummy.has_WGL_ARB_create_context || ::GetPixelFormat(m_hDC) == 0) { + if (!dummy.has_WGL_ARB_create_context || ::GetPixelFormat(h_DC_) == 0) { int iPixelFormat = 0; if (dummy.has_WGL_ARB_pixel_format) { - iPixelFormat = choose_pixel_format_arb(m_context_params.is_stereo_visual, needAlpha); + iPixelFormat = choose_pixel_format_arb(context_params_.is_stereo_visual, needAlpha); } if (iPixelFormat == 0) { - iPixelFormat = choose_pixel_format_legacy(m_hDC, dummy.preferredPFD); + iPixelFormat = choose_pixel_format_legacy(h_DC_, dummy.preferredPFD); } if (iPixelFormat == 0) { @@ -528,7 +528,7 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() PIXELFORMATDESCRIPTOR chosenPFD; int lastPFD = ::DescribePixelFormat( - m_hDC, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &chosenPFD); + h_DC_, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &chosenPFD); if (!WIN32_CHK(lastPFD != 0)) { goto error; @@ -538,14 +538,14 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() fprintf(stderr, "Warning! Unable to find a pixel format with an alpha channel.\n"); } - if (!WIN32_CHK(::SetPixelFormat(m_hDC, iPixelFormat, &chosenPFD))) { + if (!WIN32_CHK(::SetPixelFormat(h_DC_, iPixelFormat, &chosenPFD))) { goto error; } } if (dummy.has_WGL_ARB_create_context) { - int profileBitCore = m_contextProfileMask & WGL_CONTEXT_CORE_PROFILE_BIT_ARB; - int profileBitCompat = m_contextProfileMask & WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; + int profileBitCore = context_profile_mask_ & WGL_CONTEXT_CORE_PROFILE_BIT_ARB; + int profileBitCompat = context_profile_mask_ & WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; if (!dummy.has_WGL_ARB_create_context_profile && profileBitCore) { fprintf(stderr, "Warning! OpenGL core profile not available.\n"); @@ -565,7 +565,7 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() profileMask |= profileBitCompat; } - if (profileMask != m_contextProfileMask) { + if (profileMask != context_profile_mask_) { fprintf(stderr, "Warning! Ignoring untested OpenGL context profile mask bits."); } @@ -576,25 +576,25 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() iAttributes.push_back(profileMask); } - if (m_contextMajorVersion != 0) { + if (context_major_version_ != 0) { iAttributes.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB); - iAttributes.push_back(m_contextMajorVersion); + iAttributes.push_back(context_major_version_); } - if (m_contextMinorVersion != 0) { + if (context_minor_version_ != 0) { iAttributes.push_back(WGL_CONTEXT_MINOR_VERSION_ARB); - iAttributes.push_back(m_contextMinorVersion); + iAttributes.push_back(context_minor_version_); } - if (m_contextFlags != 0) { + if (context_flags_ != 0) { iAttributes.push_back(WGL_CONTEXT_FLAGS_ARB); - iAttributes.push_back(m_contextFlags); + iAttributes.push_back(context_flags_); } - if (m_contextResetNotificationStrategy != 0) { + if (context_reset_notification_strategy_ != 0) { if (dummy.has_WGL_ARB_create_context_robustness) { iAttributes.push_back(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB); - iAttributes.push_back(m_contextResetNotificationStrategy); + iAttributes.push_back(context_reset_notification_strategy_); } else { fprintf(stderr, "Warning! Cannot set the reset notification strategy."); @@ -603,15 +603,15 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() iAttributes.push_back(0); - m_hGLRC = ::wglCreateContextAttribsARB(m_hDC, s_sharedHGLRC, &(iAttributes[0])); + h_GLRC_ = ::wglCreateContextAttribsARB(h_DC_, s_sharedHGLRC, &(iAttributes[0])); } } /* Silence warnings interpreted as errors by users when trying to get * a context with version higher than 3.3 Core. */ { - const bool silent = m_contextMajorVersion > 3; - if (!WIN32_CHK_SILENT(m_hGLRC != nullptr, silent)) { + const bool silent = context_major_version_ > 3; + if (!WIN32_CHK_SILENT(h_GLRC_ != nullptr, silent)) { goto error; } } @@ -626,10 +626,10 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() s_sharedCount++; if (s_sharedHGLRC == nullptr) { - s_sharedHGLRC = m_hGLRC; + s_sharedHGLRC = h_GLRC_; } - if (!WIN32_CHK(::wglMakeCurrent(m_hDC, m_hGLRC))) { + if (!WIN32_CHK(::wglMakeCurrent(h_DC_, h_GLRC_))) { goto error; } @@ -643,7 +643,7 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() } initClearGL(); - ::SwapBuffers(m_hDC); + ::SwapBuffers(h_DC_); #ifndef NDEBUG { @@ -651,11 +651,11 @@ GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() const char *renderer = reinterpret_cast(glGetString(GL_RENDERER)); const char *version = reinterpret_cast(glGetString(GL_VERSION)); - reportContextString("Vendor", m_dummyVendor, vendor); - reportContextString("Renderer", m_dummyRenderer, renderer); - reportContextString("Version", m_dummyVersion, version); + reportContextString("Vendor", dummy_vendor_, vendor); + reportContextString("Renderer", dummy_renderer_, renderer); + reportContextString("Version", dummy_version_, version); - fprintf(stderr, "Context Version: %d.%d\n", m_contextMajorVersion, m_contextMinorVersion); + fprintf(stderr, "Context Version: %d.%d\n", context_major_version_, context_minor_version_); } #endif @@ -668,11 +668,11 @@ error: GHOST_TSuccess GHOST_ContextWGL::releaseNativeHandles() { - GHOST_TSuccess success = m_hGLRC != s_sharedHGLRC || s_sharedCount == 1 ? GHOST_kSuccess : + GHOST_TSuccess success = h_GLRC_ != s_sharedHGLRC || s_sharedCount == 1 ? GHOST_kSuccess : GHOST_kFailure; - m_hWnd = nullptr; - m_hDC = nullptr; + h_wnd_ = nullptr; + h_DC_ = nullptr; return success; } diff --git a/intern/ghost/intern/GHOST_ContextWGL.hh b/intern/ghost/intern/GHOST_ContextWGL.hh index 48f15452670..a97ad414e97 100644 --- a/intern/ghost/intern/GHOST_ContextWGL.hh +++ b/intern/ghost/intern/GHOST_ContextWGL.hh @@ -79,31 +79,31 @@ class GHOST_ContextWGL : public GHOST_Context { /** * Gets the current swap interval for #swapBuffers. - * \param intervalOut: Variable to store the swap interval if it can be read. + * \param interval_out: Variable to store the swap interval if it can be read. * \return Whether the swap interval can be read. */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; private: int choose_pixel_format_arb(bool stereoVisual, bool needAlpha); int _choose_pixel_format_arb_1(bool stereoVisual, bool needAlpha); - HWND m_hWnd; - HDC m_hDC; + HWND h_wnd_; + HDC h_DC_; - const int m_contextProfileMask; - const int m_contextMajorVersion; - const int m_contextMinorVersion; - const int m_contextFlags; - const bool m_alphaBackground; - const int m_contextResetNotificationStrategy; + const int context_profile_mask_; + const int context_major_version_; + const int context_minor_version_; + const int context_flags_; + const bool alpha_background_; + const int context_reset_notification_strategy_; - HGLRC m_hGLRC; + HGLRC h_GLRC_; #ifndef NDEBUG - const char *m_dummyVendor; - const char *m_dummyRenderer; - const char *m_dummyVersion; + const char *dummy_vendor_; + const char *dummy_renderer_; + const char *dummy_version_; #endif static HGLRC s_sharedHGLRC; diff --git a/intern/ghost/intern/GHOST_DropTargetWin32.cc b/intern/ghost/intern/GHOST_DropTargetWin32.cc index b08600ceb63..1f64936b582 100644 --- a/intern/ghost/intern/GHOST_DropTargetWin32.cc +++ b/intern/ghost/intern/GHOST_DropTargetWin32.cc @@ -19,11 +19,11 @@ void printLastError(void); #endif /* WITH_GHOST_DEBUG */ GHOST_DropTargetWin32::GHOST_DropTargetWin32(GHOST_WindowWin32 *window, GHOST_SystemWin32 *system) - : m_window(window), m_system(system) + : window_(window), system_(system) { - m_cRef = 1; - m_hWnd = window->getHWND(); - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + c_ref_ = 1; + h_wnd_ = window->getHWND(); + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; } GHOST_DropTargetWin32::~GHOST_DropTargetWin32() {} @@ -54,7 +54,7 @@ HRESULT __stdcall GHOST_DropTargetWin32::QueryInterface(REFIID riid, void **ppv_ ULONG __stdcall GHOST_DropTargetWin32::AddRef(void) { - return ::InterlockedIncrement(&m_cRef); + return ::InterlockedIncrement(&c_ref_); } /* @@ -62,7 +62,7 @@ ULONG __stdcall GHOST_DropTargetWin32::AddRef(void) */ ULONG __stdcall GHOST_DropTargetWin32::Release(void) { - ULONG refs = ::InterlockedDecrement(&m_cRef); + ULONG refs = ::InterlockedDecrement(&c_ref_); if (refs == 0) { delete this; @@ -82,12 +82,12 @@ HRESULT __stdcall GHOST_DropTargetWin32::DragEnter(IDataObject *p_data_object, DWORD *pdw_effect) { /* We accept all drop by default. */ - m_window->setAcceptDragOperation(true); + window_->setAcceptDragOperation(true); *pdw_effect = DROPEFFECT_NONE; - m_draggedObjectType = getGhostType(p_data_object); - m_system->pushDragDropEvent( - GHOST_kEventDraggingEntered, m_draggedObjectType, m_window, pt.x, pt.y, nullptr); + dragged_object_type_ = getGhostType(p_data_object); + system_->pushDragDropEvent( + GHOST_kEventDraggingEntered, dragged_object_type_, window_, pt.x, pt.y, nullptr); return S_OK; } @@ -98,7 +98,7 @@ HRESULT __stdcall GHOST_DropTargetWin32::DragOver(DWORD /*grf_key_state*/, POINTL pt, DWORD *pdw_effect) { - if (m_window->canAcceptDragOperation()) { + if (window_->canAcceptDragOperation()) { *pdw_effect = allowedDropEffect(*pdw_effect); } else { @@ -106,8 +106,8 @@ HRESULT __stdcall GHOST_DropTargetWin32::DragOver(DWORD /*grf_key_state*/, /* XXX Uncomment to test drop. Drop will not be called if `pdw_effect == DROPEFFECT_NONE`. */ // *pdw_effect = DROPEFFECT_COPY; } - m_system->pushDragDropEvent( - GHOST_kEventDraggingUpdated, m_draggedObjectType, m_window, pt.x, pt.y, nullptr); + system_->pushDragDropEvent( + GHOST_kEventDraggingUpdated, dragged_object_type_, window_, pt.x, pt.y, nullptr); return S_OK; } @@ -116,9 +116,9 @@ HRESULT __stdcall GHOST_DropTargetWin32::DragOver(DWORD /*grf_key_state*/, */ HRESULT __stdcall GHOST_DropTargetWin32::DragLeave(void) { - m_system->pushDragDropEvent( - GHOST_kEventDraggingExited, m_draggedObjectType, m_window, 0, 0, nullptr); - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + system_->pushDragDropEvent( + GHOST_kEventDraggingExited, dragged_object_type_, window_, 0, 0, nullptr); + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; return S_OK; } @@ -132,17 +132,17 @@ HRESULT __stdcall GHOST_DropTargetWin32::Drop(IDataObject *p_data_object, DWORD *pdw_effect) { void *data = getGhostData(p_data_object); - if (m_window->canAcceptDragOperation()) { + if (window_->canAcceptDragOperation()) { *pdw_effect = allowedDropEffect(*pdw_effect); } else { *pdw_effect = DROPEFFECT_NONE; } if (data) { - m_system->pushDragDropEvent( - GHOST_kEventDraggingDropDone, m_draggedObjectType, m_window, pt.x, pt.y, data); + system_->pushDragDropEvent( + GHOST_kEventDraggingDropDone, dragged_object_type_, window_, pt.x, pt.y, data); } - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; return S_OK; } diff --git a/intern/ghost/intern/GHOST_DropTargetWin32.hh b/intern/ghost/intern/GHOST_DropTargetWin32.hh index f8ec4d8b34e..c4c4f2414c7 100644 --- a/intern/ghost/intern/GHOST_DropTargetWin32.hh +++ b/intern/ghost/intern/GHOST_DropTargetWin32.hh @@ -123,15 +123,15 @@ class GHOST_DropTargetWin32 : public IDropTarget { /* Private member variables */ /* COM reference count. */ - LONG m_cRef; + LONG c_ref_; /* Handle of the associated window. */ - HWND m_hWnd; + HWND h_wnd_; /* The associated GHOST_WindowWin32. */ - GHOST_WindowWin32 *m_window; + GHOST_WindowWin32 *window_; /* The System. */ - GHOST_SystemWin32 *m_system; + GHOST_SystemWin32 *system_; /* Data type of the dragged object */ - GHOST_TDragnDropTypes m_draggedObjectType; + GHOST_TDragnDropTypes dragged_object_type_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_DropTargetWin32") }; diff --git a/intern/ghost/intern/GHOST_DropTargetX11.cc b/intern/ghost/intern/GHOST_DropTargetX11.cc index 45edd553886..515f61aa6fa 100644 --- a/intern/ghost/intern/GHOST_DropTargetX11.cc +++ b/intern/ghost/intern/GHOST_DropTargetX11.cc @@ -16,41 +16,41 @@ #include #include -bool GHOST_DropTargetX11::m_xdndInitialized = false; -DndClass GHOST_DropTargetX11::m_dndClass; -Atom *GHOST_DropTargetX11::m_dndTypes = nullptr; -Atom *GHOST_DropTargetX11::m_dndActions = nullptr; -const char *GHOST_DropTargetX11::m_dndMimeTypes[] = { +bool GHOST_DropTargetX11::xdnd_initialized_ = false; +DndClass GHOST_DropTargetX11::dnd_class_; +Atom *GHOST_DropTargetX11::dnd_types_ = nullptr; +Atom *GHOST_DropTargetX11::dnd_actions_ = nullptr; +const char *GHOST_DropTargetX11::dnd_mime_types_[] = { "url/url", "text/uri-list", "text/plain", "application/octet-stream"}; -int GHOST_DropTargetX11::m_refCounter = 0; +int GHOST_DropTargetX11::ref_counter_ = 0; #define dndTypeURLID 0 #define dndTypeURIListID 1 #define dndTypePlainTextID 2 #define dndTypeOctetStreamID 3 -#define dndTypeURL m_dndTypes[dndTypeURLID] -#define dndTypeURIList m_dndTypes[dndTypeURIListID] -#define dndTypePlainText m_dndTypes[dndTypePlainTextID] -#define dndTypeOctetStream m_dndTypes[dndTypeOctetStreamID] +#define dndTypeURL dnd_types_[dndTypeURLID] +#define dndTypeURIList dnd_types_[dndTypeURIListID] +#define dndTypePlainText dnd_types_[dndTypePlainTextID] +#define dndTypeOctetStream dnd_types_[dndTypeOctetStreamID] void GHOST_DropTargetX11::Initialize() { - Display *display = m_system->getXDisplay(); - int dndTypesCount = ARRAY_SIZE(m_dndMimeTypes); + Display *display = system_->getXDisplay(); + int dndTypesCount = ARRAY_SIZE(dnd_mime_types_); int counter; - xdnd_init(&m_dndClass, display); + xdnd_init(&dnd_class_, display); - m_dndTypes = new Atom[dndTypesCount + 1]; - XInternAtoms(display, (char **)m_dndMimeTypes, dndTypesCount, 0, m_dndTypes); - m_dndTypes[dndTypesCount] = 0; + dnd_types_ = new Atom[dndTypesCount + 1]; + XInternAtoms(display, (char **)dnd_mime_types_, dndTypesCount, 0, dnd_types_); + dnd_types_[dndTypesCount] = 0; - m_dndActions = new Atom[8]; + dnd_actions_ = new Atom[8]; counter = 0; - m_dndActions[counter++] = m_dndClass.XdndActionCopy; - m_dndActions[counter++] = m_dndClass.XdndActionMove; + dnd_actions_[counter++] = dnd_class_.XdndActionCopy; + dnd_actions_[counter++] = dnd_class_.XdndActionMove; #if 0 /* Not supported yet */ dndActions[counter++] = dnd->XdndActionLink; @@ -60,41 +60,41 @@ void GHOST_DropTargetX11::Initialize() dndActions[counter++] = dnd->XdndActionDescription; #endif - m_dndActions[counter++] = 0; + dnd_actions_[counter++] = 0; } void GHOST_DropTargetX11::Uninitialize() { - xdnd_shut(&m_dndClass); + xdnd_shut(&dnd_class_); - delete[] m_dndActions; - delete[] m_dndTypes; + delete[] dnd_actions_; + delete[] dnd_types_; } GHOST_DropTargetX11::GHOST_DropTargetX11(GHOST_WindowX11 *window, GHOST_SystemX11 *system) - : m_window(window), m_system(system) + : window_(window), system_(system) { - if (!m_xdndInitialized) { + if (!xdnd_initialized_) { Initialize(); - m_xdndInitialized = true; + xdnd_initialized_ = true; GHOST_PRINT("XDND initialized\n"); } Window wnd = window->getXWindow(); - xdnd_set_dnd_aware(&m_dndClass, wnd, nullptr); - xdnd_set_type_list(&m_dndClass, wnd, m_dndTypes); + xdnd_set_dnd_aware(&dnd_class_, wnd, nullptr); + xdnd_set_type_list(&dnd_class_, wnd, dnd_types_); - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; - m_refCounter++; + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; + ref_counter_++; } GHOST_DropTargetX11::~GHOST_DropTargetX11() { - m_refCounter--; - if (m_refCounter == 0) { + ref_counter_--; + if (ref_counter_ == 0) { Uninitialize(); - m_xdndInitialized = false; + xdnd_initialized_ = false; GHOST_PRINT("XDND uninitialized\n"); } } @@ -170,7 +170,7 @@ void *GHOST_DropTargetX11::getGhostData(Atom dropType, const uchar *dropBuffer, tmpBuffer[dropBufferSize] = 0; if (dropType == dndTypeURIList) { - m_draggedObjectType = GHOST_kDragnDropTypeFilenames; + dragged_object_type_ = GHOST_kDragnDropTypeFilenames; data = getURIListGhostData(tmpBuffer, dropBufferSize); } else if (dropType == dndTypeURL) { @@ -178,17 +178,17 @@ void *GHOST_DropTargetX11::getGhostData(Atom dropType, const uchar *dropBuffer, char *decodedPath = FileUrlDecode((const char *)tmpBuffer); if (decodedPath) { - m_draggedObjectType = GHOST_kDragnDropTypeString; + dragged_object_type_ = GHOST_kDragnDropTypeString; data = decodedPath; } } else if (ELEM(dropType, dndTypePlainText, dndTypeOctetStream)) { - m_draggedObjectType = GHOST_kDragnDropTypeString; + dragged_object_type_ = GHOST_kDragnDropTypeString; data = tmpBuffer; needsFree = false; } else { - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; } if (needsFree) { @@ -204,10 +204,10 @@ bool GHOST_DropTargetX11::GHOST_HandleClientMessage(XEvent *event) uchar *dropBuffer; int dropBufferSize, dropX, dropY; - if (xdnd_get_drop(m_system->getXDisplay(), + if (xdnd_get_drop(system_->getXDisplay(), event, - m_dndTypes, - m_dndActions, + dnd_types_, + dnd_actions_, &dropBuffer, &dropBufferSize, &dropType, @@ -217,13 +217,13 @@ bool GHOST_DropTargetX11::GHOST_HandleClientMessage(XEvent *event) void *data = getGhostData(dropType, dropBuffer, dropBufferSize); if (data) { - m_system->pushDragDropEvent( - GHOST_kEventDraggingDropDone, m_draggedObjectType, m_window, dropX, dropY, data); + system_->pushDragDropEvent( + GHOST_kEventDraggingDropDone, dragged_object_type_, window_, dropX, dropY, data); } free(dropBuffer); - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; return true; } diff --git a/intern/ghost/intern/GHOST_DropTargetX11.hh b/intern/ghost/intern/GHOST_DropTargetX11.hh index 8953f47e3aa..5ae64c2310f 100644 --- a/intern/ghost/intern/GHOST_DropTargetX11.hh +++ b/intern/ghost/intern/GHOST_DropTargetX11.hh @@ -73,30 +73,30 @@ class GHOST_DropTargetX11 { char *FileUrlDecode(const char *fileUrl); /* The associated GHOST_WindowWin32. */ - GHOST_WindowX11 *m_window; + GHOST_WindowX11 *window_; /* The System. */ - GHOST_SystemX11 *m_system; + GHOST_SystemX11 *system_; /* Data type of the dragged object */ - GHOST_TDragnDropTypes m_draggedObjectType; + GHOST_TDragnDropTypes dragged_object_type_; /* Is drag-and-drop stuff initialized. */ - static bool m_xdndInitialized; + static bool xdnd_initialized_; /* Class holding internal stiff of `xdnd` library. */ - static DndClass m_dndClass; + static DndClass dnd_class_; /* List of supported types to be dragged into. */ - static Atom *m_dndTypes; + static Atom *dnd_types_; /* List of supported drag-and-drop actions. */ - static Atom *m_dndActions; + static Atom *dnd_actions_; /* List of supported MIME types to be dragged into. */ - static const char *m_dndMimeTypes[]; + static const char *dnd_mime_types_[]; /* Counter of references to global #XDND structures. */ - static int m_refCounter; + static int ref_counter_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_DropTargetX11") }; diff --git a/intern/ghost/intern/GHOST_Event.hh b/intern/ghost/intern/GHOST_Event.hh index 1a09f7ef407..9094b3e9006 100644 --- a/intern/ghost/intern/GHOST_Event.hh +++ b/intern/ghost/intern/GHOST_Event.hh @@ -23,41 +23,41 @@ class GHOST_Event : public GHOST_IEvent { * \param window: The generating window (or nullptr if system event). */ GHOST_Event(uint64_t msec, GHOST_TEventType type, GHOST_IWindow *window) - : m_type(type), m_time(msec), m_window(window) + : type_(type), time_(msec), window_(window) { } /** \copydoc #GHOST_IEvent::getType */ GHOST_TEventType getType() const override { - return m_type; + return type_; } /** \copydoc #GHOST_IEvent::getTime */ uint64_t getTime() const override { - return m_time; + return time_; } /** \copydoc #GHOST_IEvent::getWindow */ GHOST_IWindow *getWindow() const override { - return m_window; + return window_; } /** \copydoc #GHOST_IEvent::getData */ GHOST_TEventDataPtr getData() const override { - return m_data; + return data_; } protected: /** Type of this event. */ - GHOST_TEventType m_type; + GHOST_TEventType type_; /** The time this event was generated. */ - uint64_t m_time; + uint64_t time_; /** Pointer to the generating window. */ - GHOST_IWindow *m_window; + GHOST_IWindow *window_; /** Pointer to the event data. */ - GHOST_TEventDataPtr m_data = nullptr; + GHOST_TEventDataPtr data_ = nullptr; }; diff --git a/intern/ghost/intern/GHOST_EventButton.hh b/intern/ghost/intern/GHOST_EventButton.hh index 300f27a72da..c38680cb360 100644 --- a/intern/ghost/intern/GHOST_EventButton.hh +++ b/intern/ghost/intern/GHOST_EventButton.hh @@ -30,12 +30,12 @@ class GHOST_EventButton : public GHOST_Event { GHOST_IWindow *window, GHOST_TButton button, const GHOST_TabletData &tablet) - : GHOST_Event(time, type, window), m_buttonEventData({button, tablet}) + : GHOST_Event(time, type, window), button_event_data_({button, tablet}) { - m_data = &m_buttonEventData; + data_ = &button_event_data_; } protected: /** The button event data. */ - GHOST_TEventButtonData m_buttonEventData; + GHOST_TEventButtonData button_event_data_; }; diff --git a/intern/ghost/intern/GHOST_EventCursor.hh b/intern/ghost/intern/GHOST_EventCursor.hh index 0fa07225b85..4fc3071ce0f 100644 --- a/intern/ghost/intern/GHOST_EventCursor.hh +++ b/intern/ghost/intern/GHOST_EventCursor.hh @@ -30,12 +30,12 @@ class GHOST_EventCursor : public GHOST_Event { int32_t x, int32_t y, const GHOST_TabletData &tablet) - : GHOST_Event(msec, type, window), m_cursorEventData({x, y, tablet}) + : GHOST_Event(msec, type, window), cursor_event_data_({x, y, tablet}) { - m_data = &m_cursorEventData; + data_ = &cursor_event_data_; } protected: /** The x,y-coordinates of the cursor position. */ - GHOST_TEventCursorData m_cursorEventData; + GHOST_TEventCursorData cursor_event_data_; }; diff --git a/intern/ghost/intern/GHOST_EventDragnDrop.hh b/intern/ghost/intern/GHOST_EventDragnDrop.hh index 12246d6aa9b..0f3c67de87b 100644 --- a/intern/ghost/intern/GHOST_EventDragnDrop.hh +++ b/intern/ghost/intern/GHOST_EventDragnDrop.hh @@ -64,26 +64,26 @@ class GHOST_EventDragnDrop : public GHOST_Event { GHOST_TDragnDropDataPtr data) : GHOST_Event(time, type, window) { - m_dragnDropEventData.x = x; - m_dragnDropEventData.y = y; - m_dragnDropEventData.dataType = dataType; - m_dragnDropEventData.data = data; - m_data = &m_dragnDropEventData; + dragn_drop_event_data_.x = x; + dragn_drop_event_data_.y = y; + dragn_drop_event_data_.dataType = dataType; + dragn_drop_event_data_.data = data; + data_ = &dragn_drop_event_data_; } ~GHOST_EventDragnDrop() override { /* Free the dropped object data. */ - if (m_dragnDropEventData.data == nullptr) { + if (dragn_drop_event_data_.data == nullptr) { return; } - switch (m_dragnDropEventData.dataType) { + switch (dragn_drop_event_data_.dataType) { case GHOST_kDragnDropTypeBitmap: - IMB_freeImBuf((ImBuf *)m_dragnDropEventData.data); + IMB_freeImBuf((ImBuf *)dragn_drop_event_data_.data); break; case GHOST_kDragnDropTypeFilenames: { - GHOST_TStringArray *strArray = (GHOST_TStringArray *)m_dragnDropEventData.data; + GHOST_TStringArray *strArray = (GHOST_TStringArray *)dragn_drop_event_data_.data; int i; for (i = 0; i < strArray->count; i++) { @@ -95,7 +95,7 @@ class GHOST_EventDragnDrop : public GHOST_Event { break; } case GHOST_kDragnDropTypeString: - free(m_dragnDropEventData.data); + free(dragn_drop_event_data_.data); break; default: @@ -105,5 +105,5 @@ class GHOST_EventDragnDrop : public GHOST_Event { protected: /** The x,y-coordinates of the cursor position. */ - GHOST_TEventDragnDropData m_dragnDropEventData; + GHOST_TEventDragnDropData dragn_drop_event_data_; }; diff --git a/intern/ghost/intern/GHOST_EventKey.hh b/intern/ghost/intern/GHOST_EventKey.hh index b7f033803e7..da334b8634c 100644 --- a/intern/ghost/intern/GHOST_EventKey.hh +++ b/intern/ghost/intern/GHOST_EventKey.hh @@ -29,10 +29,10 @@ class GHOST_EventKey : public GHOST_Event { uint64_t msec, GHOST_TEventType type, GHOST_IWindow *window, GHOST_TKey key, bool is_repeat) : GHOST_Event(msec, type, window) { - m_keyEventData.key = key; - m_keyEventData.utf8_buf[0] = '\0'; - m_keyEventData.is_repeat = is_repeat; - m_data = &m_keyEventData; + key_event_data_.key = key; + key_event_data_.utf8_buf[0] = '\0'; + key_event_data_.is_repeat = is_repeat; + data_ = &key_event_data_; } /** @@ -51,18 +51,18 @@ class GHOST_EventKey : public GHOST_Event { const char utf8_buf[6]) : GHOST_Event(msec, type, window) { - m_keyEventData.key = key; + key_event_data_.key = key; if (utf8_buf) { - memcpy(m_keyEventData.utf8_buf, utf8_buf, sizeof(m_keyEventData.utf8_buf)); + memcpy(key_event_data_.utf8_buf, utf8_buf, sizeof(key_event_data_.utf8_buf)); } else { - m_keyEventData.utf8_buf[0] = '\0'; + key_event_data_.utf8_buf[0] = '\0'; } - m_keyEventData.is_repeat = is_repeat; - m_data = &m_keyEventData; + key_event_data_.is_repeat = is_repeat; + data_ = &key_event_data_; } protected: /** The key event data. */ - GHOST_TEventKeyData m_keyEventData; + GHOST_TEventKeyData key_event_data_; }; diff --git a/intern/ghost/intern/GHOST_EventManager.cc b/intern/ghost/intern/GHOST_EventManager.cc index 9fba696bc19..5b7f3eb0e6f 100644 --- a/intern/ghost/intern/GHOST_EventManager.cc +++ b/intern/ghost/intern/GHOST_EventManager.cc @@ -20,24 +20,24 @@ GHOST_EventManager::~GHOST_EventManager() { disposeEvents(); - TConsumerVector::iterator iter = m_consumers.begin(); - while (iter != m_consumers.end()) { + TConsumerVector::iterator iter = consumers_.begin(); + while (iter != consumers_.end()) { GHOST_IEventConsumer *consumer = *iter; delete consumer; - iter = m_consumers.erase(iter); + iter = consumers_.erase(iter); } } uint32_t GHOST_EventManager::getNumEvents() { - return uint32_t(m_events.size()); + return uint32_t(events_.size()); } uint32_t GHOST_EventManager::getNumEvents(GHOST_TEventType type) { uint32_t numEvents = 0; TEventStack::iterator p; - for (p = m_events.begin(); p != m_events.end(); ++p) { + for (p = events_.begin(); p != events_.end(); ++p) { if ((*p)->getType() == type) { numEvents++; } @@ -49,8 +49,8 @@ GHOST_TSuccess GHOST_EventManager::pushEvent(const GHOST_IEvent *event) { GHOST_TSuccess success; GHOST_ASSERT(event, "invalid event"); - if (m_events.size() < m_events.max_size()) { - m_events.push_front(event); + if (events_.size() < events_.max_size()) { + events_.push_front(event); success = GHOST_kSuccess; } else { @@ -63,23 +63,23 @@ void GHOST_EventManager::dispatchEvent(const GHOST_IEvent *event) { TConsumerVector::iterator iter; - for (iter = m_consumers.begin(); iter != m_consumers.end(); ++iter) { + for (iter = consumers_.begin(); iter != consumers_.end(); ++iter) { (*iter)->processEvent(event); } } void GHOST_EventManager::dispatchEvent() { - const GHOST_IEvent *event = m_events.back(); - m_events.pop_back(); - m_handled_events.push_back(event); + const GHOST_IEvent *event = events_.back(); + events_.pop_back(); + handled_events_.push_back(event); dispatchEvent(event); } void GHOST_EventManager::dispatchEvents() { - while (!m_events.empty()) { + while (!events_.empty()) { dispatchEvent(); } @@ -92,12 +92,11 @@ GHOST_TSuccess GHOST_EventManager::addConsumer(GHOST_IEventConsumer *consumer) GHOST_ASSERT(consumer, "invalid consumer"); /* Check to see whether the consumer is already in our list. */ - TConsumerVector::const_iterator iter = std::find( - m_consumers.begin(), m_consumers.end(), consumer); + TConsumerVector::const_iterator iter = std::find(consumers_.begin(), consumers_.end(), consumer); - if (iter == m_consumers.end()) { + if (iter == consumers_.end()) { /* Add the consumer. */ - m_consumers.push_back(consumer); + consumers_.push_back(consumer); success = GHOST_kSuccess; } else { @@ -112,11 +111,11 @@ GHOST_TSuccess GHOST_EventManager::removeConsumer(GHOST_IEventConsumer *consumer GHOST_ASSERT(consumer, "invalid consumer"); /* Check to see whether the consumer is in our list. */ - TConsumerVector::iterator iter = std::find(m_consumers.begin(), m_consumers.end(), consumer); + TConsumerVector::iterator iter = std::find(consumers_.begin(), consumers_.end(), consumer); - if (iter != m_consumers.end()) { + if (iter != consumers_.end()) { /* Remove the consumer. */ - m_consumers.erase(iter); + consumers_.erase(iter); success = GHOST_kSuccess; } else { @@ -128,8 +127,8 @@ GHOST_TSuccess GHOST_EventManager::removeConsumer(GHOST_IEventConsumer *consumer void GHOST_EventManager::removeWindowEvents(const GHOST_IWindow *window) { TEventStack::iterator iter; - iter = m_events.begin(); - while (iter != m_events.end()) { + iter = events_.begin(); + while (iter != events_.end()) { const GHOST_IEvent *event = *iter; if (event->getWindow() == window) { GHOST_PRINT("GHOST_EventManager::removeWindowEvents(): removing event\n"); @@ -138,8 +137,8 @@ void GHOST_EventManager::removeWindowEvents(const GHOST_IWindow *window) * The iterator will become invalid. */ delete event; - m_events.erase(iter); - iter = m_events.begin(); + events_.erase(iter); + iter = events_.begin(); } else { ++iter; @@ -150,8 +149,8 @@ void GHOST_EventManager::removeWindowEvents(const GHOST_IWindow *window) void GHOST_EventManager::removeTypeEvents(GHOST_TEventType type, const GHOST_IWindow *window) { TEventStack::iterator iter; - iter = m_events.begin(); - while (iter != m_events.end()) { + iter = events_.begin(); + while (iter != events_.end()) { const GHOST_IEvent *event = *iter; if ((event->getType() == type) && (!window || (event->getWindow() == window))) { GHOST_PRINT("GHOST_EventManager::removeTypeEvents(): removing event\n"); @@ -160,8 +159,8 @@ void GHOST_EventManager::removeTypeEvents(GHOST_TEventType type, const GHOST_IWi * The iterator will become invalid. */ delete event; - m_events.erase(iter); - iter = m_events.begin(); + events_.erase(iter); + iter = events_.begin(); } else { ++iter; @@ -171,15 +170,15 @@ void GHOST_EventManager::removeTypeEvents(GHOST_TEventType type, const GHOST_IWi void GHOST_EventManager::disposeEvents() { - while (m_handled_events.empty() == false) { - GHOST_ASSERT(m_handled_events[0], "invalid event"); - delete m_handled_events[0]; - m_handled_events.pop_front(); + while (handled_events_.empty() == false) { + GHOST_ASSERT(handled_events_[0], "invalid event"); + delete handled_events_[0]; + handled_events_.pop_front(); } - while (m_events.empty() == false) { - GHOST_ASSERT(m_events[0], "invalid event"); - delete m_events[0]; - m_events.pop_front(); + while (events_.empty() == false) { + GHOST_ASSERT(events_[0], "invalid event"); + delete events_[0]; + events_.pop_front(); } } diff --git a/intern/ghost/intern/GHOST_EventManager.hh b/intern/ghost/intern/GHOST_EventManager.hh index 95647ce7297..ea5e6642674 100644 --- a/intern/ghost/intern/GHOST_EventManager.hh +++ b/intern/ghost/intern/GHOST_EventManager.hh @@ -111,14 +111,14 @@ class GHOST_EventManager { using TEventStack = std::deque; /** The event stack. */ - std::deque m_events; - std::deque m_handled_events; + std::deque events_; + std::deque handled_events_; /** A vector with event consumers. */ using TConsumerVector = std::vector; /** The list with event consumers. */ - TConsumerVector m_consumers; + TConsumerVector consumers_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_EventManager") }; diff --git a/intern/ghost/intern/GHOST_EventNDOF.hh b/intern/ghost/intern/GHOST_EventNDOF.hh index a0938c761e0..1fb78f886a5 100644 --- a/intern/ghost/intern/GHOST_EventNDOF.hh +++ b/intern/ghost/intern/GHOST_EventNDOF.hh @@ -16,24 +16,24 @@ class GHOST_EventNDOFMotion : public GHOST_Event { protected: - GHOST_TEventNDOFMotionData m_axisData; + GHOST_TEventNDOFMotionData axis_data_; public: GHOST_EventNDOFMotion(uint64_t time, GHOST_IWindow *window) : GHOST_Event(time, GHOST_kEventNDOFMotion, window) { - m_data = &m_axisData; + data_ = &axis_data_; } }; class GHOST_EventNDOFButton : public GHOST_Event { protected: - GHOST_TEventNDOFButtonData m_buttonData; + GHOST_TEventNDOFButtonData button_data_; public: GHOST_EventNDOFButton(uint64_t time, GHOST_IWindow *window) : GHOST_Event(time, GHOST_kEventNDOFButton, window) { - m_data = &m_buttonData; + data_ = &button_data_; } }; diff --git a/intern/ghost/intern/GHOST_EventString.hh b/intern/ghost/intern/GHOST_EventString.hh index 1fb591a338c..bb218d1d8f9 100644 --- a/intern/ghost/intern/GHOST_EventString.hh +++ b/intern/ghost/intern/GHOST_EventString.hh @@ -29,13 +29,13 @@ class GHOST_EventString : public GHOST_Event { GHOST_TEventDataPtr data_ptr) : GHOST_Event(msec, type, window) { - m_data = data_ptr; + data_ = data_ptr; } ~GHOST_EventString() override { - if (m_data) { - free((void *)m_data); + if (data_) { + free((void *)data_); } } }; diff --git a/intern/ghost/intern/GHOST_EventTrackpad.hh b/intern/ghost/intern/GHOST_EventTrackpad.hh index 0a2ba424211..497d960e7cc 100644 --- a/intern/ghost/intern/GHOST_EventTrackpad.hh +++ b/intern/ghost/intern/GHOST_EventTrackpad.hh @@ -34,16 +34,16 @@ class GHOST_EventTrackpad : public GHOST_Event { bool isDirectionInverted) : GHOST_Event(msec, GHOST_kEventTrackpad, window) { - m_trackpadEventData.subtype = subtype; - m_trackpadEventData.x = x; - m_trackpadEventData.y = y; - m_trackpadEventData.deltaX = deltaX; - m_trackpadEventData.deltaY = deltaY; - m_trackpadEventData.isDirectionInverted = isDirectionInverted; - m_data = &m_trackpadEventData; + trackpad_event_data_.subtype = subtype; + trackpad_event_data_.x = x; + trackpad_event_data_.y = y; + trackpad_event_data_.deltaX = deltaX; + trackpad_event_data_.deltaY = deltaY; + trackpad_event_data_.isDirectionInverted = isDirectionInverted; + data_ = &trackpad_event_data_; } protected: /** The mouse pan data */ - GHOST_TEventTrackpadData m_trackpadEventData; + GHOST_TEventTrackpadData trackpad_event_data_; }; diff --git a/intern/ghost/intern/GHOST_EventWheel.hh b/intern/ghost/intern/GHOST_EventWheel.hh index c0a2f802535..c50735ca0e5 100644 --- a/intern/ghost/intern/GHOST_EventWheel.hh +++ b/intern/ghost/intern/GHOST_EventWheel.hh @@ -28,11 +28,11 @@ class GHOST_EventWheel : public GHOST_Event { GHOST_EventWheel(uint64_t msec, GHOST_IWindow *window, GHOST_TEventWheelAxis axis, int32_t value) : GHOST_Event(msec, GHOST_kEventWheel, window) { - m_wheelEventData.axis = axis; - m_wheelEventData.value = value; - m_data = &m_wheelEventData; + wheel_event_data_.axis = axis; + wheel_event_data_.value = value; + data_ = &wheel_event_data_; } protected: - GHOST_TEventWheelData m_wheelEventData; + GHOST_TEventWheelData wheel_event_data_; }; diff --git a/intern/ghost/intern/GHOST_ISystem.cc b/intern/ghost/intern/GHOST_ISystem.cc index dfb78057243..83bb833fbdc 100644 --- a/intern/ghost/intern/GHOST_ISystem.cc +++ b/intern/ghost/intern/GHOST_ISystem.cc @@ -34,10 +34,10 @@ static CLG_LogRef LOG = {"ghost.system"}; -GHOST_ISystem *GHOST_ISystem::m_system = nullptr; -const char *GHOST_ISystem::m_system_backend_id = nullptr; +GHOST_ISystem *GHOST_ISystem::system_ = nullptr; +const char *GHOST_ISystem::system_backend_id_ = nullptr; -GHOST_TBacktraceFn GHOST_ISystem::m_backtrace_fn = nullptr; +GHOST_TBacktraceFn GHOST_ISystem::backtrace_fn_ = nullptr; GHOST_TSuccess GHOST_ISystem::createSystem(bool verbose, [[maybe_unused]] bool background) { @@ -52,7 +52,7 @@ GHOST_TSuccess GHOST_ISystem::createSystem(bool verbose, [[maybe_unused]] bool b std::vector backends_attempted; GHOST_TSuccess success; - if (!m_system) { + if (!system_) { #if defined(WITH_HEADLESS) /* Pass. */ @@ -72,98 +72,98 @@ GHOST_TSuccess GHOST_ISystem::createSystem(bool verbose, [[maybe_unused]] bool b backends_attempted.push_back({"WAYLAND"}); try { CLOG_INFO(&LOG, "Create Wayland system"); - m_system = new GHOST_SystemWayland(background); + system_ = new GHOST_SystemWayland(background); } catch (const std::runtime_error &e) { if (verbose) { backends_attempted.back().failure_msg = e.what(); } CLOG_INFO(&LOG, "Wayland system not created, falling back to X11"); - delete m_system; - m_system = nullptr; + delete system_; + system_ = nullptr; # ifdef WITH_GHOST_WAYLAND_DYNLOAD ghost_wl_dynload_libraries_exit(); # endif } } else { - m_system = nullptr; + system_ = nullptr; } - if (!m_system) { + if (!system_) { /* Try to fall back to X11. */ backends_attempted.push_back({"X11"}); try { CLOG_INFO(&LOG, "Create X11 system"); - m_system = new GHOST_SystemX11(); + system_ = new GHOST_SystemX11(); } catch (const std::runtime_error &e) { if (verbose) { backends_attempted.back().failure_msg = e.what(); } - delete m_system; - m_system = nullptr; + delete system_; + system_ = nullptr; } } #elif defined(WITH_GHOST_X11) backends_attempted.push_back({"X11"}); try { CLOG_INFO(&LOG, "Create X11 system"); - m_system = new GHOST_SystemX11(); + system_ = new GHOST_SystemX11(); } catch (const std::runtime_error &e) { if (verbose) { backends_attempted.back().failure_msg = e.what(); } - delete m_system; - m_system = nullptr; + delete system_; + system_ = nullptr; } #elif defined(WITH_GHOST_WAYLAND) if (has_wayland_libraries) { backends_attempted.push_back({"WAYLAND"}); try { CLOG_INFO(&LOG, "Create Wayland system"); - m_system = new GHOST_SystemWayland(background); + system_ = new GHOST_SystemWayland(background); } catch (const std::runtime_error &e) { if (verbose) { backends_attempted.back().failure_msg = e.what(); } - delete m_system; - m_system = nullptr; + delete system_; + system_ = nullptr; # ifdef WITH_GHOST_WAYLAND_DYNLOAD ghost_wl_dynload_libraries_exit(); # endif } } else { - m_system = nullptr; + system_ = nullptr; } #elif defined(WITH_GHOST_SDL) backends_attempted.push_back({"SDL"}); try { CLOG_INFO(&LOG, "Create SDL system"); - m_system = new GHOST_SystemSDL(); + system_ = new GHOST_SystemSDL(); } catch (const std::runtime_error &e) { if (verbose) { backends_attempted.back().failure_msg = e.what(); } - delete m_system; - m_system = nullptr; + delete system_; + system_ = nullptr; } #elif defined(WIN32) backends_attempted.push_back({"WIN32"}); CLOG_INFO(&LOG, "Create Windows system"); - m_system = new GHOST_SystemWin32(); + system_ = new GHOST_SystemWin32(); #elif defined(__APPLE__) backends_attempted.push_back({"COCOA"}); CLOG_INFO(&LOG, "Create Cocoa system"); - m_system = new GHOST_SystemCocoa(); + system_ = new GHOST_SystemCocoa(); #endif - if (m_system) { - m_system_backend_id = backends_attempted.back().id; + if (system_) { + system_backend_id_ = backends_attempted.back().id; } else if (verbose || CLOG_CHECK(&LOG, CLG_LEVEL_INFO)) { bool show_messages = false; @@ -191,13 +191,13 @@ GHOST_TSuccess GHOST_ISystem::createSystem(bool verbose, [[maybe_unused]] bool b } CLOG_STR_INFO_NOCHECK(&LOG, msg.c_str()); } - success = m_system != nullptr ? GHOST_kSuccess : GHOST_kFailure; + success = system_ != nullptr ? GHOST_kSuccess : GHOST_kFailure; } else { success = GHOST_kFailure; } if (success) { - success = m_system->init(); + success = system_->init(); } return success; } @@ -205,7 +205,7 @@ GHOST_TSuccess GHOST_ISystem::createSystem(bool verbose, [[maybe_unused]] bool b GHOST_TSuccess GHOST_ISystem::createSystemBackground() { GHOST_TSuccess success; - if (!m_system) { + if (!system_) { #if !defined(WITH_HEADLESS) /* Try to create a off-screen render surface with the graphical systems. */ CLOG_INFO(&LOG, "Create background system"); @@ -216,14 +216,14 @@ GHOST_TSuccess GHOST_ISystem::createSystemBackground() /* Try to fall back to headless mode if all else fails. */ #endif CLOG_INFO(&LOG, "Create headless system"); - m_system = new GHOST_SystemHeadless(); - success = m_system != nullptr ? GHOST_kSuccess : GHOST_kFailure; + system_ = new GHOST_SystemHeadless(); + success = system_ != nullptr ? GHOST_kSuccess : GHOST_kFailure; } else { success = GHOST_kFailure; } if (success) { - success = m_system->init(); + success = system_->init(); } return success; } @@ -232,9 +232,9 @@ GHOST_TSuccess GHOST_ISystem::disposeSystem() { CLOG_DEBUG(&LOG, "Dispose system"); GHOST_TSuccess success = GHOST_kSuccess; - if (m_system) { - delete m_system; - m_system = nullptr; + if (system_) { + delete system_; + system_ = nullptr; } else { success = GHOST_kFailure; @@ -244,20 +244,20 @@ GHOST_TSuccess GHOST_ISystem::disposeSystem() GHOST_ISystem *GHOST_ISystem::getSystem() { - return m_system; + return system_; } const char *GHOST_ISystem::getSystemBackend() { - return m_system_backend_id; + return system_backend_id_; } GHOST_TBacktraceFn GHOST_ISystem::getBacktraceFn() { - return GHOST_ISystem::m_backtrace_fn; + return GHOST_ISystem::backtrace_fn_; } void GHOST_ISystem::setBacktraceFn(GHOST_TBacktraceFn backtrace_fn) { - GHOST_ISystem::m_backtrace_fn = backtrace_fn; + GHOST_ISystem::backtrace_fn_ = backtrace_fn; } diff --git a/intern/ghost/intern/GHOST_ISystemPaths.cc b/intern/ghost/intern/GHOST_ISystemPaths.cc index e0663014f63..9e2d4063529 100644 --- a/intern/ghost/intern/GHOST_ISystemPaths.cc +++ b/intern/ghost/intern/GHOST_ISystemPaths.cc @@ -22,22 +22,22 @@ # endif #endif -GHOST_ISystemPaths *GHOST_ISystemPaths::m_systemPaths = nullptr; +GHOST_ISystemPaths *GHOST_ISystemPaths::system_paths_ = nullptr; GHOST_TSuccess GHOST_ISystemPaths::create() { GHOST_TSuccess success; - if (!m_systemPaths) { + if (!system_paths_) { #ifdef WIN32 - m_systemPaths = new GHOST_SystemPathsWin32(); + system_paths_ = new GHOST_SystemPathsWin32(); #else # ifdef __APPLE__ - m_systemPaths = new GHOST_SystemPathsCocoa(); + system_paths_ = new GHOST_SystemPathsCocoa(); # else - m_systemPaths = new GHOST_SystemPathsUnix(); + system_paths_ = new GHOST_SystemPathsUnix(); # endif #endif - success = m_systemPaths != nullptr ? GHOST_kSuccess : GHOST_kFailure; + success = system_paths_ != nullptr ? GHOST_kSuccess : GHOST_kFailure; } else { success = GHOST_kFailure; @@ -48,9 +48,9 @@ GHOST_TSuccess GHOST_ISystemPaths::create() GHOST_TSuccess GHOST_ISystemPaths::dispose() { GHOST_TSuccess success = GHOST_kSuccess; - if (m_systemPaths) { - delete m_systemPaths; - m_systemPaths = nullptr; + if (system_paths_) { + delete system_paths_; + system_paths_ = nullptr; } else { success = GHOST_kFailure; @@ -60,8 +60,8 @@ GHOST_TSuccess GHOST_ISystemPaths::dispose() GHOST_ISystemPaths *GHOST_ISystemPaths::get() { - if (!m_systemPaths) { + if (!system_paths_) { create(); } - return m_systemPaths; + return system_paths_; } diff --git a/intern/ghost/intern/GHOST_ImeWin32.cc b/intern/ghost/intern/GHOST_ImeWin32.cc index bcf30ac6174..96877135397 100644 --- a/intern/ghost/intern/GHOST_ImeWin32.cc +++ b/intern/ghost/intern/GHOST_ImeWin32.cc @@ -150,8 +150,8 @@ void GHOST_ImeWin32::DestroyImeWindow(HWND /*window_handle*/) void GHOST_ImeWin32::MoveImeWindow(HWND /*window_handle*/, HIMC imm_context) { - int x = caret_rect_.m_l; - int y = caret_rect_.m_t; + int x = caret_rect_.l_; + int y = caret_rect_.t_; const int kCaretMargin = 1; /** * As written in a comment in GHOST_ImeWin32::CreateImeWindow(), @@ -193,7 +193,7 @@ void GHOST_ImeWin32::MoveImeWindow(HWND /*window_handle*/, HIMC imm_context) void GHOST_ImeWin32::UpdateImeWindow(HWND window_handle) { /* Just move the IME window attached to the given window. */ - if (caret_rect_.m_l >= 0 && caret_rect_.m_t >= 0) { + if (caret_rect_.l_ >= 0 && caret_rect_.t_ >= 0) { HIMC imm_context = ::ImmGetContext(window_handle); if (imm_context) { MoveImeWindow(window_handle, imm_context); @@ -460,7 +460,7 @@ void GHOST_ImeWin32::BeginIME(HWND window_handle, const GHOST_Rect &caret_rect, * This update is used for moving an IME window when a renderer process * resize/moves the input caret. */ - if (caret_rect.m_l >= 0 && caret_rect.m_t >= 0) { + if (caret_rect.l_ >= 0 && caret_rect.t_ >= 0) { caret_rect_ = caret_rect; MoveImeWindow(window_handle, imm_context); } diff --git a/intern/ghost/intern/GHOST_ImeWin32.hh b/intern/ghost/intern/GHOST_ImeWin32.hh index e63f3de7a96..5f65aedc88b 100644 --- a/intern/ghost/intern/GHOST_ImeWin32.hh +++ b/intern/ghost/intern/GHOST_ImeWin32.hh @@ -36,7 +36,7 @@ class GHOST_EventIME : public GHOST_Event { const void *customdata) : GHOST_Event(msec, type, window) { - this->m_data = customdata; + this->data_ = customdata; } }; diff --git a/intern/ghost/intern/GHOST_ModifierKeys.cc b/intern/ghost/intern/GHOST_ModifierKeys.cc index c8c9e930bfc..492a5144ac7 100644 --- a/intern/ghost/intern/GHOST_ModifierKeys.cc +++ b/intern/ghost/intern/GHOST_ModifierKeys.cc @@ -67,25 +67,25 @@ bool GHOST_ModifierKeys::get(GHOST_TModifierKey mask) const { switch (mask) { case GHOST_kModifierKeyLeftShift: - return m_LeftShift; + return left_shift_; case GHOST_kModifierKeyRightShift: - return m_RightShift; + return right_shift_; case GHOST_kModifierKeyLeftAlt: - return m_LeftAlt; + return left_alt_; case GHOST_kModifierKeyRightAlt: - return m_RightAlt; + return right_alt_; case GHOST_kModifierKeyLeftControl: - return m_LeftControl; + return left_control_; case GHOST_kModifierKeyRightControl: - return m_RightControl; + return right_control_; case GHOST_kModifierKeyLeftOS: - return m_LeftOS; + return left_os_; case GHOST_kModifierKeyRightOS: - return m_RightOS; + return right_os_; case GHOST_kModifierKeyLeftHyper: - return m_LeftHyper; + return left_hyper_; case GHOST_kModifierKeyRightHyper: - return m_RightHyper; + return right_hyper_; default: GHOST_ASSERT(0, "Invalid key!"); return false; @@ -96,34 +96,34 @@ void GHOST_ModifierKeys::set(GHOST_TModifierKey mask, bool down) { switch (mask) { case GHOST_kModifierKeyLeftShift: - m_LeftShift = down; + left_shift_ = down; break; case GHOST_kModifierKeyRightShift: - m_RightShift = down; + right_shift_ = down; break; case GHOST_kModifierKeyLeftAlt: - m_LeftAlt = down; + left_alt_ = down; break; case GHOST_kModifierKeyRightAlt: - m_RightAlt = down; + right_alt_ = down; break; case GHOST_kModifierKeyLeftControl: - m_LeftControl = down; + left_control_ = down; break; case GHOST_kModifierKeyRightControl: - m_RightControl = down; + right_control_ = down; break; case GHOST_kModifierKeyLeftOS: - m_LeftOS = down; + left_os_ = down; break; case GHOST_kModifierKeyRightOS: - m_RightOS = down; + right_os_ = down; break; case GHOST_kModifierKeyLeftHyper: - m_LeftHyper = down; + left_hyper_ = down; break; case GHOST_kModifierKeyRightHyper: - m_RightHyper = down; + right_hyper_ = down; break; default: GHOST_ASSERT(0, "Invalid key!"); @@ -133,23 +133,23 @@ void GHOST_ModifierKeys::set(GHOST_TModifierKey mask, bool down) void GHOST_ModifierKeys::clear() { - m_LeftShift = false; - m_RightShift = false; - m_LeftAlt = false; - m_RightAlt = false; - m_LeftControl = false; - m_RightControl = false; - m_LeftOS = false; - m_RightOS = false; - m_LeftHyper = false; - m_RightHyper = false; + left_shift_ = false; + right_shift_ = false; + left_alt_ = false; + right_alt_ = false; + left_control_ = false; + right_control_ = false; + left_os_ = false; + right_os_ = false; + left_hyper_ = false; + right_hyper_ = false; } bool GHOST_ModifierKeys::equals(const GHOST_ModifierKeys &keys) const { - return (m_LeftShift == keys.m_LeftShift) && (m_RightShift == keys.m_RightShift) && - (m_LeftAlt == keys.m_LeftAlt) && (m_RightAlt == keys.m_RightAlt) && - (m_LeftControl == keys.m_LeftControl) && (m_RightControl == keys.m_RightControl) && - (m_LeftOS == keys.m_LeftOS) && (m_RightOS == keys.m_RightOS) && - (m_LeftHyper == keys.m_LeftHyper) && (m_RightHyper == keys.m_RightHyper); + return (left_shift_ == keys.left_shift_) && (right_shift_ == keys.right_shift_) && + (left_alt_ == keys.left_alt_) && (right_alt_ == keys.right_alt_) && + (left_control_ == keys.left_control_) && (right_control_ == keys.right_control_) && + (left_os_ == keys.left_os_) && (right_os_ == keys.right_os_) && + (left_hyper_ == keys.left_hyper_) && (right_hyper_ == keys.right_hyper_); } diff --git a/intern/ghost/intern/GHOST_ModifierKeys.hh b/intern/ghost/intern/GHOST_ModifierKeys.hh index ac49c38c429..0eae271ad48 100644 --- a/intern/ghost/intern/GHOST_ModifierKeys.hh +++ b/intern/ghost/intern/GHOST_ModifierKeys.hh @@ -57,20 +57,20 @@ struct GHOST_ModifierKeys { bool equals(const GHOST_ModifierKeys &keys) const; /** Bit-field that stores the appropriate key state. */ - uint8_t m_LeftShift : 1; + uint8_t left_shift_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_RightShift : 1; + uint8_t right_shift_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_LeftAlt : 1; + uint8_t left_alt_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_RightAlt : 1; + uint8_t right_alt_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_LeftControl : 1; + uint8_t left_control_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_RightControl : 1; + uint8_t right_control_ : 1; /** Bit-field that stores the appropriate key state. */ - uint8_t m_LeftOS : 1; - uint8_t m_RightOS : 1; - uint8_t m_LeftHyper : 1; - uint8_t m_RightHyper : 1; + uint8_t left_os_ : 1; + uint8_t right_os_ : 1; + uint8_t left_hyper_ : 1; + uint8_t right_hyper_ : 1; }; diff --git a/intern/ghost/intern/GHOST_Rect.cc b/intern/ghost/intern/GHOST_Rect.cc index a0518e1c5d0..1c15303ffac 100644 --- a/intern/ghost/intern/GHOST_Rect.cc +++ b/intern/ghost/intern/GHOST_Rect.cc @@ -12,39 +12,39 @@ void GHOST_Rect::inset(int32_t i) { if (i > 0) { /* Grow the rectangle. */ - m_l -= i; - m_r += i; - m_t -= i; - m_b += i; + l_ -= i; + r_ += i; + t_ -= i; + b_ += i; } else if (i < 0) { /* Shrink the rectangle, check for insets larger than half the size. */ int32_t i2 = i * 2; if (getWidth() > i2) { - m_l += i; - m_r -= i; + l_ += i; + r_ -= i; } else { - m_l = m_l + ((m_r - m_l) / 2); - m_r = m_l; + l_ = l_ + ((r_ - l_) / 2); + r_ = l_; } if (getHeight() > i2) { - m_t += i; - m_b -= i; + t_ += i; + b_ -= i; } else { - m_t = m_t + ((m_b - m_t) / 2); - m_b = m_t; + t_ = t_ + ((b_ - t_) / 2); + b_ = t_; } } } GHOST_TVisibility GHOST_Rect::getVisibility(GHOST_Rect &r) const { - bool lt = isInside(r.m_l, r.m_t); - bool rt = isInside(r.m_r, r.m_t); - bool lb = isInside(r.m_l, r.m_b); - bool rb = isInside(r.m_r, r.m_b); + bool lt = isInside(r.l_, r.t_); + bool rt = isInside(r.r_, r.t_); + bool lb = isInside(r.l_, r.b_); + bool rb = isInside(r.r_, r.b_); GHOST_TVisibility v; if (lt && rt && lb && rb) { /* All points inside, rectangle is inside this. */ @@ -53,7 +53,7 @@ GHOST_TVisibility GHOST_Rect::getVisibility(GHOST_Rect &r) const else if (!(lt || rt || lb || rb)) { /* None of the points inside. * Check to see whether the rectangle is larger than this one. */ - if ((r.m_l < m_l) && (r.m_t < m_t) && (r.m_r > m_r) && (r.m_b > m_b)) { + if ((r.l_ < l_) && (r.t_ < t_) && (r.r_ > r_) && (r.b_ > b_)) { v = GHOST_kPartiallyVisible; } else { @@ -69,12 +69,12 @@ GHOST_TVisibility GHOST_Rect::getVisibility(GHOST_Rect &r) const void GHOST_Rect::setCenter(int32_t cx, int32_t cy) { - int32_t offset = cx - (m_l + (m_r - m_l) / 2); - m_l += offset; - m_r += offset; - offset = cy - (m_t + (m_b - m_t) / 2); - m_t += offset; - m_b += offset; + int32_t offset = cx - (l_ + (r_ - l_) / 2); + l_ += offset; + r_ += offset; + offset = cy - (t_ + (b_ - t_) / 2); + t_ += offset; + b_ += offset; } void GHOST_Rect::setCenter(int32_t cx, int32_t cy, int32_t w, int32_t h) @@ -83,29 +83,29 @@ void GHOST_Rect::setCenter(int32_t cx, int32_t cy, int32_t w, int32_t h) w_2 = w >> 1; h_2 = h >> 1; - m_l = cx - w_2; - m_t = cy - h_2; - m_r = m_l + w; - m_b = m_t + h; + l_ = cx - w_2; + t_ = cy - h_2; + r_ = l_ + w; + b_ = t_ + h; } bool GHOST_Rect::clip(GHOST_Rect &r) const { bool clipped = false; - if (r.m_l < m_l) { - r.m_l = m_l; + if (r.l_ < l_) { + r.l_ = l_; clipped = true; } - if (r.m_t < m_t) { - r.m_t = m_t; + if (r.t_ < t_) { + r.t_ = t_; clipped = true; } - if (r.m_r > m_r) { - r.m_r = m_r; + if (r.r_ > r_) { + r.r_ = r_; clipped = true; } - if (r.m_b > m_b) { - r.m_b = m_b; + if (r.b_ > b_) { + r.b_ = b_; clipped = true; } return clipped; diff --git a/intern/ghost/intern/GHOST_System.cc b/intern/ghost/intern/GHOST_System.cc index f944cdfa822..3cef1c35bf6 100644 --- a/intern/ghost/intern/GHOST_System.cc +++ b/intern/ghost/intern/GHOST_System.cc @@ -18,18 +18,18 @@ #endif GHOST_System::GHOST_System() - : m_nativePixel(false), - m_windowFocus(true), - m_autoFocus(true), - m_timerManager(nullptr), - m_windowManager(nullptr), - m_eventManager(nullptr), + : native_pixel_(false), + window_focus_(true), + auto_focus_(true), + timer_manager_(nullptr), + window_manager_(nullptr), + event_manager_(nullptr), #ifdef WITH_INPUT_NDOF - m_ndofManager(nullptr), + ndof_manager_(nullptr), #endif - m_multitouchGestures(true), - m_tabletAPI(GHOST_kTabletAutomatic), - m_is_debug_enabled(false) + multitouch_gestures_(true), + tablet_api_(GHOST_kTabletAutomatic), + is_debug_enabled_(false) { } @@ -57,15 +57,15 @@ GHOST_TSuccess GHOST_System::putClipboardImage(uint * /*rgba*/, GHOST_ITimerTask *GHOST_System::installTimer(uint64_t delay, uint64_t interval, - GHOST_TimerProcPtr timerProc, - GHOST_TUserDataPtr userData) + GHOST_TimerProcPtr timer_proc, + GHOST_TUserDataPtr user_data) { uint64_t millis = getMilliSeconds(); - GHOST_TimerTask *timer = new GHOST_TimerTask(millis + delay, interval, timerProc, userData); + GHOST_TimerTask *timer = new GHOST_TimerTask(millis + delay, interval, timer_proc, user_data); if (timer) { - if (m_timerManager->addTimer(timer) == GHOST_kSuccess) { + if (timer_manager_->addTimer(timer) == GHOST_kSuccess) { /* Check to see whether we need to fire the timer right away. */ - m_timerManager->fireTimers(millis); + timer_manager_->fireTimers(millis); } else { delete timer; @@ -79,7 +79,7 @@ GHOST_TSuccess GHOST_System::removeTimer(GHOST_ITimerTask *timerTask) { GHOST_TSuccess success = GHOST_kFailure; if (timerTask) { - success = m_timerManager->removeTimer((GHOST_TimerTask *)timerTask); + success = timer_manager_->removeTimer((GHOST_TimerTask *)timerTask); } return success; } @@ -91,9 +91,9 @@ GHOST_TSuccess GHOST_System::disposeWindow(GHOST_IWindow *window) /* * Remove all pending events for the window. */ - if (m_windowManager->getWindowFound(window)) { - m_eventManager->removeWindowEvents(window); - success = m_windowManager->removeWindow(window); + if (window_manager_->getWindowFound(window)) { + event_manager_->removeWindowEvents(window); + success = window_manager_->removeWindow(window); if (success) { delete window; } @@ -106,7 +106,7 @@ GHOST_TSuccess GHOST_System::disposeWindow(GHOST_IWindow *window) bool GHOST_System::validWindow(GHOST_IWindow *window) { - return m_windowManager->getWindowFound(window); + return window_manager_->getWindowFound(window); } GHOST_IWindow *GHOST_System::getWindowUnderCursor(int32_t x, int32_t y) @@ -115,7 +115,7 @@ GHOST_IWindow *GHOST_System::getWindowUnderCursor(int32_t x, int32_t y) * It is imperfect but usable in most cases. Ideally each platform should provide * a custom version of this function that properly considers z-order. */ - std::vector windows = m_windowManager->getWindows(); + std::vector windows = window_manager_->getWindows(); std::vector::reverse_iterator iwindow_iter; /* Search through the windows in reverse order because in most cases @@ -143,23 +143,23 @@ void GHOST_System::dispatchEvents() { #ifdef WITH_INPUT_NDOF /* NDOF Motion event is sent only once per dispatch, so do it now: */ - if (m_ndofManager) { - m_ndofManager->sendMotionEvent(); + if (ndof_manager_) { + ndof_manager_->sendMotionEvent(); } #endif - if (m_eventManager) { - m_eventManager->dispatchEvents(); + if (event_manager_) { + event_manager_->dispatchEvents(); } - m_timerManager->fireTimers(getMilliSeconds()); + timer_manager_->fireTimers(getMilliSeconds()); } GHOST_TSuccess GHOST_System::addEventConsumer(GHOST_IEventConsumer *consumer) { GHOST_TSuccess success; - if (m_eventManager) { - success = m_eventManager->addConsumer(consumer); + if (event_manager_) { + success = event_manager_->addConsumer(consumer); } else { success = GHOST_kFailure; @@ -170,8 +170,8 @@ GHOST_TSuccess GHOST_System::addEventConsumer(GHOST_IEventConsumer *consumer) GHOST_TSuccess GHOST_System::removeEventConsumer(GHOST_IEventConsumer *consumer) { GHOST_TSuccess success; - if (m_eventManager) { - success = m_eventManager->removeConsumer(consumer); + if (event_manager_) { + success = event_manager_->removeConsumer(consumer); } else { success = GHOST_kFailure; @@ -182,8 +182,8 @@ GHOST_TSuccess GHOST_System::removeEventConsumer(GHOST_IEventConsumer *consumer) GHOST_TSuccess GHOST_System::pushEvent(const GHOST_IEvent *event) { GHOST_TSuccess success; - if (m_eventManager) { - success = m_eventManager->pushEvent(event); + if (event_manager_) { + success = event_manager_->pushEvent(event); } else { success = GHOST_kFailure; @@ -219,43 +219,43 @@ uint32_t GHOST_System::getCursorPreferredLogicalSize() const return uint32_t(24); } -GHOST_TSuccess GHOST_System::getModifierKeyState(GHOST_TModifierKey mask, bool &isDown) const +GHOST_TSuccess GHOST_System::getModifierKeyState(GHOST_TModifierKey mask, bool &is_down) const { GHOST_ModifierKeys keys; /* Get the state of all modifier keys. */ GHOST_TSuccess success = getModifierKeys(keys); if (success) { /* Isolate the state of the key requested. */ - isDown = keys.get(mask); + is_down = keys.get(mask); } return success; } -GHOST_TSuccess GHOST_System::getButtonState(GHOST_TButton mask, bool &isDown) const +GHOST_TSuccess GHOST_System::getButtonState(GHOST_TButton mask, bool &is_down) const { GHOST_Buttons buttons; /* Get the state of all mouse buttons. */ GHOST_TSuccess success = getButtons(buttons); if (success) { /* Isolate the state of the mouse button requested. */ - isDown = buttons.get(mask); + is_down = buttons.get(mask); } return success; } void GHOST_System::setMultitouchGestures(const bool use) { - m_multitouchGestures = use; + multitouch_gestures_ = use; } void GHOST_System::setTabletAPI(GHOST_TTabletAPI api) { - m_tabletAPI = api; + tablet_api_ = api; } GHOST_TTabletAPI GHOST_System::getTabletAPI() { - return m_tabletAPI; + return tablet_api_; } GHOST_TSuccess GHOST_System::getPixelAtCursor(float /*r_color*/[3]) const @@ -266,26 +266,26 @@ GHOST_TSuccess GHOST_System::getPixelAtCursor(float /*r_color*/[3]) const #ifdef WITH_INPUT_NDOF void GHOST_System::setNDOFDeadZone(float deadzone) { - if (this->m_ndofManager) { - this->m_ndofManager->setDeadZone(deadzone); + if (this->ndof_manager_) { + this->ndof_manager_->setDeadZone(deadzone); } } #endif GHOST_TSuccess GHOST_System::init() { - m_timerManager = new GHOST_TimerManager(); - m_windowManager = new GHOST_WindowManager(); - m_eventManager = new GHOST_EventManager(); + timer_manager_ = new GHOST_TimerManager(); + window_manager_ = new GHOST_WindowManager(); + event_manager_ = new GHOST_EventManager(); #ifdef WITH_GHOST_DEBUG - if (m_eventManager) { - m_eventPrinter = new GHOST_EventPrinter(); - m_eventManager->addConsumer(m_eventPrinter); + if (event_manager_) { + event_printer_ = new GHOST_EventPrinter(); + event_manager_->addConsumer(event_printer_); } #endif /* WITH_GHOST_DEBUG */ - if (m_timerManager && m_windowManager && m_eventManager) { + if (timer_manager_ && window_manager_ && event_manager_) { return GHOST_kSuccess; } return GHOST_kFailure; @@ -296,18 +296,18 @@ GHOST_TSuccess GHOST_System::exit() /** WARNING: exit() may run more than once, since it may need to be called from a derived class * destructor. Take it into account when modifying this function. */ - delete m_windowManager; - m_windowManager = nullptr; + delete window_manager_; + window_manager_ = nullptr; - delete m_timerManager; - m_timerManager = nullptr; + delete timer_manager_; + timer_manager_ = nullptr; - delete m_eventManager; - m_eventManager = nullptr; + delete event_manager_; + event_manager_ = nullptr; #ifdef WITH_INPUT_NDOF - delete m_ndofManager; - m_ndofManager = nullptr; + delete ndof_manager_; + ndof_manager_ = nullptr; #endif return GHOST_kSuccess; @@ -315,26 +315,26 @@ GHOST_TSuccess GHOST_System::exit() bool GHOST_System::useNativePixel() { - m_nativePixel = true; + native_pixel_ = true; return true; } void GHOST_System::useWindowFocus(const bool use_focus) { - m_windowFocus = use_focus; + window_focus_ = use_focus; } void GHOST_System::setAutoFocus(const bool auto_focus) { - m_autoFocus = auto_focus; + auto_focus_ = auto_focus; } void GHOST_System::initDebug(GHOST_Debug debug) { - m_is_debug_enabled = debug.flags & GHOST_kDebugDefault; + is_debug_enabled_ = debug.flags & GHOST_kDebugDefault; } bool GHOST_System::isDebugEnabled() { - return m_is_debug_enabled; + return is_debug_enabled_; } diff --git a/intern/ghost/intern/GHOST_System.hh b/intern/ghost/intern/GHOST_System.hh index 9a4baf99e7e..a1c6fb98a23 100644 --- a/intern/ghost/intern/GHOST_System.hh +++ b/intern/ghost/intern/GHOST_System.hh @@ -56,8 +56,8 @@ class GHOST_System : public GHOST_ISystem { /** \copydoc #GHOST_ISystem::installTimer */ GHOST_ITimerTask *installTimer(uint64_t delay, uint64_t interval, - GHOST_TimerProcPtr timerProc, - GHOST_TUserDataPtr userData = nullptr) override; + GHOST_TimerProcPtr timer_proc, + GHOST_TUserDataPtr user_data = nullptr) override; /** \copydoc #GHOST_ISystem::removeTimer */ GHOST_TSuccess removeTimer(GHOST_ITimerTask *timerTask) override; @@ -69,23 +69,23 @@ class GHOST_System : public GHOST_ISystem { GHOST_TSuccess disposeWindow(GHOST_IWindow *window) override; /** \copydoc #GHOST_ISystem::createOffscreenContext */ - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override = 0; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override = 0; /** \copydoc #GHOST_ISystem::validWindow */ bool validWindow(GHOST_IWindow *window) override; /** \copydoc #GHOST_ISystem::useNativePixel */ bool useNativePixel() override; - bool m_nativePixel; + bool native_pixel_; /** \copydoc #GHOST_ISystem::useWindowFocus */ void useWindowFocus(const bool use_focus) override; - bool m_windowFocus; + bool window_focus_; /** \copydoc #GHOST_ISystem::setAutoFocus */ void setAutoFocus(const bool auto_focus) override; - bool m_autoFocus; + bool auto_focus_; /** \copydoc #GHOST_ISystem::getWindowUnderCursor */ GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y) override; @@ -142,10 +142,10 @@ class GHOST_System : public GHOST_ISystem { ***************************************************************************************/ /** \copydoc #GHOST_ISystem::getModifierKeyState */ - GHOST_TSuccess getModifierKeyState(GHOST_TModifierKey mask, bool &isDown) const override; + GHOST_TSuccess getModifierKeyState(GHOST_TModifierKey mask, bool &is_down) const override; /** \copydoc #GHOST_ISystem::getButtonState */ - GHOST_TSuccess getButtonState(GHOST_TButton mask, bool &isDown) const override; + GHOST_TSuccess getButtonState(GHOST_TButton mask, bool &is_down) const override; /** \copydoc #GHOST_ISystem::setMultitouchGestures */ void setMultitouchGestures(const bool use) override; @@ -257,51 +257,51 @@ class GHOST_System : public GHOST_ISystem { GHOST_TSuccess exit() override; /** The timer manager. */ - GHOST_TimerManager *m_timerManager; + GHOST_TimerManager *timer_manager_; /** The window manager. */ - GHOST_WindowManager *m_windowManager; + GHOST_WindowManager *window_manager_; /** The event manager. */ - GHOST_EventManager *m_eventManager; + GHOST_EventManager *event_manager_; #ifdef WITH_INPUT_NDOF /** The N-degree of freedom device manager */ - GHOST_NDOFManager *m_ndofManager; + GHOST_NDOFManager *ndof_manager_; #endif #ifdef WITH_GHOST_DEBUG /** Prints all the events. */ - GHOST_EventPrinter *m_eventPrinter; + GHOST_EventPrinter *event_printer_; #endif // WITH_GHOST_DEBUG /** Use multi-touch gestures. */ - bool m_multitouchGestures; + bool multitouch_gestures_; /** Which tablet API to use. */ - GHOST_TTabletAPI m_tabletAPI; + GHOST_TTabletAPI tablet_api_; - bool m_is_debug_enabled; + bool is_debug_enabled_; }; inline GHOST_TimerManager *GHOST_System::getTimerManager() const { - return m_timerManager; + return timer_manager_; } inline GHOST_EventManager *GHOST_System::getEventManager() const { - return m_eventManager; + return event_manager_; } inline GHOST_WindowManager *GHOST_System::getWindowManager() const { - return m_windowManager; + return window_manager_; } #ifdef WITH_INPUT_NDOF inline GHOST_NDOFManager *GHOST_System::getNDOFManager() const { - return m_ndofManager; + return ndof_manager_; } #endif diff --git a/intern/ghost/intern/GHOST_SystemCocoa.hh b/intern/ghost/intern/GHOST_SystemCocoa.hh index db251717e95..61ac76a988b 100644 --- a/intern/ghost/intern/GHOST_SystemCocoa.hh +++ b/intern/ghost/intern/GHOST_SystemCocoa.hh @@ -78,9 +78,9 @@ class GHOST_SystemCocoa : public GHOST_System { * \param width: The width the window. * \param height: The height the window. * \param state: The state of the window when opened. - * \param gpuSettings: Misc GPU settings. + * \param gpu_settings: Misc GPU settings. * \param exclusive: Use to show the window on top and ignore others (used full-screen). - * \param parentWindow: Parent (embedder) window. + * \param parent_window: Parent (embedder) window. * \return The new window (or 0 if creation failed). */ GHOST_IWindow *createWindow(const char *title, @@ -89,17 +89,17 @@ class GHOST_SystemCocoa : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive = false, const bool is_dialog = false, - const GHOST_IWindow *parentWindow = nullptr) override; + const GHOST_IWindow *parent_window = nullptr) override; /** * Create a new off-screen context. * Never explicitly delete the context, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override; /** * Dispose of a context. @@ -333,23 +333,23 @@ class GHOST_SystemCocoa : public GHOST_System { /** Event has been processed directly by Cocoa (or NDOF manager) * and has sent a ghost event to be dispatched */ - bool m_outsideLoopEventProcessed; + bool outside_loop_event_processed_; /** Raised window is not yet known by the window manager, * so delay application become active event handling */ - bool m_needDelayedApplicationBecomeActiveEventProcessing; + bool need_delayed_application_become_active_event_processing_; /** State of the modifiers. */ - uint32_t m_modifierMask; + uint32_t modifier_mask_; /** Ignores window size messages (when window is dragged). */ - bool m_ignoreWindowSizedMessages; + bool ignore_window_sized_messages_; /** Temporarily ignore momentum scroll events */ - bool m_ignoreMomentumScroll; + bool ignore_momentum_scroll_; /** Is the scroll wheel event generated by a multi-touch trackpad or mouse? */ - bool m_multiTouchScroll; + bool multi_touch_scroll_; /** To prevent multiple warp, we store the time of the last warp event * and ignore mouse moved events generated before that. */ - double m_last_warp_timestamp; + double last_warp_timestamp_; }; diff --git a/intern/ghost/intern/GHOST_SystemCocoa.mm b/intern/ghost/intern/GHOST_SystemCocoa.mm index 40e8807667d..a4ff30e92d2 100644 --- a/intern/ghost/intern/GHOST_SystemCocoa.mm +++ b/intern/ghost/intern/GHOST_SystemCocoa.mm @@ -382,7 +382,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) @implementation CocoaAppDelegate : NSObject -@synthesize systemCocoa = m_systemCocoa; +@synthesize systemCocoa = system_cocoa_; - (instancetype)initWithSystemCocoa:(GHOST_SystemCocoa *)systemCocoa { @@ -394,7 +394,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) selector:@selector(windowWillClose:) name:NSWindowWillCloseNotification object:nil]; - m_systemCocoa = systemCocoa; + system_cocoa_ = systemCocoa; } return self; @@ -411,7 +411,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) - (void)applicationDidFinishLaunching:(NSNotification *)aNotification { - if (m_systemCocoa->m_windowFocus) { + if (system_cocoa_->window_focus_) { /* Raise application to front, convenient when starting from the terminal * and important for launching the animation player. we call this after the * application finishes launching, as doing it earlier can make us end up @@ -424,7 +424,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename { - return m_systemCocoa->handleOpenDocumentRequest(filename); + return system_cocoa_->handleOpenDocumentRequest(filename); } - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender @@ -432,7 +432,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) /* TODO: implement graceful termination through Cocoa mechanism * to avoid session log off to be canceled. */ /* Note that Command-Q is already handled by key-handler. */ - m_systemCocoa->handleQuitRequest(); + system_cocoa_->handleQuitRequest(); return NSTerminateCancel; } @@ -448,7 +448,7 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) - (void)applicationWillBecomeActive:(NSNotification *)aNotification { - m_systemCocoa->handleApplicationBecomeActiveEvent(); + system_cocoa_->handleApplicationBecomeActiveEvent(); } - (void)toggleFullScreen:(NSNotification *)notification @@ -537,14 +537,14 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG]) GHOST_SystemCocoa::GHOST_SystemCocoa() { - m_modifierMask = 0; - m_outsideLoopEventProcessed = false; - m_needDelayedApplicationBecomeActiveEventProcessing = false; + modifier_mask_ = 0; + outside_loop_event_processed_ = false; + need_delayed_application_become_active_event_processing_ = false; - m_ignoreWindowSizedMessages = false; - m_ignoreMomentumScroll = false; - m_multiTouchScroll = false; - m_last_warp_timestamp = 0; + ignore_window_sized_messages_ = false; + ignore_momentum_scroll_ = false; + multi_touch_scroll_ = false; + last_warp_timestamp_ = 0; } GHOST_SystemCocoa::~GHOST_SystemCocoa() @@ -569,7 +569,7 @@ GHOST_TSuccess GHOST_SystemCocoa::init() if (success) { #ifdef WITH_INPUT_NDOF - m_ndofManager = new GHOST_NDOFManagerCocoa(*this); + ndof_manager_ = new GHOST_NDOFManagerCocoa(*this); #endif // ProcessSerialNumber psn; @@ -720,12 +720,12 @@ GHOST_IWindow *GHOST_SystemCocoa::createWindow(const char *title, uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool /*exclusive*/, const bool is_dialog, - const GHOST_IWindow *parentWindow) + const GHOST_IWindow *parent_window) { - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings); GHOST_IWindow *window = nullptr; @autoreleasepool { /* Get the available rect for including window contents. */ @@ -744,17 +744,17 @@ GHOST_IWindow *GHOST_SystemCocoa::createWindow(const char *title, width, height, state, - gpuSettings.context_type, + gpu_settings.context_type, context_params, is_dialog, - (GHOST_WindowCocoa *)parentWindow, - gpuSettings.preferred_device); + (GHOST_WindowCocoa *)parent_window, + gpu_settings.preferred_device); if (window->getValid()) { /* Store the pointer to the window. */ - GHOST_ASSERT(m_windowManager, "m_windowManager not initialized"); - m_windowManager->addWindow(window); - m_windowManager->setActiveWindow(window); + GHOST_ASSERT(window_manager_, "window_manager_ not initialized"); + window_manager_->addWindow(window); + window_manager_->setActiveWindow(window); /* Need to tell window manager the new window is the active one * (Cocoa does not send the event activate upon window creation). */ pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window)); @@ -774,16 +774,16 @@ GHOST_IWindow *GHOST_SystemCocoa::createWindow(const char *title, * Never explicitly delete the context, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ -GHOST_IContext *GHOST_SystemCocoa::createOffscreenContext(GHOST_GPUSettings gpuSettings) +GHOST_IContext *GHOST_SystemCocoa::createOffscreenContext(GHOST_GPUSettings gpu_settings) { const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { GHOST_Context *context = new GHOST_ContextVK( - context_params_offscreen, nullptr, 1, 2, gpuSettings.preferred_device); + context_params_offscreen, nullptr, 1, 2, gpu_settings.preferred_device); if (context->initializeDrawingContext()) { return context; } @@ -834,7 +834,7 @@ GHOST_IWindow *GHOST_SystemCocoa::getWindowUnderCursor(int32_t x, int32_t y) return nil; } - return m_windowManager->getWindowAssociatedWithOSWindow((const void *)nswindow); + return window_manager_->getWindowAssociatedWithOSWindow((const void *)nswindow); } } @@ -856,7 +856,7 @@ GHOST_TSuccess GHOST_SystemCocoa::getCursorPosition(int32_t &x, int32_t &y) cons */ GHOST_TSuccess GHOST_SystemCocoa::setCursorPosition(int32_t x, int32_t y) { - GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)m_windowManager->getActiveWindow(); + GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)window_manager_->getActiveWindow(); if (!window) { return GHOST_kFailure; } @@ -870,7 +870,7 @@ GHOST_TSuccess GHOST_SystemCocoa::setCursorPosition(int32_t x, int32_t y) /* Force mouse move event (not pushed by Cocoa). */ pushEvent(new GHOST_EventCursor( getMilliSeconds(), GHOST_kEventCursorMove, window, x, y, window->GetCocoaTabletData())); - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; return GHOST_kSuccess; } @@ -912,7 +912,7 @@ GHOST_TSuccess GHOST_SystemCocoa::getPixelAtCursor(float r_color[3]) const GHOST_TSuccess GHOST_SystemCocoa::setMouseCursorPosition(int32_t x, int32_t y) { float xf = float(x), yf = float(y); - GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)m_windowManager->getActiveWindow(); + GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)window_manager_->getActiveWindow(); if (!window) { return GHOST_kFailure; } @@ -944,12 +944,12 @@ GHOST_TSuccess GHOST_SystemCocoa::setMouseCursorPosition(int32_t x, int32_t y) GHOST_TSuccess GHOST_SystemCocoa::getModifierKeys(GHOST_ModifierKeys &keys) const { - keys.set(GHOST_kModifierKeyLeftOS, (m_modifierMask & NSEventModifierFlagCommand) ? true : false); - keys.set(GHOST_kModifierKeyLeftAlt, (m_modifierMask & NSEventModifierFlagOption) ? true : false); + keys.set(GHOST_kModifierKeyLeftOS, (modifier_mask_ & NSEventModifierFlagCommand) ? true : false); + keys.set(GHOST_kModifierKeyLeftAlt, (modifier_mask_ & NSEventModifierFlagOption) ? true : false); keys.set(GHOST_kModifierKeyLeftShift, - (m_modifierMask & NSEventModifierFlagShift) ? true : false); + (modifier_mask_ & NSEventModifierFlagShift) ? true : false); keys.set(GHOST_kModifierKeyLeftControl, - (m_modifierMask & NSEventModifierFlagControl) ? true : false); + (modifier_mask_ & NSEventModifierFlagControl) ? true : false); return GHOST_kSuccess; } @@ -1065,16 +1065,16 @@ bool GHOST_SystemCocoa::processEvents(bool /*waitForEvent*/) } while (waitForEvent && !anyProcessed); /* Needed only for timer implementation. */ #endif - if (m_needDelayedApplicationBecomeActiveEventProcessing) { + if (need_delayed_application_become_active_event_processing_) { handleApplicationBecomeActiveEvent(); } - if (m_outsideLoopEventProcessed) { - m_outsideLoopEventProcessed = false; + if (outside_loop_event_processed_) { + outside_loop_event_processed_ = false; return true; } - m_ignoreWindowSizedMessages = false; + ignore_window_sized_messages_ = false; return anyProcessed; } @@ -1083,7 +1083,7 @@ bool GHOST_SystemCocoa::processEvents(bool /*waitForEvent*/) GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() { @autoreleasepool { - for (GHOST_IWindow *iwindow : m_windowManager->getWindows()) { + for (GHOST_IWindow *iwindow : window_manager_->getWindows()) { GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)iwindow; if (window->isDialog()) { [window->getViewWindow() makeKeyAndOrderFront:nil]; @@ -1092,19 +1092,19 @@ GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() /* Update the modifiers key mask, as its status may have changed when the application * was not active (that is when update events are sent to another application). */ - GHOST_IWindow *window = m_windowManager->getActiveWindow(); + GHOST_IWindow *window = window_manager_->getActiveWindow(); if (!window) { - m_needDelayedApplicationBecomeActiveEventProcessing = true; + need_delayed_application_become_active_event_processing_ = true; return GHOST_kFailure; } - m_needDelayedApplicationBecomeActiveEventProcessing = false; + need_delayed_application_become_active_event_processing_ = false; const unsigned int modifiers = [[[NSApplication sharedApplication] currentEvent] modifierFlags]; - if ((modifiers & NSEventModifierFlagShift) != (m_modifierMask & NSEventModifierFlagShift)) { + if ((modifiers & NSEventModifierFlagShift) != (modifier_mask_ & NSEventModifierFlagShift)) { pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & NSEventModifierFlagShift) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, @@ -1112,7 +1112,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() GHOST_kKeyLeftShift, false)); } - if ((modifiers & NSEventModifierFlagControl) != (m_modifierMask & NSEventModifierFlagControl)) + if ((modifiers & NSEventModifierFlagControl) != (modifier_mask_ & NSEventModifierFlagControl)) { pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & NSEventModifierFlagControl) ? GHOST_kEventKeyDown : @@ -1121,7 +1121,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() GHOST_kKeyLeftControl, false)); } - if ((modifiers & NSEventModifierFlagOption) != (m_modifierMask & NSEventModifierFlagOption)) { + if ((modifiers & NSEventModifierFlagOption) != (modifier_mask_ & NSEventModifierFlagOption)) { pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & NSEventModifierFlagOption) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, @@ -1129,7 +1129,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() GHOST_kKeyLeftAlt, false)); } - if ((modifiers & NSEventModifierFlagCommand) != (m_modifierMask & NSEventModifierFlagCommand)) + if ((modifiers & NSEventModifierFlagCommand) != (modifier_mask_ & NSEventModifierFlagCommand)) { pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & NSEventModifierFlagCommand) ? GHOST_kEventKeyDown : @@ -1139,16 +1139,16 @@ GHOST_TSuccess GHOST_SystemCocoa::handleApplicationBecomeActiveEvent() false)); } - m_modifierMask = modifiers; + modifier_mask_ = modifiers; - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; } return GHOST_kSuccess; } bool GHOST_SystemCocoa::hasDialogWindow() { - for (GHOST_IWindow *iwindow : m_windowManager->getWindows()) { + for (GHOST_IWindow *iwindow : window_manager_->getWindows()) { GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)iwindow; if (window->isDialog()) { return true; @@ -1159,7 +1159,7 @@ bool GHOST_SystemCocoa::hasDialogWindow() void GHOST_SystemCocoa::notifyExternalEventProcessed() { - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; } /* NOTE: called from #NSWindow delegate. */ @@ -1174,16 +1174,16 @@ GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window)); break; case GHOST_kEventWindowActivate: - m_windowManager->setActiveWindow(window); + window_manager_->setActiveWindow(window); window->loadCursor(window->getCursorVisibility(), window->getCursorShape()); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window)); break; case GHOST_kEventWindowDeactivate: - m_windowManager->setWindowInactive(window); + window_manager_->setWindowInactive(window); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window)); break; case GHOST_kEventWindowUpdate: - if (m_nativePixel) { + if (native_pixel_) { window->setNativePixelSize(); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventNativeResolutionChange, window)); } @@ -1193,7 +1193,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowMove, window)); break; case GHOST_kEventWindowSize: - if (!m_ignoreWindowSizedMessages) { + if (!ignore_window_sized_messages_) { /* Enforce only one resize message per event loop * (coalescing all the live resize messages). */ window->updateDrawingContext(); @@ -1205,12 +1205,12 @@ GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, window, GHOST_kButtonMaskLeft, GHOST_TABLET_DATA_NONE)); - // m_ignoreWindowSizedMessages = true; + // ignore_window_sized_messages_ = true; } break; case GHOST_kEventNativeResolutionChange: - if (m_nativePixel) { + if (native_pixel_) { window->setNativePixelSize(); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventNativeResolutionChange, window)); } @@ -1220,7 +1220,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleWindowEvent(GHOST_TEventType eventType, break; } - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; return GHOST_kSuccess; } @@ -1390,13 +1390,13 @@ GHOST_TSuccess GHOST_SystemCocoa::handleDraggingEvent(GHOST_TEventType eventType default: return GHOST_kFailure; } - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; return GHOST_kSuccess; } void GHOST_SystemCocoa::handleQuitRequest() { - GHOST_Window *window = (GHOST_Window *)m_windowManager->getActiveWindow(); + GHOST_Window *window = (GHOST_Window *)window_manager_->getActiveWindow(); /* Discard quit event if we are in cursor grab sequence. */ if (window && window->getCursorGrabModeIsWarp()) { @@ -1405,7 +1405,7 @@ void GHOST_SystemCocoa::handleQuitRequest() /* Push the event to Blender so it can open a dialog if needed. */ pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventQuitRequest, window)); - m_outsideLoopEventProcessed = true; + outside_loop_event_processed_ = true; } bool GHOST_SystemCocoa::handleOpenDocumentRequest(void *filepathStr) @@ -1421,9 +1421,9 @@ bool GHOST_SystemCocoa::handleOpenDocumentRequest(void *filepathStr) [[windowsList objectAtIndex:0] makeKeyAndOrderFront:nil]; } - GHOST_Window *window = m_windowManager->getWindows().empty() ? + GHOST_Window *window = window_manager_->getWindows().empty() ? nullptr : - (GHOST_Window *)m_windowManager->getWindows().front(); + (GHOST_Window *)window_manager_->getWindows().front(); if (!window) { return NO; @@ -1457,7 +1457,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleTabletEvent(void *eventPtr, short eventT { NSEvent *event = (NSEvent *)eventPtr; - GHOST_IWindow *window = m_windowManager->getWindowAssociatedWithOSWindow( + GHOST_IWindow *window = window_manager_->getWindowAssociatedWithOSWindow( (const void *)event.window); if (!window) { // printf("\nW failure for event 0x%x",event.type); @@ -1536,10 +1536,10 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) /* event.window returns other windows if mouse-over, that's OSX input standard * however, if mouse exits window(s), the windows become inactive, until you click. * We then fall back to the active window from ghost. */ - GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)m_windowManager + GHOST_WindowCocoa *window = (GHOST_WindowCocoa *)window_manager_ ->getWindowAssociatedWithOSWindow((const void *)event.window); if (!window) { - window = (GHOST_WindowCocoa *)m_windowManager->getActiveWindow(); + window = (GHOST_WindowCocoa *)window_manager_->getActiveWindow(); if (!window) { // printf("\nW failure for event 0x%x", event.type); return GHOST_kFailure; @@ -1636,7 +1636,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) case GHOST_kGrabWrap: { /* Wrap cursor at area/window boundaries. */ const NSTimeInterval timestamp = event.timestamp; - if (timestamp < m_last_warp_timestamp) { + if (timestamp < last_warp_timestamp_) { /* After warping we can still receive older unwrapped mouse events, * ignore those. */ break; @@ -1652,10 +1652,10 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) /* Switch back to Cocoa coordinates orientation * (y=0 at bottom, the same as blender internal BTW!), and to client coordinates. */ window->getClientBounds(windowBounds); - window->screenToClient(bounds.m_l, bounds.m_b, correctedBounds.m_l, correctedBounds.m_t); - window->screenToClient(bounds.m_r, bounds.m_t, correctedBounds.m_r, correctedBounds.m_b); - correctedBounds.m_b = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_b; - correctedBounds.m_t = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_t; + window->screenToClient(bounds.l_, bounds.b_, correctedBounds.l_, correctedBounds.t_); + window->screenToClient(bounds.r_, bounds.t_, correctedBounds.r_, correctedBounds.b_); + correctedBounds.b_ = (windowBounds.b_ - windowBounds.t_) - correctedBounds.b_; + correctedBounds.t_ = (windowBounds.b_ - windowBounds.t_) - correctedBounds.t_; /* Get accumulation from previous mouse warps. */ int32_t x_accum, y_accum; @@ -1681,7 +1681,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) y_accum + (y_mouse - warped_y_mouse)); /* This is the current time that matches NSEvent timestamp. */ - m_last_warp_timestamp = [[NSProcessInfo processInfo] systemUptime]; + last_warp_timestamp_ = [[NSProcessInfo processInfo] systemUptime]; } /* Generate event. */ @@ -1721,27 +1721,27 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) * change from e.g. scrolling to zooming. this works around the * issue by ignoring momentum scroll after a key press */ if (momentumPhase) { - if (m_ignoreMomentumScroll) { + if (ignore_momentum_scroll_) { break; } } else { - m_ignoreMomentumScroll = false; + ignore_momentum_scroll_ = false; } /* we assume phases are only set for gestures from trackpad or magic * mouse events. note that using tablet at the same time may not work * since this is a static variable */ - if (phase == NSEventPhaseBegan && m_multitouchGestures) { - m_multiTouchScroll = true; + if (phase == NSEventPhaseBegan && multitouch_gestures_) { + multi_touch_scroll_ = true; } else if (phase == NSEventPhaseEnded) { - m_multiTouchScroll = false; + multi_touch_scroll_ = false; } /* Standard scroll-wheel case, if no swiping happened, * and no momentum (kinetic scroll) works. */ - if (!m_multiTouchScroll && momentumPhase == NSEventPhaseNone) { + if (!multi_touch_scroll_ && momentumPhase == NSEventPhaseNone) { if (event.deltaX != 0.0) { const int32_t delta = event.deltaX > 0.0 ? 1 : -1; pushEvent(new GHOST_EventWheel( @@ -1832,7 +1832,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr) GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) { NSEvent *event = (NSEvent *)eventPtr; - GHOST_IWindow *window = m_windowManager->getWindowAssociatedWithOSWindow( + GHOST_IWindow *window = window_manager_->getWindowAssociatedWithOSWindow( (const void *)event.window); if (!window) { @@ -1877,11 +1877,11 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) } /* no text with command key pressed */ - if (m_modifierMask & NSEventModifierFlagCommand) { + if (modifier_mask_ & NSEventModifierFlagCommand) { utf8_buf[0] = '\0'; } - if ((keyCode == GHOST_kKeyQ) && (m_modifierMask & NSEventModifierFlagCommand)) { + if ((keyCode == GHOST_kKeyQ) && (modifier_mask_ & NSEventModifierFlagCommand)) { break; /* Command-Q is directly handled by Cocoa. */ } @@ -1913,13 +1913,13 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) utf8_buf); #endif } - m_ignoreMomentumScroll = true; + ignore_momentum_scroll_ = true; break; } case NSEventTypeFlagsChanged: { const unsigned int modifiers = event.modifierFlags; - if ((modifiers & NSEventModifierFlagShift) != (m_modifierMask & NSEventModifierFlagShift)) { + if ((modifiers & NSEventModifierFlagShift) != (modifier_mask_ & NSEventModifierFlagShift)) { pushEvent(new GHOST_EventKey(event.timestamp * 1000, (modifiers & NSEventModifierFlagShift) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, @@ -1928,7 +1928,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) false)); } if ((modifiers & NSEventModifierFlagControl) != - (m_modifierMask & NSEventModifierFlagControl)) + (modifier_mask_ & NSEventModifierFlagControl)) { pushEvent(new GHOST_EventKey( event.timestamp * 1000, @@ -1937,7 +1937,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) GHOST_kKeyLeftControl, false)); } - if ((modifiers & NSEventModifierFlagOption) != (m_modifierMask & NSEventModifierFlagOption)) + if ((modifiers & NSEventModifierFlagOption) != (modifier_mask_ & NSEventModifierFlagOption)) { pushEvent(new GHOST_EventKey( event.timestamp * 1000, @@ -1947,7 +1947,7 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) false)); } if ((modifiers & NSEventModifierFlagCommand) != - (m_modifierMask & NSEventModifierFlagCommand)) + (modifier_mask_ & NSEventModifierFlagCommand)) { pushEvent(new GHOST_EventKey( event.timestamp * 1000, @@ -1957,8 +1957,8 @@ GHOST_TSuccess GHOST_SystemCocoa::handleKeyEvent(void *eventPtr) false)); } - m_modifierMask = modifiers; - m_ignoreMomentumScroll = true; + modifier_mask_ = modifiers; + ignore_momentum_scroll_ = true; break; } diff --git a/intern/ghost/intern/GHOST_SystemHeadless.hh b/intern/ghost/intern/GHOST_SystemHeadless.hh index ebd03625e88..cf02a8d1cd7 100644 --- a/intern/ghost/intern/GHOST_SystemHeadless.hh +++ b/intern/ghost/intern/GHOST_SystemHeadless.hh @@ -109,22 +109,22 @@ class GHOST_SystemHeadless : public GHOST_System { void getAllDisplayDimensions(uint32_t & /*width*/, uint32_t & /*height*/) const override { /* nop */ } - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override { const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); /* This may not be used depending on the build configuration. */ (void)context_params_offscreen; - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { # ifdef _WIN32 GHOST_Context *context = new GHOST_ContextVK( - context_params_offscreen, (HWND)0, 1, 2, gpuSettings.preferred_device); + context_params_offscreen, (HWND)0, 1, 2, gpu_settings.preferred_device); # elif defined(__APPLE__) GHOST_Context *context = new GHOST_ContextVK( - context_params_offscreen, nullptr, 1, 2, gpuSettings.preferred_device); + context_params_offscreen, nullptr, 1, 2, gpu_settings.preferred_device); # else GHOST_Context *context = new GHOST_ContextVK(context_params_offscreen, GHOST_kVulkanPlatformHeadless, @@ -135,7 +135,7 @@ class GHOST_SystemHeadless : public GHOST_System { nullptr, 1, 2, - gpuSettings.preferred_device); + gpu_settings.preferred_device); # endif if (context->initializeDrawingContext()) { return context; @@ -203,20 +203,21 @@ class GHOST_SystemHeadless : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool /*exclusive*/, const bool /*is_dialog*/, - const GHOST_IWindow *parentWindow) override + const GHOST_IWindow *parent_window) override { - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS( + gpu_settings); return new GHOST_WindowNULL(title, left, top, width, height, state, - parentWindow, - gpuSettings.context_type, + parent_window, + gpu_settings.context_type, context_params); } diff --git a/intern/ghost/intern/GHOST_SystemSDL.cc b/intern/ghost/intern/GHOST_SystemSDL.cc index 1469cdcb6aa..61ef6022322 100644 --- a/intern/ghost/intern/GHOST_SystemSDL.cc +++ b/intern/ghost/intern/GHOST_SystemSDL.cc @@ -44,14 +44,14 @@ GHOST_IWindow *GHOST_SystemSDL::createWindow(const char *title, uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive, const bool /*is_dialog*/, - const GHOST_IWindow *parentWindow) + const GHOST_IWindow *parent_window) { GHOST_WindowSDL *window = nullptr; - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings); window = new GHOST_WindowSDL(this, title, @@ -60,10 +60,10 @@ GHOST_IWindow *GHOST_SystemSDL::createWindow(const char *title, width, height, state, - gpuSettings.context_type, + gpu_settings.context_type, context_params, exclusive, - parentWindow); + parent_window); if (window) { if (GHOST_kWindowStateFullScreen == state) { @@ -78,7 +78,7 @@ GHOST_IWindow *GHOST_SystemSDL::createWindow(const char *title, } if (window->getValid()) { - m_windowManager->addWindow(window); + window_manager_->addWindow(window); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window)); } else { @@ -131,12 +131,12 @@ uint8_t GHOST_SystemSDL::getNumDisplays() const return SDL_GetNumVideoDisplays(); } -GHOST_IContext *GHOST_SystemSDL::createOffscreenContext(GHOST_GPUSettings gpuSettings) +GHOST_IContext *GHOST_SystemSDL::createOffscreenContext(GHOST_GPUSettings gpu_settings) { const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_OPENGL_BACKEND case GHOST_kDrawingContextTypeOpenGL: { for (int minor = 6; minor >= 3; --minor) { @@ -495,7 +495,7 @@ void GHOST_SystemSDL::processEvent(SDL_Event *sdl_event) case SDL_QUIT: { const SDL_QuitEvent &sdl_sub_evt = sdl_event->quit; const uint64_t event_ms = sdl_sub_evt.timestamp; - GHOST_IWindow *window = m_windowManager->getActiveWindow(); + GHOST_IWindow *window = window_manager_->getActiveWindow(); g_event = new GHOST_Event(event_ms, GHOST_kEventQuitRequest, window); break; } @@ -534,12 +534,12 @@ void GHOST_SystemSDL::processEvent(SDL_Event *sdl_event) /* Can't use #setCursorPosition because the mouse may have no focus! */ if (x_new != x_root || y_new != y_root) { - if (1 /* `xme.time > m_last_warp` */) { + if (1 /* `xme.time > last_warp_` */) { /* when wrapping we don't need to add an event because the * #setCursorPosition call will cause a new event after */ SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win); /* wrap */ window->setCursorGrabAccum(x_accum + (x_root - x_new), y_accum + (y_root - y_new)); - // m_last_warp = lastEventTime(xme.time); + // last_warp_ = lastEventTime(xme.time); } else { // setCursorPosition(x_new, y_new); /* wrap but don't accumulate */ @@ -677,8 +677,8 @@ GHOST_TSuccess GHOST_SystemSDL::setCursorPosition(int32_t x, int32_t y) bool GHOST_SystemSDL::generateWindowExposeEvents() { - std::vector::iterator w_start = m_dirty_windows.begin(); - std::vector::const_iterator w_end = m_dirty_windows.end(); + std::vector::iterator w_start = dirty_windows_.begin(); + std::vector::const_iterator w_end = dirty_windows_.end(); bool anyProcessed = false; for (; w_start != w_end; ++w_start) { @@ -695,7 +695,7 @@ bool GHOST_SystemSDL::generateWindowExposeEvents() } } - m_dirty_windows.clear(); + dirty_windows_.clear(); return anyProcessed; } @@ -709,19 +709,19 @@ bool GHOST_SystemSDL::processEvents(bool waitForEvent) do { GHOST_TimerManager *timerMgr = getTimerManager(); - if (waitForEvent && m_dirty_windows.empty() && !SDL_HasEvents(SDL_FIRSTEVENT, SDL_LASTEVENT)) { + if (waitForEvent && dirty_windows_.empty() && !SDL_HasEvents(SDL_FIRSTEVENT, SDL_LASTEVENT)) { uint64_t next = timerMgr->nextFireTime(); if (next == GHOST_kFireTimeNever) { SDL_WaitEventTimeout(nullptr, -1); - // SleepTillEvent(m_display, -1); + // SleepTillEvent(display_, -1); } else { int64_t maxSleep = next - getMilliSeconds(); if (maxSleep >= 0) { SDL_WaitEventTimeout(nullptr, next - getMilliSeconds()); - // SleepTillEvent(m_display, next - getMilliSeconds()); /* X11. */ + // SleepTillEvent(display_, next - getMilliSeconds()); /* X11. */ } } } @@ -754,7 +754,7 @@ GHOST_WindowSDL *GHOST_SystemSDL::findGhostWindow(SDL_Window *sdl_win) * We should always check the window manager's list of windows * and only process events on these windows. */ - const std::vector &win_vec = m_windowManager->getWindows(); + const std::vector &win_vec = window_manager_->getWindows(); std::vector::const_iterator win_it = win_vec.begin(); std::vector::const_iterator win_end = win_vec.end(); @@ -772,7 +772,7 @@ void GHOST_SystemSDL::addDirtyWindow(GHOST_WindowSDL *bad_wind) { GHOST_ASSERT((bad_wind != nullptr), "addDirtyWindow() nullptr ptr trapped (window)"); - m_dirty_windows.push_back(bad_wind); + dirty_windows_.push_back(bad_wind); } GHOST_TSuccess GHOST_SystemSDL::getButtons(GHOST_Buttons &buttons) const diff --git a/intern/ghost/intern/GHOST_SystemSDL.hh b/intern/ghost/intern/GHOST_SystemSDL.hh index baebf610a0b..9f97ff9bedd 100644 --- a/intern/ghost/intern/GHOST_SystemSDL.hh +++ b/intern/ghost/intern/GHOST_SystemSDL.hh @@ -61,7 +61,7 @@ class GHOST_SystemSDL : public GHOST_System { void getMainDisplayDimensions(uint32_t &width, uint32_t &height) const override; - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override; GHOST_TSuccess disposeContext(GHOST_IContext *context) override; @@ -74,10 +74,10 @@ class GHOST_SystemSDL : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive = false, const bool is_dialog = false, - const GHOST_IWindow *parentWindow = nullptr) override; + const GHOST_IWindow *parent_window = nullptr) override; /* SDL specific */ GHOST_WindowSDL *findGhostWindow(SDL_Window *sdl_win); @@ -87,5 +87,5 @@ class GHOST_SystemSDL : public GHOST_System { void processEvent(SDL_Event *sdl_event); /** The vector of windows that need to be updated. */ - std::vector m_dirty_windows; + std::vector dirty_windows_; }; diff --git a/intern/ghost/intern/GHOST_SystemWayland.cc b/intern/ghost/intern/GHOST_SystemWayland.cc index 07e489456ce..0969a20a3e2 100644 --- a/intern/ghost/intern/GHOST_SystemWayland.cc +++ b/intern/ghost/intern/GHOST_SystemWayland.cc @@ -3175,12 +3175,12 @@ static void relative_pointer_handle_relative_motion_impl(GWL_Seat *seat, GHOST_Rect bounds; win->getClientBounds(bounds); /* Needed or the cursor is considered outside the window and doesn't restore the location. */ - bounds.m_r -= 1; - bounds.m_b -= 1; - bounds.m_l = win->wl_fixed_from_window(wl_fixed_from_int(bounds.m_l)); - bounds.m_t = win->wl_fixed_from_window(wl_fixed_from_int(bounds.m_t)); - bounds.m_r = win->wl_fixed_from_window(wl_fixed_from_int(bounds.m_r)); - bounds.m_b = win->wl_fixed_from_window(wl_fixed_from_int(bounds.m_b)); + bounds.r_ -= 1; + bounds.b_ -= 1; + bounds.l_ = win->wl_fixed_from_window(wl_fixed_from_int(bounds.l_)); + bounds.t_ = win->wl_fixed_from_window(wl_fixed_from_int(bounds.t_)); + bounds.r_ = win->wl_fixed_from_window(wl_fixed_from_int(bounds.r_)); + bounds.b_ = win->wl_fixed_from_window(wl_fixed_from_int(bounds.b_)); bounds.clampPoint(UNPACK2(seat->pointer.xy)); } #endif @@ -5945,7 +5945,7 @@ class GHOST_EventIME : public GHOST_Event { /* Make sure that we keep a copy of the IME input. Otherwise it might get lost * because we overwrite it before it can be read in Blender. (See #137346). */ this->event_ime_data = *customdata; - this->m_data = &this->event_ime_data; + this->data_ = &this->event_ime_data; } }; @@ -7744,7 +7744,7 @@ GHOST_TSuccess GHOST_SystemWayland::init() if (success) { #ifdef WITH_INPUT_NDOF - m_ndofManager = new GHOST_NDOFManagerUnix(*this); + ndof_manager_ = new GHOST_NDOFManagerUnix(*this); #endif return GHOST_kSuccess; } @@ -7815,7 +7815,7 @@ bool GHOST_SystemWayland::processEvents(bool waitForEvent) } #ifdef WITH_INPUT_NDOF - if (static_cast(m_ndofManager)->processEvents()) { + if (static_cast(ndof_manager_)->processEvents()) { /* As NDOF bypasses WAYLAND event handling, * never wait for an event when an NDOF event was found. */ waitForEvent = false; @@ -8403,10 +8403,10 @@ static GHOST_TSuccess getCursorPositionClientRelative_impl( GHOST_Rect wrap_bounds_scale; - wrap_bounds_scale.m_l = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.m_l)); - wrap_bounds_scale.m_t = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.m_t)); - wrap_bounds_scale.m_r = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.m_r)); - wrap_bounds_scale.m_b = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.m_b)); + wrap_bounds_scale.l_ = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.l_)); + wrap_bounds_scale.t_ = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.t_)); + wrap_bounds_scale.r_ = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.r_)); + wrap_bounds_scale.b_ = win->wl_fixed_from_window(wl_fixed_from_int(wrap_bounds.b_)); wrap_bounds_scale.wrapPoint(UNPACK2(xy_wrap), 0, win->getCursorGrabAxis()); x = wl_fixed_to_int(win->wl_fixed_to_window(xy_wrap[0])); @@ -8578,16 +8578,16 @@ void GHOST_SystemWayland::getAllDisplayDimensions(uint32_t &width, uint32_t &hei } } -GHOST_IContext *GHOST_SystemWayland::createOffscreenContext(GHOST_GPUSettings gpuSettings) +GHOST_IContext *GHOST_SystemWayland::createOffscreenContext(GHOST_GPUSettings gpu_settings) { #ifdef USE_EVENT_BACKGROUND_THREAD std::lock_guard lock_server_guard{*server_mutex}; #endif const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { @@ -8603,7 +8603,7 @@ GHOST_IContext *GHOST_SystemWayland::createOffscreenContext(GHOST_GPUSettings gp nullptr, 1, 2, - gpuSettings.preferred_device); + gpu_settings.preferred_device); if (context->initializeDrawingContext()) { context->setUserData(wl_surface); @@ -8712,12 +8712,12 @@ GHOST_IWindow *GHOST_SystemWayland::createWindow(const char *title, const uint32_t width, const uint32_t height, const GHOST_TWindowState state, - const GHOST_GPUSettings gpuSettings, + const GHOST_GPUSettings gpu_settings, const bool exclusive, const bool is_dialog, - const GHOST_IWindow *parentWindow) + const GHOST_IWindow *parent_window) { - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings); /* Globally store pointer to window manager. */ GHOST_WindowWayland *window = new GHOST_WindowWayland(this, @@ -8727,17 +8727,17 @@ GHOST_IWindow *GHOST_SystemWayland::createWindow(const char *title, width, height, state, - parentWindow, - gpuSettings.context_type, + parent_window, + gpu_settings.context_type, is_dialog, context_params, exclusive, - gpuSettings.preferred_device); + gpu_settings.preferred_device); if (window) { if (window->getValid()) { - m_windowManager->addWindow(window); - m_windowManager->setActiveWindow(window); + window_manager_->addWindow(window); + window_manager_->setActiveWindow(window); const uint64_t event_ms = getMilliSeconds(); pushEvent(new GHOST_Event(event_ms, GHOST_kEventWindowSize, window)); } @@ -8826,7 +8826,7 @@ GHOST_TSuccess GHOST_SystemWayland::cursor_shape_set(const GHOST_TStandardCursor return GHOST_kSuccess; } -GHOST_TSuccess GHOST_SystemWayland::cursor_shape_check(const GHOST_TStandardCursor cursorShape) +GHOST_TSuccess GHOST_SystemWayland::cursor_shape_check(const GHOST_TStandardCursor cursor_shape) { /* No need to lock `server_mutex`. */ GWL_Seat *seat = gwl_display_seat_active_get(display_); @@ -8839,7 +8839,7 @@ GHOST_TSuccess GHOST_SystemWayland::cursor_shape_check(const GHOST_TStandardCurs } const std::optional wl_shape = - gwl_seat_cursor_find_wl_shape_from_ghost(cursorShape); + gwl_seat_cursor_find_wl_shape_from_ghost(cursor_shape); if (wl_shape == std::nullopt) { return GHOST_kFailure; } @@ -9156,10 +9156,10 @@ static GWL_SeatStateGrab seat_grab_state_from_mode(const GHOST_TGrabCursorMode m void GHOST_SystemWayland::setMultitouchGestures(const bool use) { - if (m_multitouchGestures == use) { + if (multitouch_gestures_ == use) { return; } - m_multitouchGestures = use; + multitouch_gestures_ = use; #ifdef USE_EVENT_BACKGROUND_THREAD /* Ensure this listeners aren't removed while events are generated. */ @@ -9708,14 +9708,14 @@ bool GHOST_SystemWayland::window_cursor_grab_set(const GHOST_TGrabCursorMode mod GHOST_Rect bounds_scale; - bounds_scale.m_l = gwl_window_scale_wl_fixed_from(scale_params, - wl_fixed_from_int(wrap_bounds->m_l)); - bounds_scale.m_t = gwl_window_scale_wl_fixed_from(scale_params, - wl_fixed_from_int(wrap_bounds->m_t)); - bounds_scale.m_r = gwl_window_scale_wl_fixed_from(scale_params, - wl_fixed_from_int(wrap_bounds->m_r)); - bounds_scale.m_b = gwl_window_scale_wl_fixed_from(scale_params, - wl_fixed_from_int(wrap_bounds->m_b)); + bounds_scale.l_ = gwl_window_scale_wl_fixed_from(scale_params, + wl_fixed_from_int(wrap_bounds->l_)); + bounds_scale.t_ = gwl_window_scale_wl_fixed_from(scale_params, + wl_fixed_from_int(wrap_bounds->t_)); + bounds_scale.r_ = gwl_window_scale_wl_fixed_from(scale_params, + wl_fixed_from_int(wrap_bounds->r_)); + bounds_scale.b_ = gwl_window_scale_wl_fixed_from(scale_params, + wl_fixed_from_int(wrap_bounds->b_)); bounds_scale.wrapPoint(UNPACK2(xy_next), 0, wrap_axis); diff --git a/intern/ghost/intern/GHOST_SystemWayland.hh b/intern/ghost/intern/GHOST_SystemWayland.hh index ce2cba7e3d4..ebe69078b12 100644 --- a/intern/ghost/intern/GHOST_SystemWayland.hh +++ b/intern/ghost/intern/GHOST_SystemWayland.hh @@ -208,7 +208,7 @@ class GHOST_SystemWayland : public GHOST_System { void getAllDisplayDimensions(uint32_t &width, uint32_t &height) const override; - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override; GHOST_TSuccess disposeContext(GHOST_IContext *context) override; @@ -218,10 +218,10 @@ class GHOST_SystemWayland : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive, const bool is_dialog, - const GHOST_IWindow *parentWindow) override; + const GHOST_IWindow *parent_window) override; GHOST_TCapabilityFlag getCapabilities() const override; @@ -231,7 +231,7 @@ class GHOST_SystemWayland : public GHOST_System { GHOST_TSuccess cursor_shape_set(GHOST_TStandardCursor shape); - GHOST_TSuccess cursor_shape_check(GHOST_TStandardCursor cursorShape); + GHOST_TSuccess cursor_shape_check(GHOST_TStandardCursor cursor_shape); GHOST_TSuccess cursor_shape_custom_set(const GHOST_CursorGenerator &cg); diff --git a/intern/ghost/intern/GHOST_SystemWin32.cc b/intern/ghost/intern/GHOST_SystemWin32.cc index f20e6e27474..59e39d03efe 100644 --- a/intern/ghost/intern/GHOST_SystemWin32.cc +++ b/intern/ghost/intern/GHOST_SystemWin32.cc @@ -162,9 +162,9 @@ static void initRawInput() typedef BOOL(API *GHOST_WIN32_EnableNonClientDpiScaling)(HWND); -GHOST_SystemWin32::GHOST_SystemWin32() : m_hasPerformanceCounter(false), m_freq(0) +GHOST_SystemWin32::GHOST_SystemWin32() : has_performance_counter_(false), freq_(0) { - m_consoleStatus = true; + console_status_ = true; /* Tell Windows we are per monitor DPI aware. This disables the default * blurry scaling and enables WM_DPICHANGED to allow us to draw at proper DPI. */ @@ -183,7 +183,7 @@ GHOST_SystemWin32::GHOST_SystemWin32() : m_hasPerformanceCounter(false), m_freq( OleInitialize(0); #ifdef WITH_INPUT_NDOF - m_ndofManager = new GHOST_NDOFManagerWin32(*this); + ndof_manager_ = new GHOST_NDOFManagerWin32(*this); #endif } @@ -206,14 +206,14 @@ uint64_t GHOST_SystemWin32::performanceCounterToMillis(__int64 perf_ticks) const /* Calculate the time passed since system initialization. */ __int64 delta = perf_ticks * 1000; - uint64_t t = uint64_t(delta / m_freq); + uint64_t t = uint64_t(delta / freq_); return t; } uint64_t GHOST_SystemWin32::getMilliSeconds() const { /* Hardware does not support high resolution timers. We will use GetTickCount instead then. */ - if (!m_hasPerformanceCounter) { + if (!has_performance_counter_) { return ::GetTickCount64(); } @@ -266,12 +266,12 @@ GHOST_IWindow *GHOST_SystemWin32::createWindow(const char *title, uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool /*exclusive*/, const bool is_dialog, - const GHOST_IWindow *parentWindow) + const GHOST_IWindow *parent_window) { - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings); GHOST_WindowWin32 *window = new GHOST_WindowWin32(this, title, left, @@ -279,16 +279,16 @@ GHOST_IWindow *GHOST_SystemWin32::createWindow(const char *title, width, height, state, - gpuSettings.context_type, + gpu_settings.context_type, context_params, - (GHOST_WindowWin32 *)parentWindow, + (GHOST_WindowWin32 *)parent_window, is_dialog, - gpuSettings.preferred_device); + gpu_settings.preferred_device); if (window->getValid()) { /* Store the pointer to the window */ - m_windowManager->addWindow(window); - m_windowManager->setActiveWindow(window); + window_manager_->addWindow(window); + window_manager_->setActiveWindow(window); } else { GHOST_PRINT("GHOST_SystemWin32::createWindow(): window invalid\n"); @@ -304,16 +304,16 @@ GHOST_IWindow *GHOST_SystemWin32::createWindow(const char *title, * Never explicitly delete the window, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ -GHOST_IContext *GHOST_SystemWin32::createOffscreenContext(GHOST_GPUSettings gpuSettings) +GHOST_IContext *GHOST_SystemWin32::createOffscreenContext(GHOST_GPUSettings gpu_settings) { const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { GHOST_Context *context = new GHOST_ContextVK( - context_params_offscreen, (HWND)0, 1, 2, gpuSettings.preferred_device); + context_params_offscreen, (HWND)0, 1, 2, gpu_settings.preferred_device); if (context->initializeDrawingContext()) { return context; } @@ -389,7 +389,7 @@ GHOST_TSuccess GHOST_SystemWin32::disposeContext(GHOST_IContext *context) */ GHOST_ContextD3D *GHOST_SystemWin32::createOffscreenContextD3D() { - /* NOTE: the `gpuSettings` could be passed in here, as it is with similar functions. */ + /* NOTE: the `gpu_settings` could be passed in here, as it is with similar functions. */ const GHOST_ContextParams context_params_offscreen = GHOST_CONTEXT_PARAMS_NONE; HWND wnd = CreateWindowA("STATIC", "Blender XR", @@ -464,7 +464,7 @@ bool GHOST_SystemWin32::processEvents(bool waitForEvent) /* `PeekMessage` above is allowed to dispatch messages to the `wndproc` without us * noticing, so we need to check the event manager here to see if there are * events waiting in the queue. */ - hasEventHandled |= this->m_eventManager->getNumEvents() > 0; + hasEventHandled |= this->event_manager_->getNumEvents() > 0; } while (waitForEvent && !hasEventHandled); @@ -563,7 +563,7 @@ GHOST_IWindow *GHOST_SystemWin32::getWindowUnderCursor(int32_t /*x*/, int32_t /* return nullptr; } - return m_windowManager->getWindowAssociatedWithOSWindow((const void *)win); + return window_manager_->getWindowAssociatedWithOSWindow((const void *)win); } GHOST_TSuccess GHOST_SystemWin32::getModifierKeys(GHOST_ModifierKeys &keys) const @@ -637,7 +637,7 @@ GHOST_TSuccess GHOST_SystemWin32::init() initRawInput(); /* Determine whether this system has a high frequency performance counter. */ - m_hasPerformanceCounter = ::QueryPerformanceFrequency((LARGE_INTEGER *)&m_freq) == TRUE; + has_performance_counter_ = ::QueryPerformanceFrequency((LARGE_INTEGER *)&freq_) == TRUE; if (success) { WNDCLASSW wc = {0}; @@ -723,7 +723,7 @@ GHOST_TKey GHOST_SystemWin32::processSpecialKey(short vKey, short /*scanCode*/) key = GHOST_kKeyQuote; } else if (vKey == VK_OEM_8) { - if (PRIMARYLANGID(m_langId) == LANG_FRENCH) { + if (PRIMARYLANGID(lang_id_) == LANG_FRENCH) { /* OEM key; used purely for shortcuts. */ key = GHOST_kKeyF13; } @@ -1269,7 +1269,7 @@ void GHOST_SystemWin32::processWheelEventVertical(GHOST_WindowWin32 *window, { GHOST_SystemWin32 *system = (GHOST_SystemWin32 *)getSystem(); - int acc = system->m_wheelDeltaAccumVertical; + int acc = system->wheel_delta_accum_vertical_; int delta = GET_WHEEL_DELTA_WPARAM(wParam); if (acc * delta < 0) { @@ -1285,7 +1285,7 @@ void GHOST_SystemWin32::processWheelEventVertical(GHOST_WindowWin32 *window, getMessageTime(system), window, GHOST_kEventWheelAxisVertical, direction)); acc -= WHEEL_DELTA; } - system->m_wheelDeltaAccumVertical = acc * direction; + system->wheel_delta_accum_vertical_ = acc * direction; } /** This is almost the same as #processWheelEventVertical. */ @@ -1295,7 +1295,7 @@ void GHOST_SystemWin32::processWheelEventHorizontal(GHOST_WindowWin32 *window, { GHOST_SystemWin32 *system = (GHOST_SystemWin32 *)getSystem(); - int acc = system->m_wheelDeltaAccumHorizontal; + int acc = system->wheel_delta_accum_horizontal_; int delta = GET_WHEEL_DELTA_WPARAM(wParam); if (acc * delta < 0) { @@ -1311,7 +1311,7 @@ void GHOST_SystemWin32::processWheelEventHorizontal(GHOST_WindowWin32 *window, getMessageTime(system), window, GHOST_kEventWheelAxisHorizontal, direction)); acc -= WHEEL_DELTA; } - system->m_wheelDeltaAccumHorizontal = acc * direction; + system->wheel_delta_accum_horizontal_ = acc * direction; } GHOST_EventKey *GHOST_SystemWin32::processKeyEvent(GHOST_WindowWin32 *window, RAWINPUT const &raw) @@ -1329,7 +1329,7 @@ GHOST_EventKey *GHOST_SystemWin32::processKeyEvent(GHOST_WindowWin32 *window, RA /* If the keyboard layout includes AltGr and the virtual key is Control, yet the * scan-code is actually for Right Alt (ALTGR_MAKE_CODE scan code with E0 prefix). * Ignore these, so treating AltGR as regular Alt. #68256 */ - if (system->m_hasAltGr && vk == VK_CONTROL && raw.data.keyboard.MakeCode == ALTGR_MAKE_CODE && + if (system->has_alt_gr_ && vk == VK_CONTROL && raw.data.keyboard.MakeCode == ALTGR_MAKE_CODE && (raw.data.keyboard.Flags & RI_KEY_E0)) { return nullptr; @@ -1380,7 +1380,7 @@ GHOST_EventKey *GHOST_SystemWin32::processKeyEvent(GHOST_WindowWin32 *window, RA /* TODO: #ToUnicodeEx can respond with up to 4 UTF16 chars (only 2 here). * Could be up to 24 UTF8 bytes. */ if ((r = ToUnicodeEx( - vk, raw.data.keyboard.MakeCode, state, utf16, 2, 0, system->m_keylayout))) + vk, raw.data.keyboard.MakeCode, state, utf16, 2, 0, system->keylayout_))) { if ((r > 0 && r < 3)) { utf16[r] = 0; @@ -1429,7 +1429,7 @@ GHOST_Event *GHOST_SystemWin32::processWindowSizeEvent(GHOST_WindowWin32 *window GHOST_Event *sizeEvent = new GHOST_Event(getMessageTime(system), GHOST_kEventWindowSize, window); /* We get WM_SIZE before we fully init. Do not dispatch before we are continuously resizing. */ - if (window->m_inLiveResize) { + if (window->in_live_resize_) { system->pushEvent(sizeEvent); system->dispatchEvents(); return nullptr; @@ -1524,7 +1524,7 @@ bool GHOST_SystemWin32::processNDOF(RAWINPUT const &raw) GetRawInputDeviceInfo(raw.header.hDevice, RIDI_DEVICEINFO, &info, &infoSize); /* Since there can be multiple NDOF devices connected, always set the current device. */ if (info.dwType == RIM_TYPEHID) { - m_ndofManager->setDevice(info.hid.dwVendorId, info.hid.dwProductId); + ndof_manager_->setDevice(info.hid.dwVendorId, info.hid.dwProductId); } else { GHOST_PRINT(" not a HID device... mouse/kb perhaps?\n"); @@ -1542,12 +1542,12 @@ bool GHOST_SystemWin32::processNDOF(RAWINPUT const &raw) const short *axis = (short *)(data + 1); /* Massage into blender view coords (same goes for rotation). */ const int t[3] = {axis[0], -axis[2], axis[1]}; - m_ndofManager->updateTranslation(t, now); + ndof_manager_->updateTranslation(t, now); if (raw.data.hid.dwSizeHid == 13) { /* This report also includes rotation. */ const int r[3] = {-axis[3], axis[5], -axis[4]}; - m_ndofManager->updateRotation(r, now); + ndof_manager_->updateRotation(r, now); /* I've never gotten one of these, has anyone else? */ GHOST_PRINT("ndof: combined T + R\n"); @@ -1558,13 +1558,13 @@ bool GHOST_SystemWin32::processNDOF(RAWINPUT const &raw) const short *axis = (short *)(data + 1); const int r[3] = {-axis[0], axis[2], -axis[1]}; - m_ndofManager->updateRotation(r, now); + ndof_manager_->updateRotation(r, now); break; } case 0x3: { /* Buttons bitmask (older devices). */ int button_bits; memcpy(&button_bits, data + 1, sizeof(button_bits)); - m_ndofManager->updateButtonsBitmask(button_bits, now); + ndof_manager_->updateButtonsBitmask(button_bits, now); break; } case 0x1c: { /* Buttons numbers (newer devices). */ @@ -1573,7 +1573,7 @@ bool GHOST_SystemWin32::processNDOF(RAWINPUT const &raw) for (int i = 0; i < buttons.size(); i++) { buttons[i] = static_cast(*(payload + i)); } - m_ndofManager->updateButtonsArray(buttons, now, NDOF_Button_Type::ShortButton); + ndof_manager_->updateButtonsArray(buttons, now, NDOF_Button_Type::ShortButton); break; } case 0x1d: { /* Buttons (long press, newer devices). */ @@ -1582,7 +1582,7 @@ bool GHOST_SystemWin32::processNDOF(RAWINPUT const &raw) for (int i = 0; i < buttons.size(); i++) { buttons[i] = translateLongButtonToNDOFButton(*(payload + i)); } - m_ndofManager->updateButtonsArray(buttons, now, NDOF_Button_Type::LongButton); + ndof_manager_->updateButtonsArray(buttons, now, NDOF_Button_Type::LongButton); break; } } @@ -1653,10 +1653,10 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, if (msg == WM_NCCREATE) { /* Tell Windows to automatically handle scaling of non-client areas * such as the caption bar. #EnableNonClientDpiScaling was introduced in Windows 10. */ - HMODULE m_user32 = ::LoadLibrary("User32.dll"); - if (m_user32) { + HMODULE user32_ = ::LoadLibrary("User32.dll"); + if (user32_) { GHOST_WIN32_EnableNonClientDpiScaling fpEnableNonClientDpiScaling = - (GHOST_WIN32_EnableNonClientDpiScaling)::GetProcAddress(m_user32, + (GHOST_WIN32_EnableNonClientDpiScaling)::GetProcAddress(user32_, "EnableNonClientDpiScaling"); if (fpEnableNonClientDpiScaling) { fpEnableNonClientDpiScaling(hwnd); @@ -1997,19 +1997,19 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, break; } case WM_MOUSEMOVE: { - if (!window->m_mousePresent) { + if (!window->mouse_present_) { WINTAB_PRINTF("HWND %p mouse enter\n", window->getHWND()); TRACKMOUSEEVENT tme = {sizeof(tme)}; /* Request WM_MOUSELEAVE message when the cursor leaves the client area. */ tme.dwFlags = TME_LEAVE; - if (system->m_autoFocus) { + if (system->auto_focus_) { /* Request WM_MOUSEHOVER message after 100ms when in the client area. */ tme.dwFlags |= TME_HOVER; tme.dwHoverTime = 100; } tme.hwndTrack = hwnd; TrackMouseEvent(&tme); - window->m_mousePresent = true; + window->mouse_present_ = true; GHOST_Wintab *wt = window->getWintab(); if (wt) { wt->gainFocus(); @@ -2025,7 +2025,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, } case WM_MOUSEHOVER: { /* Mouse Tracking is now off. TrackMouseEvent restarts in MouseMove. */ - window->m_mousePresent = false; + window->mouse_present_ = false; /* Auto-focus only occurs within Blender windows, not with _other_ applications. We are * notified of change of focus from our console, but it returns null from GetFocus. */ @@ -2100,7 +2100,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, } case WM_MOUSELEAVE: { WINTAB_PRINTF("HWND %p mouse leave\n", window->getHWND()); - window->m_mousePresent = false; + window->mouse_present_ = false; if (window->getTabletData().Active == GHOST_kTabletModeNone) { /* FIXME: document why the cursor motion event on mouse leave is needed. */ int32_t screen_co[2] = {0, 0}; @@ -2150,8 +2150,8 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, * If the windows use different input queues, the message is sent asynchronously, * so the window is activated immediately. */ - system->m_wheelDeltaAccumVertical = 0; - system->m_wheelDeltaAccumHorizontal = 0; + system->wheel_delta_accum_vertical_ = 0; + system->wheel_delta_accum_horizontal_ = 0; event = processWindowEvent( LOWORD(wParam) ? GHOST_kEventWindowActivate : GHOST_kEventWindowDeactivate, window); /* WARNING: Let DefWindowProc handle WM_ACTIVATE, otherwise WM_MOUSEWHEEL @@ -2171,11 +2171,11 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, * message specifies the SC_MOVE or SC_SIZE value. The operation is complete when * DefWindowProc returns. */ - window->m_inLiveResize = 1; + window->in_live_resize_ = 1; break; } case WM_EXITSIZEMOVE: { - window->m_inLiveResize = 0; + window->in_live_resize_ = 0; break; } case WM_PAINT: { @@ -2185,7 +2185,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, * function when the application obtains a WM_PAINT message by using the GetMessage or * PeekMessage function. */ - if (!window->m_inLiveResize) { + if (!window->in_live_resize_) { event = processWindowEvent(GHOST_kEventWindowUpdate, window); ::ValidateRect(hwnd, nullptr); } @@ -2234,7 +2234,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, * message without calling DefWindowProc. */ /* See #WM_SIZE comment. */ - if (window->m_inLiveResize) { + if (window->in_live_resize_) { system->pushEvent(processWindowEvent(GHOST_kEventWindowMove, window)); system->dispatchEvents(); } @@ -2380,7 +2380,7 @@ LRESULT WINAPI GHOST_SystemWin32::s_wndProc(HWND hwnd, uint msg, WPARAM wParam, /* The DM_POINTERHITTEST message is sent to a window, when pointer input is first * detected, in order to determine the most probable input target for Direct * Manipulation. */ - if (system->m_multitouchGestures) { + if (system->multitouch_gestures_) { window->onPointerHitTest(wParam); } break; @@ -2950,13 +2950,13 @@ bool GHOST_SystemWin32::setConsoleWindowState(GHOST_TConsoleWindowState action) case GHOST_kConsoleWindowStateHideForNonConsoleLaunch: { if (!isStartedFromCommandPrompt()) { ShowWindow(wnd, SW_HIDE); - m_consoleStatus = false; + console_status_ = false; } break; } case GHOST_kConsoleWindowStateHide: { ShowWindow(wnd, SW_HIDE); - m_consoleStatus = false; + console_status_ = false; break; } case GHOST_kConsoleWindowStateShow: { @@ -2964,18 +2964,18 @@ bool GHOST_SystemWin32::setConsoleWindowState(GHOST_TConsoleWindowState action) if (!isStartedFromCommandPrompt()) { DeleteMenu(GetSystemMenu(wnd, FALSE), SC_CLOSE, MF_BYCOMMAND); } - m_consoleStatus = true; + console_status_ = true; break; } case GHOST_kConsoleWindowStateToggle: { - ShowWindow(wnd, m_consoleStatus ? SW_HIDE : SW_SHOW); - m_consoleStatus = !m_consoleStatus; - if (m_consoleStatus && !isStartedFromCommandPrompt()) { + ShowWindow(wnd, console_status_ ? SW_HIDE : SW_SHOW); + console_status_ = !console_status_; + if (console_status_ && !isStartedFromCommandPrompt()) { DeleteMenu(GetSystemMenu(wnd, FALSE), SC_CLOSE, MF_BYCOMMAND); } break; } } - return m_consoleStatus; + return console_status_; } diff --git a/intern/ghost/intern/GHOST_SystemWin32.hh b/intern/ghost/intern/GHOST_SystemWin32.hh index b513c2b4f78..871b226ca4e 100644 --- a/intern/ghost/intern/GHOST_SystemWin32.hh +++ b/intern/ghost/intern/GHOST_SystemWin32.hh @@ -101,9 +101,9 @@ class GHOST_SystemWin32 : public GHOST_System { * \param width: The width the window. * \param height: The height the window. * \param state: The state of the window when opened. - * \param gpuSettings: Misc GPU settings. + * \param gpu_settings: Misc GPU settings. * \param exclusive: Use to show the window on top and ignore others (used full-screen). - * \param parentWindow: Parent window. + * \param parent_window: Parent window. * \return The new window (or 0 if creation failed). */ GHOST_IWindow *createWindow(const char *title, @@ -112,17 +112,17 @@ class GHOST_SystemWin32 : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive = false, const bool is_dialog = false, - const GHOST_IWindow *parentWindow = nullptr) override; + const GHOST_IWindow *parent_window = nullptr) override; /** * Create a new off-screen context. * Never explicitly delete the window, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override; /** * Dispose of a context. @@ -387,7 +387,7 @@ class GHOST_SystemWin32 : public GHOST_System { static void processWheelEventHorizontal(GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam); /** - * Creates a key event and updates the key data stored locally (m_modifierKeys). + * Creates a key event and updates the key data stored locally (modifier_keys_). * In most cases this is a straightforward conversion of key codes. * For the modifier keys however, we want to distinguish left and right keys. * \param window: The window receiving the event (the active window). @@ -476,40 +476,40 @@ class GHOST_SystemWin32 : public GHOST_System { bool setConsoleWindowState(GHOST_TConsoleWindowState action) override; /** State variable set at initialization. */ - bool m_hasPerformanceCounter; + bool has_performance_counter_; /** High frequency timer variable. */ - __int64 m_freq; + __int64 freq_; /** AltGr on current keyboard layout. */ - bool m_hasAltGr; + bool has_alt_gr_; /** Language identifier. */ - WORD m_langId; + WORD lang_id_; /** Stores keyboard layout. */ - HKL m_keylayout; + HKL keylayout_; /** Console status. */ - bool m_consoleStatus; + bool console_status_; /** Wheel delta accumulators. */ - int m_wheelDeltaAccumVertical; - int m_wheelDeltaAccumHorizontal; + int wheel_delta_accum_vertical_; + int wheel_delta_accum_horizontal_; }; inline void GHOST_SystemWin32::handleKeyboardChange() { - m_keylayout = GetKeyboardLayout(0); /* Get keylayout for current thread. */ + keylayout_ = GetKeyboardLayout(0); /* Get keylayout for current thread. */ int i; SHORT s; /* Save the language identifier. */ - m_langId = LOWORD(m_keylayout); + lang_id_ = LOWORD(keylayout_); - for (m_hasAltGr = false, i = 32; i < 256; ++i) { - s = VkKeyScanEx((char)i, m_keylayout); + for (has_alt_gr_ = false, i = 32; i < 256; ++i) { + s = VkKeyScanEx((char)i, keylayout_); /* `s == -1` means no key that translates passed char code high byte contains shift state. * bit 2 Control pressed, bit 4 `Alt` pressed if both are pressed, * we have `AltGr` key-combination on key-layout. */ if (s != -1 && (s & 0x600) == 0x600) { - m_hasAltGr = true; + has_alt_gr_ = true; break; } } diff --git a/intern/ghost/intern/GHOST_SystemX11.cc b/intern/ghost/intern/GHOST_SystemX11.cc index c108636f594..b742aff43c6 100644 --- a/intern/ghost/intern/GHOST_SystemX11.cc +++ b/intern/ghost/intern/GHOST_SystemX11.cc @@ -104,17 +104,17 @@ using namespace std; GHOST_SystemX11::GHOST_SystemX11() : GHOST_System(), - m_xkb_descr(nullptr), - m_keyboard_vector{0}, + xkb_descr_(nullptr), + keyboard_vector_{0}, #ifdef WITH_X11_XINPUT - m_last_key_time(0), + last_key_time_(0), #endif - m_keycode_last_repeat_key(uint(-1)) + keycode_last_repeat_key_(uint(-1)) { XInitThreads(); - m_display = XOpenDisplay(nullptr); + display_ = XOpenDisplay(nullptr); - if (!m_display) { + if (!display_) { throw std::runtime_error("unable to open a display!"); } @@ -127,17 +127,17 @@ GHOST_SystemX11::GHOST_SystemX11() /* NOTE: Don't open connection to XIM server here, because the locale has to be * set before opening the connection but `setlocale()` has not been called yet. * the connection will be opened after entering the event loop. */ - m_xim = nullptr; + xim_ = nullptr; #endif #define GHOST_INTERN_ATOM_IF_EXISTS(atom) \ { \ - m_atom.atom = XInternAtom(m_display, #atom, True); \ + atom_.atom = XInternAtom(display_, #atom, True); \ } \ (void)0 #define GHOST_INTERN_ATOM(atom) \ { \ - m_atom.atom = XInternAtom(m_display, #atom, False); \ + atom_.atom = XInternAtom(display_, #atom, False); \ } \ (void)0 @@ -162,16 +162,16 @@ GHOST_SystemX11::GHOST_SystemX11() GHOST_INTERN_ATOM(INCR); GHOST_INTERN_ATOM(UTF8_STRING); #ifdef WITH_X11_XINPUT - m_atom.TABLET = XInternAtom(m_display, XI_TABLET, False); + atom_.TABLET = XInternAtom(display_, XI_TABLET, False); #endif #undef GHOST_INTERN_ATOM_IF_EXISTS #undef GHOST_INTERN_ATOM - m_last_warp_x = 0; - m_last_warp_y = 0; - m_last_release_keycode = 0; - m_last_release_time = 0; + last_warp_x_ = 0; + last_warp_y_ = 0; + last_release_keycode_ = 0; + last_release_time_ = 0; /* Use detectable auto-repeat, mac and windows also do this. */ int use_xkb; @@ -179,14 +179,14 @@ GHOST_SystemX11::GHOST_SystemX11() int xkb_major = XkbMajorVersion, xkb_minor = XkbMinorVersion; use_xkb = XkbQueryExtension( - m_display, &xkb_opcode, &xkb_event, &xkb_error, &xkb_major, &xkb_minor); + display_, &xkb_opcode, &xkb_event, &xkb_error, &xkb_major, &xkb_minor); if (use_xkb) { - XkbSetDetectableAutoRepeat(m_display, true, nullptr); + XkbSetDetectableAutoRepeat(display_, true, nullptr); - m_xkb_descr = XkbGetMap(m_display, 0, XkbUseCoreKbd); - if (m_xkb_descr) { - XkbGetNames(m_display, XkbKeyNamesMask, m_xkb_descr); - XkbGetControls(m_display, XkbPerKeyRepeatMask | XkbRepeatKeysMask, m_xkb_descr); + xkb_descr_ = XkbGetMap(display_, 0, XkbUseCoreKbd); + if (xkb_descr_) { + XkbGetNames(display_, XkbKeyNamesMask, xkb_descr_); + XkbGetControls(display_, XkbPerKeyRepeatMask | XkbRepeatKeysMask, xkb_descr_); } } @@ -197,23 +197,23 @@ GHOST_SystemX11::GHOST_SystemX11() #ifdef WITH_X11_XINPUT /* Detect if we have XINPUT (for reuse). */ { - memset(&m_xinput_version, 0, sizeof(m_xinput_version)); - XExtensionVersion *version = XGetExtensionVersion(m_display, INAME); + memset(&xinput_version_, 0, sizeof(xinput_version_)); + XExtensionVersion *version = XGetExtensionVersion(display_, INAME); if (version && (version != (XExtensionVersion *)NoSuchExtension)) { if (version->present) { - m_xinput_version = *version; + xinput_version_ = *version; } XFree(version); } } # ifdef USE_XINPUT_HOTPLUG - if (m_xinput_version.present) { + if (xinput_version_.present) { XEventClass class_presence; int xi_presence; - DevicePresence(m_display, xi_presence, class_presence); + DevicePresence(display_, xi_presence, class_presence); XSelectExtensionEvent( - m_display, RootWindow(m_display, DefaultScreen(m_display)), &class_presence, 1); + display_, RootWindow(display_, DefaultScreen(display_)), &class_presence, 1); (void)xi_presence; } # endif /* USE_XINPUT_HOTPLUG */ @@ -225,8 +225,8 @@ GHOST_SystemX11::GHOST_SystemX11() GHOST_SystemX11::~GHOST_SystemX11() { #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) - if (m_xim) { - XCloseIM(m_xim); + if (xim_) { + XCloseIM(xim_); } #endif @@ -235,11 +235,11 @@ GHOST_SystemX11::~GHOST_SystemX11() clearXInputDevices(); #endif /* WITH_X11_XINPUT */ - if (m_xkb_descr) { - XkbFreeKeyboard(m_xkb_descr, XkbAllComponentsMask, true); + if (xkb_descr_) { + XkbFreeKeyboard(xkb_descr_, XkbAllComponentsMask, true); } - XCloseDisplay(m_display); + XCloseDisplay(display_); } GHOST_TSuccess GHOST_SystemX11::init() @@ -248,7 +248,7 @@ GHOST_TSuccess GHOST_SystemX11::init() if (success) { #ifdef WITH_INPUT_NDOF - m_ndofManager = new GHOST_NDOFManagerUnix(*this); + ndof_manager_ = new GHOST_NDOFManagerUnix(*this); #endif return GHOST_kSuccess; } @@ -333,7 +333,7 @@ uint8_t GHOST_SystemX11::getNumDisplays() const void GHOST_SystemX11::getMainDisplayDimensions(uint32_t &width, uint32_t &height) const { - if (m_display) { + if (display_) { /* NOTE(@ideasman42): for this to work as documented, * we would need to use Xinerama check r54370 for code that did this, * we've since removed since its not worth the extra dependency. */ @@ -343,9 +343,9 @@ void GHOST_SystemX11::getMainDisplayDimensions(uint32_t &width, uint32_t &height void GHOST_SystemX11::getAllDisplayDimensions(uint32_t &width, uint32_t &height) const { - if (m_display) { - width = DisplayWidth(m_display, DefaultScreen(m_display)); - height = DisplayHeight(m_display, DefaultScreen(m_display)); + if (display_) { + width = DisplayWidth(display_, DefaultScreen(display_)); + height = DisplayHeight(display_, DefaultScreen(display_)); } } @@ -355,32 +355,32 @@ GHOST_IWindow *GHOST_SystemX11::createWindow(const char *title, uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive, const bool is_dialog, - const GHOST_IWindow *parentWindow) + const GHOST_IWindow *parent_window) { GHOST_WindowX11 *window = nullptr; - if (!m_display) { + if (!display_) { return nullptr; } - const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpuSettings); + const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings); window = new GHOST_WindowX11(this, - m_display, + display_, title, left, top, width, height, state, - (GHOST_WindowX11 *)parentWindow, - gpuSettings.context_type, + (GHOST_WindowX11 *)parent_window, + gpu_settings.context_type, is_dialog, context_params, exclusive, - gpuSettings.preferred_device); + gpu_settings.preferred_device); if (window) { /* Both are now handle in GHOST_WindowX11.cc @@ -388,8 +388,8 @@ GHOST_IWindow *GHOST_SystemX11::createWindow(const char *title, if (window->getValid()) { /* Store the pointer to the window */ - m_windowManager->addWindow(window); - m_windowManager->setActiveWindow(window); + window_manager_->addWindow(window); + window_manager_->setActiveWindow(window); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window)); } else { @@ -400,24 +400,24 @@ GHOST_IWindow *GHOST_SystemX11::createWindow(const char *title, return window; } -GHOST_IContext *GHOST_SystemX11::createOffscreenContext(GHOST_GPUSettings gpuSettings) +GHOST_IContext *GHOST_SystemX11::createOffscreenContext(GHOST_GPUSettings gpu_settings) { const GHOST_ContextParams context_params_offscreen = - GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpuSettings); + GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings); - switch (gpuSettings.context_type) { + switch (gpu_settings.context_type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { GHOST_Context *context = new GHOST_ContextVK(context_params_offscreen, GHOST_kVulkanPlatformX11, 0, - m_display, + display_, nullptr, nullptr, nullptr, 1, 2, - gpuSettings.preferred_device); + gpu_settings.preferred_device); if (context->initializeDrawingContext()) { return context; } @@ -432,7 +432,7 @@ GHOST_IContext *GHOST_SystemX11::createOffscreenContext(GHOST_GPUSettings gpuSet GHOST_Context *context = new GHOST_ContextGLX( context_params_offscreen, (Window) nullptr, - m_display, + display_, (GLXFBConfig) nullptr, GLX_CONTEXT_CORE_PROFILE_BIT_ARB, 4, @@ -474,22 +474,22 @@ static void destroyIMCallback(XIM /*xim*/, XPointer ptr, XPointer /*data*/) bool GHOST_SystemX11::openX11_IM() { - if (!m_display) { + if (!display_) { return false; } /* set locale modifiers such as `@im=ibus` specified by XMODIFIERS. */ XSetLocaleModifiers(""); - m_xim = XOpenIM(m_display, nullptr, (char *)GHOST_X11_RES_NAME, (char *)GHOST_X11_RES_CLASS); - if (!m_xim) { + xim_ = XOpenIM(display_, nullptr, (char *)GHOST_X11_RES_NAME, (char *)GHOST_X11_RES_CLASS); + if (!xim_) { return false; } XIMCallback destroy; destroy.callback = (XIMProc)destroyIMCallback; - destroy.client_data = (XPointer)&m_xim; - XSetIMValues(m_xim, XNDestroyCallback, &destroy, nullptr); + destroy.client_data = (XPointer)&xim_; + XSetIMValues(xim_, XNDestroyCallback, &destroy, nullptr); return true; } #endif @@ -506,7 +506,7 @@ GHOST_WindowX11 *GHOST_SystemX11::findGhostWindow(Window xwind) const * We should always check the window manager's list of windows * and only process events on these windows. */ - const vector &win_vec = m_windowManager->getWindows(); + const vector &win_vec = window_manager_->getWindows(); vector::const_iterator win_it = win_vec.begin(); vector::const_iterator win_end = win_vec.end(); @@ -583,7 +583,7 @@ Time GHOST_SystemX11::lastEventTime(Time default_time) init_timestamp_data data; data.timestamp = default_time; XEvent ev; - XCheckIfEvent(m_display, &ev, &init_timestamp_scanner, (XPointer)&data); + XCheckIfEvent(display_, &ev, &init_timestamp_scanner, (XPointer)&data); return data.timestamp; } @@ -598,17 +598,17 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) do { GHOST_TimerManager *timerMgr = getTimerManager(); - if (waitForEvent && m_dirty_windows.empty() && !XPending(m_display)) { + if (waitForEvent && dirty_windows_.empty() && !XPending(display_)) { uint64_t next = timerMgr->nextFireTime(); if (next == GHOST_kFireTimeNever) { - SleepTillEvent(m_display, -1); + SleepTillEvent(display_, -1); } else { const int64_t maxSleep = next - getMilliSeconds(); if (maxSleep >= 0) { - SleepTillEvent(m_display, next - getMilliSeconds()); + SleepTillEvent(display_, next - getMilliSeconds()); } } } @@ -617,20 +617,20 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) anyProcessed = true; } - while (XPending(m_display)) { + while (XPending(display_)) { XEvent xevent; - XNextEvent(m_display, &xevent); + XNextEvent(display_, &xevent); #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) /* open connection to XIM server and create input context (XIC) * when receiving the first FocusIn or KeyPress event after startup, * or recover XIM and XIC when the XIM server has been restarted */ if (ELEM(xevent.type, FocusIn, KeyPress)) { - if (!m_xim && openX11_IM()) { + if (!xim_ && openX11_IM()) { GHOST_PRINT("Connected to XIM server\n"); } - if (m_xim) { + if (xim_) { GHOST_WindowX11 *window = findGhostWindow(xevent.xany.window); if (window && !window->getX11_XIC() && window->createX11_XIC()) { GHOST_PRINT("XIM input context created\n"); @@ -647,7 +647,7 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) /* Ensure generated time-stamps are non-zero. */ if (ELEM(xevent.type, KeyPress, KeyRelease)) { if (xevent.xkey.time != 0) { - m_last_key_time = xevent.xkey.time; + last_key_time_ = xevent.xkey.time; } } @@ -660,12 +660,12 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) /* When using auto-repeat, some key-press events can actually come *after* the * last key-release. The next code takes care of that. */ if (xevent.type == KeyRelease) { - m_last_release_keycode = xevent.xkey.keycode; - m_last_release_time = xevent.xkey.time; + last_release_keycode_ = xevent.xkey.keycode; + last_release_time_ = xevent.xkey.time; } else if (xevent.type == KeyPress) { - if ((xevent.xkey.keycode == m_last_release_keycode) && - (xevent.xkey.time <= m_last_release_time)) + if ((xevent.xkey.keycode == last_release_keycode_) && + (xevent.xkey.time <= last_release_time_)) { continue; } @@ -685,15 +685,15 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) /* use previous event's window, because KeymapNotify event * has no window information. */ GHOST_WindowX11 *window = findGhostWindow(xevent.xany.window); - if (window && XPending(m_display) >= 2) { - XNextEvent(m_display, &xevent); + if (window && XPending(display_) >= 2) { + XNextEvent(display_, &xevent); if (xevent.type == KeymapNotify) { XEvent xev_next; /* check if KeyPress or KeyRelease event was generated * in order to confirm the window is active. */ - XPeekEvent(m_display, &xev_next); + XPeekEvent(display_, &xev_next); if (ELEM(xev_next.type, KeyPress, KeyRelease)) { const uint64_t event_ms = ms_from_input_time(xev_next.xkey.time); @@ -712,7 +712,7 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) }; for (int i = 0; i < int(ARRAY_SIZE(modifiers)); i++) { - KeyCode kc = XKeysymToKeycode(m_display, modifiers[i]); + KeyCode kc = XKeysymToKeycode(display_, modifiers[i]); if (kc != 0 && ((xevent.xkeymap.key_vector[kc >> 3] >> (kc & 7)) & 1) != 0) { pushEvent(new GHOST_EventKey(event_ms, GHOST_kEventKeyDown, @@ -734,7 +734,7 @@ bool GHOST_SystemX11::processEvents(bool waitForEvent) } #ifdef WITH_INPUT_NDOF - if (static_cast(m_ndofManager)->processEvents()) { + if (static_cast(ndof_manager_)->processEvents()) { anyProcessed = true; } #endif @@ -801,12 +801,12 @@ void GHOST_SystemX11::processEvent(XEvent *xe) /* Set to true if this key will repeat. */ bool is_repeat_keycode = false; - if (m_xkb_descr != nullptr) { + if (xkb_descr_ != nullptr) { /* Use XKB support. */ is_repeat_keycode = ( /* Should always be true, check just in case. */ (xke->keycode < (XkbPerKeyBitArraySize << 3)) && - bit_is_on(m_xkb_descr->ctrls->per_key_repeat, xke->keycode)); + bit_is_on(xkb_descr_->ctrls->per_key_repeat, xke->keycode)); } else { /* No XKB support (filter by modifier). */ @@ -834,30 +834,30 @@ void GHOST_SystemX11::processEvent(XEvent *xe) if (is_repeat_keycode) { if (xe->type == KeyPress) { - if (m_keycode_last_repeat_key == xke->keycode) { + if (keycode_last_repeat_key_ == xke->keycode) { is_repeat = true; } - m_keycode_last_repeat_key = xke->keycode; + keycode_last_repeat_key_ = xke->keycode; } else { - if (m_keycode_last_repeat_key == xke->keycode) { - m_keycode_last_repeat_key = uint(-1); + if (keycode_last_repeat_key_ == xke->keycode) { + keycode_last_repeat_key_ = uint(-1); } } } } else if (xe->type == EnterNotify) { /* We can't tell how the key state changed, clear it to avoid stuck keys. */ - m_keycode_last_repeat_key = uint(-1); + keycode_last_repeat_key_ = uint(-1); } #ifdef USE_XINPUT_HOTPLUG /* Hot-Plug support */ - if (m_xinput_version.present) { + if (xinput_version_.present) { XEventClass class_presence; int xi_presence; - DevicePresence(m_display, xi_presence, class_presence); + DevicePresence(display_, xi_presence, class_presence); (void)class_presence; if (xe->type == xi_presence) { @@ -868,7 +868,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) /* update all window events */ { - const vector &win_vec = m_windowManager->getWindows(); + const vector &win_vec = window_manager_->getWindows(); vector::const_iterator win_it = win_vec.begin(); vector::const_iterator win_end = win_vec.end(); @@ -895,7 +895,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) if (window->GetTabletData().Active != GHOST_kTabletModeNone) { bool any_proximity = false; - for (const GHOST_TabletX11 &xtablet : m_xtablets) { + for (const GHOST_TabletX11 &xtablet : xtablets_) { if (checkTabletProximity(xe->xany.display, xtablet.Device)) { any_proximity = true; } @@ -947,14 +947,14 @@ void GHOST_SystemX11::processEvent(XEvent *xe) const int32_t subregion_div = 4; /* One quarter of the region. */ const int32_t size[2] = {bounds.getWidth(), bounds.getHeight()}; const int32_t center[2] = { - (bounds.m_l + bounds.m_r) / 2, - (bounds.m_t + bounds.m_b) / 2, + (bounds.l_ + bounds.r_) / 2, + (bounds.t_ + bounds.b_) / 2, }; /* Shrink the box to prevent the cursor escaping. */ - bounds.m_l = center[0] - (size[0] / (subregion_div * 2)); - bounds.m_r = center[0] + (size[0] / (subregion_div * 2)); - bounds.m_t = center[1] - (size[1] / (subregion_div * 2)); - bounds.m_b = center[1] + (size[1] / (subregion_div * 2)); + bounds.l_ = center[0] - (size[0] / (subregion_div * 2)); + bounds.r_ = center[0] + (size[0] / (subregion_div * 2)); + bounds.t_ = center[1] - (size[1] / (subregion_div * 2)); + bounds.b_ = center[1] + (size[1] / (subregion_div * 2)); bounds_margin = 0; bounds_axis = GHOST_TAxisFlag(GHOST_kAxisX | GHOST_kAxisY); } @@ -983,13 +983,13 @@ void GHOST_SystemX11::processEvent(XEvent *xe) * We also have to add a few extra milliseconds of 'padding', as sometimes we get two * close events that will generate extra wrap on the same axis within those few * milliseconds. */ - if (x_new != xme.x_root && xme.time > m_last_warp_x) { + if (x_new != xme.x_root && xme.time > last_warp_x_) { x_accum += (xme.x_root - x_new); - m_last_warp_x = lastEventTime(xme.time) + 25; + last_warp_x_ = lastEventTime(xme.time) + 25; } - if (y_new != xme.y_root && xme.time > m_last_warp_y) { + if (y_new != xme.y_root && xme.time > last_warp_y_) { y_accum += (xme.y_root - y_new); - m_last_warp_y = lastEventTime(xme.time) + 25; + last_warp_y_ = lastEventTime(xme.time) + 25; } window->setCursorGrabAccum(x_accum, y_accum); /* When wrapping we don't need to add an event because the @@ -1021,7 +1021,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) XKeyEvent *xke = &(xe->xkey); #ifdef WITH_X11_XINPUT /* Can be zero for XIM generated events. */ - const Time time = xke->time ? xke->time : m_last_key_time; + const Time time = xke->time ? xke->time : last_key_time_; #else const Time time = xke->time; #endif @@ -1093,7 +1093,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) /* Only allow a limited set of keys from XLookupKeysym, * all others we take from XLookupString, unless it gives unknown key... */ - gkey = ghost_key_from_keysym_or_keycode(key_sym, m_xkb_descr, xke->keycode); + gkey = ghost_key_from_keysym_or_keycode(key_sym, xkb_descr_, xke->keycode); switch (gkey) { case GHOST_kKeyRightAlt: case GHOST_kKeyLeftAlt: @@ -1159,7 +1159,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) key_sym = XLookupKeysym(xke, 0); } - gkey = ghost_key_from_keysym_or_keycode(key_sym, m_xkb_descr, xke->keycode); + gkey = ghost_key_from_keysym_or_keycode(key_sym, xkb_descr_, xke->keycode); if (!XLookupString(xke, &ascii, 1, nullptr, nullptr)) { ascii = '\0'; @@ -1209,7 +1209,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) status == XLookupKeySym ? "XLookupKeySym" : "Unknown status")); - printf("'%.*s' %p %p\n", len, utf8_buf, xic, m_xim); + printf("'%.*s' %p %p\n", len, utf8_buf, xic, xim_); } } else { @@ -1356,10 +1356,10 @@ void GHOST_SystemX11::processEvent(XEvent *xe) case ClientMessage: { XClientMessageEvent &xcme = xe->xclient; - if (((Atom)xcme.data.l[0]) == m_atom.WM_DELETE_WINDOW) { + if (((Atom)xcme.data.l[0]) == atom_.WM_DELETE_WINDOW) { g_event = new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window); } - else if (((Atom)xcme.data.l[0]) == m_atom.WM_TAKE_FOCUS) { + else if (((Atom)xcme.data.l[0]) == atom_.WM_TAKE_FOCUS) { XWindowAttributes attr; Window fwin; int revert_to; @@ -1374,11 +1374,11 @@ void GHOST_SystemX11::processEvent(XEvent *xe) * to be sure that our windows is mapped * or this call fail and close blender. */ - if (XGetWindowAttributes(m_display, xcme.window, &attr) == True) { - if (XGetInputFocus(m_display, &fwin, &revert_to) == True) { + if (XGetWindowAttributes(display_, xcme.window, &attr) == True) { + if (XGetInputFocus(display_, &fwin, &revert_to) == True) { if (attr.map_state == IsViewable) { if (fwin != xcme.window) { - XSetInputFocus(m_display, xcme.window, RevertToParent, xcme.data.l[1]); + XSetInputFocus(display_, xcme.window, RevertToParent, xcme.data.l[1]); } } } @@ -1432,10 +1432,10 @@ void GHOST_SystemX11::processEvent(XEvent *xe) #endif if (xce.type == EnterNotify) { - m_windowManager->setActiveWindow(window); + window_manager_->setActiveWindow(window); } else { - m_windowManager->setWindowInactive(window); + window_manager_->setWindowInactive(window); } break; @@ -1450,13 +1450,13 @@ void GHOST_SystemX11::processEvent(XEvent *xe) * state, and receipt of an #UnmapNotify event will * indicate a transition to the Iconic state. ] */ - if (window->m_post_init == True) { + if (window->post_init_ == True) { /* * Now we are sure that the window is * mapped, so only need change the state. */ - window->setState(window->m_post_state); - window->m_post_init = False; + window->setState(window->post_state_); + window->post_init_ = False; } break; case UnmapNotify: @@ -1482,14 +1482,10 @@ void GHOST_SystemX11::processEvent(XEvent *xe) nxe.xselection.time = xse->time; /* Check to see if the requester is asking for String */ - if (ELEM(xse->target, - m_atom.UTF8_STRING, - m_atom.STRING, - m_atom.COMPOUND_TEXT, - m_atom.C_STRING)) + if (ELEM(xse->target, atom_.UTF8_STRING, atom_.STRING, atom_.COMPOUND_TEXT, atom_.C_STRING)) { - if (xse->selection == XInternAtom(m_display, "PRIMARY", False)) { - XChangeProperty(m_display, + if (xse->selection == XInternAtom(display_, "PRIMARY", False)) { + XChangeProperty(display_, xse->requestor, xse->property, xse->target, @@ -1498,8 +1494,8 @@ void GHOST_SystemX11::processEvent(XEvent *xe) (uchar *)txt_select_buffer, strlen(txt_select_buffer)); } - else if (xse->selection == XInternAtom(m_display, "CLIPBOARD", False)) { - XChangeProperty(m_display, + else if (xse->selection == XInternAtom(display_, "CLIPBOARD", False)) { + XChangeProperty(display_, xse->requestor, xse->property, xse->target, @@ -1509,13 +1505,10 @@ void GHOST_SystemX11::processEvent(XEvent *xe) strlen(txt_cut_buffer)); } } - else if (xse->target == m_atom.TARGETS) { - const Atom atom_list[] = {m_atom.TARGETS, - m_atom.UTF8_STRING, - m_atom.STRING, - m_atom.COMPOUND_TEXT, - m_atom.C_STRING}; - XChangeProperty(m_display, + else if (xse->target == atom_.TARGETS) { + const Atom atom_list[] = { + atom_.TARGETS, atom_.UTF8_STRING, atom_.STRING, atom_.COMPOUND_TEXT, atom_.C_STRING}; + XChangeProperty(display_, xse->requestor, xse->property, XA_ATOM, @@ -1523,7 +1516,7 @@ void GHOST_SystemX11::processEvent(XEvent *xe) PropModeReplace, reinterpret_cast(atom_list), ARRAY_SIZE(atom_list)); - XFlush(m_display); + XFlush(display_); } else { /* Change property to None because we do not support the selection request target. */ @@ -1531,14 +1524,14 @@ void GHOST_SystemX11::processEvent(XEvent *xe) } /* Send the event to the client 0 0 == False, #SelectionNotify */ - XSendEvent(m_display, xse->requestor, 0, 0, &nxe); - XFlush(m_display); + XSendEvent(display_, xse->requestor, 0, 0, &nxe); + XFlush(display_); break; } default: { #ifdef WITH_X11_XINPUT - for (GHOST_TabletX11 &xtablet : m_xtablets) { + for (GHOST_TabletX11 &xtablet : xtablets_) { if (ELEM(xe->type, xtablet.MotionEvent, xtablet.PressEvent)) { const XDeviceMotionEvent *data = (const XDeviceMotionEvent *)xe; if (data->deviceid != xtablet.ID) { @@ -1626,20 +1619,14 @@ GHOST_TSuccess GHOST_SystemX11::getPixelAtCursor(float r_color[3]) const if (getCursorPosition(x, y) == GHOST_kFailure) { return GHOST_kFailure; } - XImage *image = XGetImage(m_display, - XRootWindow(m_display, XDefaultScreen(m_display)), - x, - y, - 1, - 1, - AllPlanes, - XYPixmap); + XImage *image = XGetImage( + display_, XRootWindow(display_, XDefaultScreen(display_)), x, y, 1, 1, AllPlanes, XYPixmap); if (image == nullptr) { return GHOST_kFailure; } c.pixel = XGetPixel(image, 0, 0); XFree(image); - XQueryColor(m_display, XDefaultColormap(m_display, XDefaultScreen(m_display)), &c); + XQueryColor(display_, XDefaultColormap(display_, XDefaultScreen(display_)), &c); /* X11 returns colors in the [0, 65535] range, so we need to scale back to [0, 1]. */ r_color[0] = c.red / 65535.0f; @@ -1653,46 +1640,45 @@ GHOST_TSuccess GHOST_SystemX11::getModifierKeys(GHOST_ModifierKeys &keys) const /* Analyze the masks returned from #XQueryPointer. */ - memset((void *)m_keyboard_vector, 0, sizeof(m_keyboard_vector)); + memset((void *)keyboard_vector_, 0, sizeof(keyboard_vector_)); - XQueryKeymap(m_display, (char *)m_keyboard_vector); + XQueryKeymap(display_, (char *)keyboard_vector_); /* Now translate key symbols into key-codes and test with vector. */ - const static KeyCode shift_l = XKeysymToKeycode(m_display, XK_Shift_L); - const static KeyCode shift_r = XKeysymToKeycode(m_display, XK_Shift_R); - const static KeyCode control_l = XKeysymToKeycode(m_display, XK_Control_L); - const static KeyCode control_r = XKeysymToKeycode(m_display, XK_Control_R); - const static KeyCode alt_l = XKeysymToKeycode(m_display, XK_Alt_L); - const static KeyCode alt_r = XKeysymToKeycode(m_display, XK_Alt_R); - const static KeyCode super_l = XKeysymToKeycode(m_display, XK_Super_L); - const static KeyCode super_r = XKeysymToKeycode(m_display, XK_Super_R); - const static KeyCode hyper_l = XKeysymToKeycode(m_display, XK_Hyper_L); - const static KeyCode hyper_r = XKeysymToKeycode(m_display, XK_Hyper_R); + const static KeyCode shift_l = XKeysymToKeycode(display_, XK_Shift_L); + const static KeyCode shift_r = XKeysymToKeycode(display_, XK_Shift_R); + const static KeyCode control_l = XKeysymToKeycode(display_, XK_Control_L); + const static KeyCode control_r = XKeysymToKeycode(display_, XK_Control_R); + const static KeyCode alt_l = XKeysymToKeycode(display_, XK_Alt_L); + const static KeyCode alt_r = XKeysymToKeycode(display_, XK_Alt_R); + const static KeyCode super_l = XKeysymToKeycode(display_, XK_Super_L); + const static KeyCode super_r = XKeysymToKeycode(display_, XK_Super_R); + const static KeyCode hyper_l = XKeysymToKeycode(display_, XK_Hyper_L); + const static KeyCode hyper_r = XKeysymToKeycode(display_, XK_Hyper_R); /* shift */ keys.set(GHOST_kModifierKeyLeftShift, - ((m_keyboard_vector[shift_l >> 3] >> (shift_l & 7)) & 1) != 0); + ((keyboard_vector_[shift_l >> 3] >> (shift_l & 7)) & 1) != 0); keys.set(GHOST_kModifierKeyRightShift, - ((m_keyboard_vector[shift_r >> 3] >> (shift_r & 7)) & 1) != 0); + ((keyboard_vector_[shift_r >> 3] >> (shift_r & 7)) & 1) != 0); /* control */ keys.set(GHOST_kModifierKeyLeftControl, - ((m_keyboard_vector[control_l >> 3] >> (control_l & 7)) & 1) != 0); + ((keyboard_vector_[control_l >> 3] >> (control_l & 7)) & 1) != 0); keys.set(GHOST_kModifierKeyRightControl, - ((m_keyboard_vector[control_r >> 3] >> (control_r & 7)) & 1) != 0); + ((keyboard_vector_[control_r >> 3] >> (control_r & 7)) & 1) != 0); /* alt */ - keys.set(GHOST_kModifierKeyLeftAlt, ((m_keyboard_vector[alt_l >> 3] >> (alt_l & 7)) & 1) != 0); - keys.set(GHOST_kModifierKeyRightAlt, ((m_keyboard_vector[alt_r >> 3] >> (alt_r & 7)) & 1) != 0); + keys.set(GHOST_kModifierKeyLeftAlt, ((keyboard_vector_[alt_l >> 3] >> (alt_l & 7)) & 1) != 0); + keys.set(GHOST_kModifierKeyRightAlt, ((keyboard_vector_[alt_r >> 3] >> (alt_r & 7)) & 1) != 0); /* super (windows) - only one GHOST-kModifierKeyOS, so mapping to either */ - keys.set(GHOST_kModifierKeyLeftOS, - ((m_keyboard_vector[super_l >> 3] >> (super_l & 7)) & 1) != 0); + keys.set(GHOST_kModifierKeyLeftOS, ((keyboard_vector_[super_l >> 3] >> (super_l & 7)) & 1) != 0); keys.set(GHOST_kModifierKeyRightOS, - ((m_keyboard_vector[super_r >> 3] >> (super_r & 7)) & 1) != 0); + ((keyboard_vector_[super_r >> 3] >> (super_r & 7)) & 1) != 0); /* hyper */ keys.set(GHOST_kModifierKeyLeftHyper, - ((m_keyboard_vector[hyper_l >> 3] >> (hyper_l & 7)) & 1) != 0); + ((keyboard_vector_[hyper_l >> 3] >> (hyper_l & 7)) & 1) != 0); keys.set(GHOST_kModifierKeyRightHyper, - ((m_keyboard_vector[hyper_r >> 3] >> (hyper_r & 7)) & 1) != 0); + ((keyboard_vector_[hyper_r >> 3] >> (hyper_r & 7)) & 1) != 0); return GHOST_kSuccess; } @@ -1703,8 +1689,8 @@ GHOST_TSuccess GHOST_SystemX11::getButtons(GHOST_Buttons &buttons) const int rx, ry, wx, wy; uint mask_return; - if (XQueryPointer(m_display, - RootWindow(m_display, DefaultScreen(m_display)), + if (XQueryPointer(display_, + RootWindow(display_, DefaultScreen(display_)), &root_return, &child_return, &rx, @@ -1757,7 +1743,7 @@ static GHOST_TSuccess getCursorPosition_impl(Display *display, GHOST_TSuccess GHOST_SystemX11::getCursorPosition(int32_t &x, int32_t &y) const { Window child_return; - return getCursorPosition_impl(m_display, x, y, &child_return); + return getCursorPosition_impl(display_, x, y, &child_return); } GHOST_TSuccess GHOST_SystemX11::setCursorPosition(int32_t x, int32_t y) @@ -1771,7 +1757,7 @@ GHOST_TSuccess GHOST_SystemX11::setCursorPosition(int32_t x, int32_t y) #ifdef WITH_XWAYLAND_HACK Window child_return = None; - if (getCursorPosition_impl(m_display, cx, cy, &child_return) == GHOST_kFailure) { + if (getCursorPosition_impl(display_, cx, cy, &child_return) == GHOST_kFailure) { return GHOST_kFailure; } #else @@ -1786,34 +1772,34 @@ GHOST_TSuccess GHOST_SystemX11::setCursorPosition(int32_t x, int32_t y) #ifdef WITH_XWAYLAND_HACK if (use_xwayland_hack) { if (child_return != None) { - XFixesHideCursor(m_display, child_return); + XFixesHideCursor(display_, child_return); } } #endif #if defined(WITH_X11_XINPUT) && defined(USE_X11_XINPUT_WARP) - if ((m_xinput_version.present) && (m_xinput_version.major_version >= 2)) { + if ((xinput_version_.present) && (xinput_version_.major_version >= 2)) { /* Needed to account for XInput "Coordinate Transformation Matrix", see #48901 */ int device_id; - if (XIGetClientPointer(m_display, None, &device_id) != False) { - XIWarpPointer(m_display, device_id, None, None, 0, 0, 0, 0, relx, rely); + if (XIGetClientPointer(display_, None, &device_id) != False) { + XIWarpPointer(display_, device_id, None, None, 0, 0, 0, 0, relx, rely); } } else #endif { - XWarpPointer(m_display, None, None, 0, 0, 0, 0, relx, rely); + XWarpPointer(display_, None, None, 0, 0, 0, 0, relx, rely); } #ifdef WITH_XWAYLAND_HACK if (use_xwayland_hack) { if (child_return != None) { - XFixesShowCursor(m_display, child_return); + XFixesShowCursor(display_, child_return); } } #endif - XSync(m_display, 0); /* Sync to process all requests */ + XSync(display_, 0); /* Sync to process all requests */ return GHOST_kSuccess; } @@ -1840,13 +1826,13 @@ void GHOST_SystemX11::addDirtyWindow(GHOST_WindowX11 *bad_wind) { GHOST_ASSERT((bad_wind != nullptr), "addDirtyWindow() nullptr ptr trapped (window)"); - m_dirty_windows.push_back(bad_wind); + dirty_windows_.push_back(bad_wind); } bool GHOST_SystemX11::generateWindowExposeEvents() { - vector::const_iterator w_start = m_dirty_windows.begin(); - vector::const_iterator w_end = m_dirty_windows.end(); + vector::const_iterator w_start = dirty_windows_.begin(); + vector::const_iterator w_end = dirty_windows_.end(); bool anyProcessed = false; for (; w_start != w_end; ++w_start) { @@ -1861,7 +1847,7 @@ bool GHOST_SystemX11::generateWindowExposeEvents() } } - m_dirty_windows.clear(); + dirty_windows_.clear(); return anyProcessed; } @@ -2056,7 +2042,7 @@ void GHOST_SystemX11::getClipboard_xcout( ulong pty_size, pty_items; uchar *ltxt = *txt; - const vector &win_vec = m_windowManager->getWindows(); + const vector &win_vec = window_manager_->getWindows(); vector::const_iterator win_it = win_vec.begin(); GHOST_WindowX11 *window = static_cast(*win_it); Window win = window->getXWindow(); @@ -2071,7 +2057,7 @@ void GHOST_SystemX11::getClipboard_xcout( } /* Send a selection request */ - XConvertSelection(m_display, sel, target, m_atom.XCLIP_OUT, win, CurrentTime); + XConvertSelection(display_, sel, target, atom_.XCLIP_OUT, win, CurrentTime); *context = XCLIB_XCOUT_SENTCONVSEL; return; @@ -2080,23 +2066,23 @@ void GHOST_SystemX11::getClipboard_xcout( return; } - if (target == m_atom.UTF8_STRING && evt->xselection.property == None) { + if (target == atom_.UTF8_STRING && evt->xselection.property == None) { *context = XCLIB_XCOUT_FALLBACK_UTF8; return; } - if (target == m_atom.COMPOUND_TEXT && evt->xselection.property == None) { + if (target == atom_.COMPOUND_TEXT && evt->xselection.property == None) { *context = XCLIB_XCOUT_FALLBACK_COMP; return; } - if (target == m_atom.TEXT && evt->xselection.property == None) { + if (target == atom_.TEXT && evt->xselection.property == None) { *context = XCLIB_XCOUT_FALLBACK_TEXT; return; } /* find the size and format of the data in property */ - XGetWindowProperty(m_display, + XGetWindowProperty(display_, win, - m_atom.XCLIP_OUT, + atom_.XCLIP_OUT, 0, 0, False, @@ -2108,10 +2094,10 @@ void GHOST_SystemX11::getClipboard_xcout( &buffer); XFree(buffer); - if (pty_type == m_atom.INCR) { + if (pty_type == atom_.INCR) { /* start INCR mechanism by deleting property */ - XDeleteProperty(m_display, win, m_atom.XCLIP_OUT); - XFlush(m_display); + XDeleteProperty(display_, win, atom_.XCLIP_OUT); + XFlush(display_); *context = XCLIB_XCOUT_INCR; return; } @@ -2125,9 +2111,9 @@ void GHOST_SystemX11::getClipboard_xcout( } /* Not using INCR mechanism, just read the property. */ - XGetWindowProperty(m_display, + XGetWindowProperty(display_, win, - m_atom.XCLIP_OUT, + atom_.XCLIP_OUT, 0, long(pty_size), False, @@ -2139,7 +2125,7 @@ void GHOST_SystemX11::getClipboard_xcout( &buffer); /* finished with property, delete it */ - XDeleteProperty(m_display, win, m_atom.XCLIP_OUT); + XDeleteProperty(display_, win, atom_.XCLIP_OUT); /* copy the buffer to the pointer for returned data */ ltxt = (uchar *)malloc(pty_items); @@ -2174,9 +2160,9 @@ void GHOST_SystemX11::getClipboard_xcout( } /* check size and format of the property */ - XGetWindowProperty(m_display, + XGetWindowProperty(display_, win, - m_atom.XCLIP_OUT, + atom_.XCLIP_OUT, 0, 0, False, @@ -2192,14 +2178,14 @@ void GHOST_SystemX11::getClipboard_xcout( * to tell the other X client that we have read * it and to send the next property */ XFree(buffer); - XDeleteProperty(m_display, win, m_atom.XCLIP_OUT); + XDeleteProperty(display_, win, atom_.XCLIP_OUT); return; } if (pty_size == 0) { /* no more data, exit from loop */ XFree(buffer); - XDeleteProperty(m_display, win, m_atom.XCLIP_OUT); + XDeleteProperty(display_, win, atom_.XCLIP_OUT); *context = XCLIB_XCOUT_NONE; /* this means that an INCR transfer is now @@ -2211,9 +2197,9 @@ void GHOST_SystemX11::getClipboard_xcout( /* if we have come this far, the property contains * text, we know the size. */ - XGetWindowProperty(m_display, + XGetWindowProperty(display_, win, - m_atom.XCLIP_OUT, + atom_.XCLIP_OUT, 0, long(pty_size), False, @@ -2241,8 +2227,8 @@ void GHOST_SystemX11::getClipboard_xcout( XFree(buffer); /* delete property to get the next item */ - XDeleteProperty(m_display, win, m_atom.XCLIP_OUT); - XFlush(m_display); + XDeleteProperty(display_, win, atom_.XCLIP_OUT); + XFlush(display_); return; } } @@ -2250,7 +2236,7 @@ void GHOST_SystemX11::getClipboard_xcout( char *GHOST_SystemX11::getClipboard(bool selection) const { Atom sseln; - Atom target = m_atom.UTF8_STRING; + Atom target = atom_.UTF8_STRING; Window owner; /* From `xclip.c` `doOut()` v0.11. */ @@ -2260,21 +2246,21 @@ char *GHOST_SystemX11::getClipboard(bool selection) const uint context = XCLIB_XCOUT_NONE; if (selection == True) { - sseln = m_atom.PRIMARY; + sseln = atom_.PRIMARY; } else { - sseln = m_atom.CLIPBOARD; + sseln = atom_.CLIPBOARD; } - const vector &win_vec = m_windowManager->getWindows(); + const vector &win_vec = window_manager_->getWindows(); vector::const_iterator win_it = win_vec.begin(); GHOST_WindowX11 *window = static_cast(*win_it); Window win = window->getXWindow(); /* check if we are the owner. */ - owner = XGetSelectionOwner(m_display, sseln); + owner = XGetSelectionOwner(display_, sseln); if (owner == win) { - if (sseln == m_atom.CLIPBOARD) { + if (sseln == atom_.CLIPBOARD) { size_t sel_buf_size = strlen(txt_cut_buffer) + 1; sel_buf = (char *)malloc(sel_buf_size); memcpy(sel_buf, txt_cut_buffer, sel_buf_size); @@ -2296,7 +2282,7 @@ char *GHOST_SystemX11::getClipboard(bool selection) const /* only get an event if xcout() is doing something */ bool restore_this_event = false; if (context != XCLIB_XCOUT_NONE) { - XNextEvent(m_display, &evt); + XNextEvent(display_, &evt); restore_this_event = (evt.type != SelectionNotify); } @@ -2310,19 +2296,19 @@ char *GHOST_SystemX11::getClipboard(bool selection) const /* Fallback is needed. Set #XA_STRING to target and restart the loop. */ if (context == XCLIB_XCOUT_FALLBACK) { context = XCLIB_XCOUT_NONE; - target = m_atom.STRING; + target = atom_.STRING; continue; } if (context == XCLIB_XCOUT_FALLBACK_UTF8) { /* utf8 fail, move to compound text. */ context = XCLIB_XCOUT_NONE; - target = m_atom.COMPOUND_TEXT; + target = atom_.COMPOUND_TEXT; continue; } if (context == XCLIB_XCOUT_FALLBACK_COMP) { /* Compound text fail, move to text. */ context = XCLIB_XCOUT_NONE; - target = m_atom.TEXT; + target = atom_.TEXT; continue; } if (context == XCLIB_XCOUT_FALLBACK_TEXT) { @@ -2337,7 +2323,7 @@ char *GHOST_SystemX11::getClipboard(bool selection) const } while (!restore_events.empty()) { - XPutBackEvent(m_display, &restore_events.back()); + XPutBackEvent(display_, &restore_events.back()); restore_events.pop_back(); } @@ -2347,7 +2333,7 @@ char *GHOST_SystemX11::getClipboard(bool selection) const memcpy(tmp_data, (char *)sel_buf, sel_len); tmp_data[sel_len] = '\0'; - if (sseln == m_atom.STRING) { + if (sseln == atom_.STRING) { XFree(sel_buf); } else { @@ -2361,17 +2347,17 @@ char *GHOST_SystemX11::getClipboard(bool selection) const void GHOST_SystemX11::putClipboard(const char *buffer, bool selection) const { - Window m_window, owner; + Window window_, owner; - const vector &win_vec = m_windowManager->getWindows(); + const vector &win_vec = window_manager_->getWindows(); vector::const_iterator win_it = win_vec.begin(); GHOST_WindowX11 *window = static_cast(*win_it); - m_window = window->getXWindow(); + window_ = window->getXWindow(); if (buffer) { if (selection == False) { - XSetSelectionOwner(m_display, m_atom.CLIPBOARD, m_window, CurrentTime); - owner = XGetSelectionOwner(m_display, m_atom.CLIPBOARD); + XSetSelectionOwner(display_, atom_.CLIPBOARD, window_, CurrentTime); + owner = XGetSelectionOwner(display_, atom_.CLIPBOARD); if (txt_cut_buffer) { free((void *)txt_cut_buffer); } @@ -2381,8 +2367,8 @@ void GHOST_SystemX11::putClipboard(const char *buffer, bool selection) const memcpy(txt_cut_buffer, buffer, buffer_size); } else { - XSetSelectionOwner(m_display, m_atom.PRIMARY, m_window, CurrentTime); - owner = XGetSelectionOwner(m_display, m_atom.PRIMARY); + XSetSelectionOwner(display_, atom_.PRIMARY, window_, CurrentTime); + owner = XGetSelectionOwner(display_, atom_.PRIMARY); if (txt_select_buffer) { free((void *)txt_select_buffer); } @@ -2392,7 +2378,7 @@ void GHOST_SystemX11::putClipboard(const char *buffer, bool selection) const memcpy(txt_select_buffer, buffer, buffer_size); } - if (owner != m_window) { + if (owner != window_) { fprintf(stderr, "failed to own primary\n"); } } @@ -2520,34 +2506,34 @@ GHOST_TSuccess GHOST_SystemX11::showMessageBox(const char *title, Window window; XEvent e; - int screen = DefaultScreen(m_display); - window = XCreateSimpleWindow(m_display, - RootWindow(m_display, screen), + int screen = DefaultScreen(display_); + window = XCreateSimpleWindow(display_, + RootWindow(display_, screen), 0, 0, dialog_data.width, dialog_data.height, 1, - BlackPixel(m_display, screen), - WhitePixel(m_display, screen)); + BlackPixel(display_, screen), + WhitePixel(display_, screen)); /* Window Should not be resizable */ { hints.flags = PSize | PMinSize | PMaxSize; hints.min_width = hints.max_width = hints.base_width = dialog_data.width; hints.min_height = hints.max_height = hints.base_height = dialog_data.height; - XSetWMNormalHints(m_display, window, &hints); + XSetWMNormalHints(display_, window, &hints); } /* Set title */ { - Atom wm_Name = XInternAtom(m_display, "_NET_WM_NAME", False); - Atom utf8Str = XInternAtom(m_display, "UTF8_STRING", False); + Atom wm_Name = XInternAtom(display_, "_NET_WM_NAME", False); + Atom utf8Str = XInternAtom(display_, "UTF8_STRING", False); - Atom winType = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE", False); - Atom typeDialog = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE_DIALOG", False); + Atom winType = XInternAtom(display_, "_NET_WM_WINDOW_TYPE", False); + Atom typeDialog = XInternAtom(display_, "_NET_WM_WINDOW_TYPE_DIALOG", False); - XChangeProperty(m_display, + XChangeProperty(display_, window, wm_Name, utf8Str, @@ -2557,40 +2543,40 @@ GHOST_TSuccess GHOST_SystemX11::showMessageBox(const char *title, int(strlen(title))); XChangeProperty( - m_display, window, winType, XA_ATOM, 32, PropModeReplace, (uchar *)&typeDialog, 1); + display_, window, winType, XA_ATOM, 32, PropModeReplace, (uchar *)&typeDialog, 1); } /* Create buttons GC */ XGCValues buttonBorderGCValues; - buttonBorderGCValues.foreground = BlackPixel(m_display, screen); - buttonBorderGCValues.background = WhitePixel(m_display, screen); + buttonBorderGCValues.foreground = BlackPixel(display_, screen); + buttonBorderGCValues.background = WhitePixel(display_, screen); XGCValues buttonGCValues; - buttonGCValues.foreground = WhitePixel(m_display, screen); - buttonGCValues.background = BlackPixel(m_display, screen); + buttonGCValues.foreground = WhitePixel(display_, screen); + buttonGCValues.background = BlackPixel(display_, screen); - GC buttonBorderGC = XCreateGC(m_display, window, GCForeground, &buttonBorderGCValues); - GC buttonGC = XCreateGC(m_display, window, GCForeground, &buttonGCValues); + GC buttonBorderGC = XCreateGC(display_, window, GCForeground, &buttonBorderGCValues); + GC buttonGC = XCreateGC(display_, window, GCForeground, &buttonGCValues); - XSelectInput(m_display, window, ExposureMask | ButtonPressMask | ButtonReleaseMask); - XMapWindow(m_display, window); + XSelectInput(display_, window, ExposureMask | ButtonPressMask | ButtonReleaseMask); + XMapWindow(display_, window); const bool has_link = link && strlen(link); while (true) { - XNextEvent(m_display, &e); + XNextEvent(display_, &e); if (e.type == Expose) { for (int i = 0; i < textLines; i++) { - XDrawString(m_display, + XDrawString(display_, window, - DefaultGC(m_display, screen), + DefaultGC(display_, screen), dialog_data.padding_x, dialog_data.padding_x + (i + 1) * dialog_data.line_height, text_splitted[i], int(strlen(text_splitted[i]))); } - dialog_data.drawButton(m_display, window, buttonBorderGC, buttonGC, 1, continue_label); + dialog_data.drawButton(display_, window, buttonBorderGC, buttonGC, 1, continue_label); if (has_link) { - dialog_data.drawButton(m_display, window, buttonBorderGC, buttonGC, 2, help_label); + dialog_data.drawButton(display_, window, buttonBorderGC, buttonGC, 2, help_label); } } else if (e.type == ButtonRelease) { @@ -2615,9 +2601,9 @@ GHOST_TSuccess GHOST_SystemX11::showMessageBox(const char *title, } free(text_splitted); - XDestroyWindow(m_display, window); - XFreeGC(m_display, buttonBorderGC); - XFreeGC(m_display, buttonGC); + XDestroyWindow(display_, window); + XFreeGC(display_, buttonBorderGC); + XFreeGC(display_, buttonGC); return GHOST_kSuccess; } @@ -2768,7 +2754,7 @@ static GHOST_TTabletMode tablet_mode_from_name(const char *name, const char *typ void GHOST_SystemX11::refreshXInputDevices() { - if (m_xinput_version.present) { + if (xinput_version_.present) { /* Close tablet devices. */ clearXInputDevices(); @@ -2777,10 +2763,10 @@ void GHOST_SystemX11::refreshXInputDevices() { int device_count; - XDeviceInfo *device_info = XListInputDevices(m_display, &device_count); + XDeviceInfo *device_info = XListInputDevices(display_, &device_count); for (int i = 0; i < device_count; ++i) { - char *device_type = device_info[i].type ? XGetAtomName(m_display, device_info[i].type) : + char *device_type = device_info[i].type ? XGetAtomName(display_, device_info[i].type) : nullptr; GHOST_TTabletMode tablet_mode = tablet_mode_from_name(device_info[i].name, device_type); @@ -2796,7 +2782,7 @@ void GHOST_SystemX11::refreshXInputDevices() GHOST_TabletX11 xtablet = {tablet_mode}; xtablet.ID = device_info[i].id; - xtablet.Device = XOpenDevice(m_display, xtablet.ID); + xtablet.Device = XOpenDevice(display_, xtablet.ID); if (xtablet.Device != nullptr) { /* Find how many pressure levels tablet has */ @@ -2828,7 +2814,7 @@ void GHOST_SystemX11::refreshXInputDevices() } } - m_xtablets.push_back(xtablet); + xtablets_.push_back(xtablet); } } @@ -2841,13 +2827,13 @@ void GHOST_SystemX11::refreshXInputDevices() void GHOST_SystemX11::clearXInputDevices() { - for (GHOST_TabletX11 &xtablet : m_xtablets) { + for (GHOST_TabletX11 &xtablet : xtablets_) { if (xtablet.Device) { - XCloseDevice(m_display, xtablet.Device); + XCloseDevice(display_, xtablet.Device); } } - m_xtablets.clear(); + xtablets_.clear(); } #endif /* WITH_X11_XINPUT */ diff --git a/intern/ghost/intern/GHOST_SystemX11.hh b/intern/ghost/intern/GHOST_SystemX11.hh index 6ec845e986f..920aee1122e 100644 --- a/intern/ghost/intern/GHOST_SystemX11.hh +++ b/intern/ghost/intern/GHOST_SystemX11.hh @@ -113,9 +113,9 @@ class GHOST_SystemX11 : public GHOST_System { * \param width: The width the window. * \param height: The height the window. * \param state: The state of the window when opened. - * \param stereoVisual: Create a stereo visual for quad buffered stereo. + * \param gpu_settings: Misc GPU settings. * \param exclusive: Use to show the window on top and ignore others (used full-screen). - * \param parentWindow: Parent (embedder) window. + * \param parent_window: Parent (embedder) window. * \return The new window (or 0 if creation failed). */ GHOST_IWindow *createWindow(const char *title, @@ -124,17 +124,17 @@ class GHOST_SystemX11 : public GHOST_System { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_GPUSettings gpuSettings, + GHOST_GPUSettings gpu_settings, const bool exclusive = false, const bool is_dialog = false, - const GHOST_IWindow *parentWindow = nullptr) override; + const GHOST_IWindow *parent_window = nullptr) override; /** * Create a new off-screen context. * Never explicitly delete the context, use #disposeContext() instead. * \return The new context (or 0 if creation failed). */ - GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpuSettings) override; + GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override; /** * Dispose of a context. @@ -190,13 +190,13 @@ class GHOST_SystemX11 : public GHOST_System { Display *getXDisplay() { - return m_display; + return display_; } #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) XIM getX11_XIM() { - return m_xim; + return xim_; } #endif @@ -289,7 +289,7 @@ class GHOST_SystemX11 : public GHOST_System { std::vector &GetXTablets() { - return m_xtablets; + return xtablets_; } #endif // WITH_X11_XINPUT @@ -325,50 +325,50 @@ class GHOST_SystemX11 : public GHOST_System { #ifdef WITH_X11_XINPUT Atom TABLET; #endif - } m_atom; + } atom_; #ifdef WITH_X11_XINPUT - XExtensionVersion m_xinput_version; + XExtensionVersion xinput_version_; #endif private: - Display *m_display; + Display *display_; /** Use for scan-code look-ups. */ - XkbDescRec *m_xkb_descr; + XkbDescRec *xkb_descr_; #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) - XIM m_xim; + XIM xim_; #endif #ifdef WITH_X11_XINPUT /* Tablet devices */ - std::vector m_xtablets; + std::vector xtablets_; #endif /** The vector of windows that need to be updated. */ - std::vector m_dirty_windows; + std::vector dirty_windows_; /** A vector of keyboard key masks. */ - char m_keyboard_vector[32]; + char keyboard_vector_[32]; /** * To prevent multiple warp, we store the time of the last warp event * and stop accumulating all events generated before that. */ - Time m_last_warp_x; - Time m_last_warp_y; + Time last_warp_x_; + Time last_warp_y_; /* Detect auto-repeat glitch. */ - unsigned int m_last_release_keycode; - Time m_last_release_time; + unsigned int last_release_keycode_; + Time last_release_time_; #ifdef WITH_X11_XINPUT /** Last key press or release, to apply to XIM generated events. */ - Time m_last_key_time; + Time last_key_time_; #endif - uint m_keycode_last_repeat_key; + uint keycode_last_repeat_key_; /** * Return the ghost window associated with the diff --git a/intern/ghost/intern/GHOST_TimerManager.cc b/intern/ghost/intern/GHOST_TimerManager.cc index 3eabe6923a2..08e4b5bb2cf 100644 --- a/intern/ghost/intern/GHOST_TimerManager.cc +++ b/intern/ghost/intern/GHOST_TimerManager.cc @@ -25,13 +25,13 @@ GHOST_TimerManager::~GHOST_TimerManager() uint32_t GHOST_TimerManager::getNumTimers() { - return uint32_t(m_timers.size()); + return uint32_t(timers_.size()); } bool GHOST_TimerManager::getTimerFound(GHOST_TimerTask *timer) { - TTimerVector::const_iterator iter = std::find(m_timers.begin(), m_timers.end(), timer); - return iter != m_timers.end(); + TTimerVector::const_iterator iter = std::find(timers_.begin(), timers_.end(), timer); + return iter != timers_.end(); } GHOST_TSuccess GHOST_TimerManager::addTimer(GHOST_TimerTask *timer) @@ -39,7 +39,7 @@ GHOST_TSuccess GHOST_TimerManager::addTimer(GHOST_TimerTask *timer) GHOST_TSuccess success; if (!getTimerFound(timer)) { /* Add the timer task. */ - m_timers.push_back(timer); + timers_.push_back(timer); success = GHOST_kSuccess; } else { @@ -51,10 +51,10 @@ GHOST_TSuccess GHOST_TimerManager::addTimer(GHOST_TimerTask *timer) GHOST_TSuccess GHOST_TimerManager::removeTimer(GHOST_TimerTask *timer) { GHOST_TSuccess success; - TTimerVector::iterator iter = std::find(m_timers.begin(), m_timers.end(), timer); - if (iter != m_timers.end()) { + TTimerVector::iterator iter = std::find(timers_.begin(), timers_.end(), timer); + if (iter != timers_.end()) { /* Remove the timer task. */ - m_timers.erase(iter); + timers_.erase(iter); delete timer; success = GHOST_kSuccess; } @@ -69,7 +69,7 @@ uint64_t GHOST_TimerManager::nextFireTime() uint64_t smallest = GHOST_kFireTimeNever; TTimerVector::iterator iter; - for (iter = m_timers.begin(); iter != m_timers.end(); ++iter) { + for (iter = timers_.begin(); iter != timers_.end(); ++iter) { const uint64_t next = (*iter)->getNext(); smallest = std::min(next, smallest); } @@ -82,7 +82,7 @@ bool GHOST_TimerManager::fireTimers(uint64_t time) TTimerVector::iterator iter; bool anyProcessed = false; - for (iter = m_timers.begin(); iter != m_timers.end(); ++iter) { + for (iter = timers_.begin(); iter != timers_.end(); ++iter) { if (fireTimer(time, *iter)) { anyProcessed = true; } @@ -98,9 +98,9 @@ bool GHOST_TimerManager::fireTimer(uint64_t time, GHOST_TimerTask *task) /* Check if the timer should be fired. */ if (time > next) { /* Fire the timer. */ - GHOST_TimerProcPtr timerProc = task->getTimerProc(); + GHOST_TimerProcPtr timer_proc = task->getTimerProc(); uint64_t start = task->getStart(); - timerProc(task, time - start); + timer_proc(task, time - start); /* Update the time at which we will fire it again. */ uint64_t interval = task->getInterval(); @@ -116,8 +116,8 @@ bool GHOST_TimerManager::fireTimer(uint64_t time, GHOST_TimerTask *task) void GHOST_TimerManager::disposeTimers() { - while (m_timers.empty() == false) { - delete m_timers[0]; - m_timers.erase(m_timers.begin()); + while (timers_.empty() == false) { + delete timers_[0]; + timers_.erase(timers_.begin()); } } diff --git a/intern/ghost/intern/GHOST_TimerManager.hh b/intern/ghost/intern/GHOST_TimerManager.hh index 7248dd16cb1..810335e6af7 100644 --- a/intern/ghost/intern/GHOST_TimerManager.hh +++ b/intern/ghost/intern/GHOST_TimerManager.hh @@ -90,7 +90,7 @@ class GHOST_TimerManager { using TTimerVector = std::vector; /** The list with event consumers. */ - TTimerVector m_timers; + TTimerVector timers_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_TimerManager") }; diff --git a/intern/ghost/intern/GHOST_TimerTask.hh b/intern/ghost/intern/GHOST_TimerTask.hh index f3f6fdc3768..bff2ef06f5f 100644 --- a/intern/ghost/intern/GHOST_TimerTask.hh +++ b/intern/ghost/intern/GHOST_TimerTask.hh @@ -19,19 +19,19 @@ class GHOST_TimerTask : public GHOST_ITimerTask { /** * Constructor. * \param start: The timer start time. - * \param interval: The interval between calls to the #timerProc. - * \param timerProc: The callback invoked when the interval expires. - * \param userData: The timer user data. + * \param interval: The interval between calls to the #timer_proc. + * \param timer_proc: The callback invoked when the interval expires. + * \param user_data: The timer user data. */ GHOST_TimerTask(uint64_t start, uint64_t interval, - GHOST_TimerProcPtr timerProc, - GHOST_TUserDataPtr userData = nullptr) - : m_start(start), - m_interval(interval), - m_next(start), - m_timerProc(timerProc), - m_userData(userData) + GHOST_TimerProcPtr timer_proc, + GHOST_TUserDataPtr user_data = nullptr) + : start_(start), + interval_(interval), + next_(start), + timer_proc_(timer_proc), + user_data_(user_data) { } @@ -41,7 +41,7 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ uint64_t getStart() const { - return m_start; + return start_; } /** @@ -50,7 +50,7 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ void setStart(uint64_t start) { - m_start = start; + start_ = start; } /** @@ -59,7 +59,7 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ uint64_t getInterval() const { - return m_interval; + return interval_; } /** @@ -68,49 +68,49 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ void setInterval(uint64_t interval) { - m_interval = interval; + interval_ = interval; } /** - * Returns the time the timerProc will be called. - * \return The time the timerProc will be called. + * Returns the time the timer_proc will be called. + * \return The time the timer_proc will be called. */ uint64_t getNext() const { - return m_next; + return next_; } /** - * Changes the time the timerProc will be called. - * \param next: The time the timerProc will be called. + * Changes the time the timer_proc will be called. + * \param next: The time the timer_proc will be called. */ void setNext(uint64_t next) { - m_next = next; + next_ = next; } /** \copydoc #GHOST_ITimerTask::getTimerProc */ GHOST_TimerProcPtr getTimerProc() const override { - return m_timerProc; + return timer_proc_; } /** \copydoc #GHOST_ITimerTask::setTimerProc */ - void setTimerProc(const GHOST_TimerProcPtr timerProc) override + void setTimerProc(const GHOST_TimerProcPtr timer_proc) override { - m_timerProc = timerProc; + timer_proc_ = timer_proc; } /** \copydoc #GHOST_ITimerTask::getUserData */ GHOST_TUserDataPtr getUserData() const override { - return m_userData; + return user_data_; } /** \copydoc #GHOST_ITimerTask::setUserData */ - void setUserData(const GHOST_TUserDataPtr userData) override + void setUserData(const GHOST_TUserDataPtr user_data) override { - m_userData = userData; + user_data_ = user_data; } /** @@ -119,7 +119,7 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ uint32_t getAuxData() const { - return m_auxData; + return aux_data_; } /** @@ -128,25 +128,25 @@ class GHOST_TimerTask : public GHOST_ITimerTask { */ void setAuxData(uint32_t auxData) { - m_auxData = auxData; + aux_data_ = auxData; } protected: /** The time the timer task was started. */ - uint64_t m_start; + uint64_t start_; /** The interval between calls. */ - uint64_t m_interval; + uint64_t interval_; - /** The time the timerProc will be called. */ - uint64_t m_next; + /** The time the timer_proc will be called. */ + uint64_t next_; /** The callback invoked when the timer expires. */ - GHOST_TimerProcPtr m_timerProc; + GHOST_TimerProcPtr timer_proc_; /** The timer task user data. */ - GHOST_TUserDataPtr m_userData; + GHOST_TUserDataPtr user_data_; /** Auxiliary storage room. */ - uint32_t m_auxData = 0; + uint32_t aux_data_ = 0; }; diff --git a/intern/ghost/intern/GHOST_TrackpadWin32.cc b/intern/ghost/intern/GHOST_TrackpadWin32.cc index 2995def80d2..a0a63188b2f 100644 --- a/intern/ghost/intern/GHOST_TrackpadWin32.cc +++ b/intern/ghost/intern/GHOST_TrackpadWin32.cc @@ -20,15 +20,15 @@ GHOST_DirectManipulationHelper::GHOST_DirectManipulationHelper( directManipulationEventHandler, DWORD directManipulationViewportHandlerCookie, bool isScrollDirectionInverted) - : m_hWnd(hWnd), - m_scrollDirectionRegKey(nullptr), - m_scrollDirectionChangeEvent(nullptr), - m_directManipulationManager(directManipulationManager), - m_directManipulationUpdateManager(directManipulationUpdateManager), - m_directManipulationViewport(directManipulationViewport), - m_directManipulationEventHandler(directManipulationEventHandler), - m_directManipulationViewportHandlerCookie(directManipulationViewportHandlerCookie), - m_isScrollDirectionInverted(isScrollDirectionInverted) + : h_wnd_(hWnd), + scroll_direction_reg_key_(nullptr), + scroll_direction_change_event_(nullptr), + direct_manipulation_manager_(directManipulationManager), + direct_manipulation_update_manager_(directManipulationUpdateManager), + direct_manipulation_viewport_(directManipulationViewport), + direct_manipulation_event_handler_(directManipulationEventHandler), + direct_manipulation_viewport_handler_cookie_(directManipulationViewportHandlerCookie), + is_scroll_direction_inverted_(isScrollDirectionInverted) { } @@ -137,29 +137,29 @@ bool GHOST_DirectManipulationHelper::getScrollDirectionFromReg() void GHOST_DirectManipulationHelper::registerScrollDirectionChangeListener() { - if (!m_scrollDirectionRegKey) { + if (!scroll_direction_reg_key_) { HRESULT hr = HRESULT_FROM_WIN32( RegOpenKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\PrecisionTouchPad\\", 0, KEY_NOTIFY, - &m_scrollDirectionRegKey)); + &scroll_direction_reg_key_)); if (!SUCCEEDED(hr)) { GHOST_PRINT("Failed to open scroll direction registry key\n"); return; } } - if (!m_scrollDirectionChangeEvent) { - m_scrollDirectionChangeEvent = CreateEventW(nullptr, true, false, nullptr); + if (!scroll_direction_change_event_) { + scroll_direction_change_event_ = CreateEventW(nullptr, true, false, nullptr); } else { - ResetEvent(m_scrollDirectionChangeEvent); + ResetEvent(scroll_direction_change_event_); } - HRESULT hr = HRESULT_FROM_WIN32(RegNotifyChangeKeyValue(m_scrollDirectionRegKey, + HRESULT hr = HRESULT_FROM_WIN32(RegNotifyChangeKeyValue(scroll_direction_reg_key_, true, REG_NOTIFY_CHANGE_LAST_SET, - m_scrollDirectionChangeEvent, + scroll_direction_change_event_, true)); if (!SUCCEEDED(hr)) { GHOST_PRINT("Failed to register scroll direction change listener\n"); @@ -169,61 +169,62 @@ void GHOST_DirectManipulationHelper::registerScrollDirectionChangeListener() void GHOST_DirectManipulationHelper::onPointerHitTest(UINT32 pointerId) { - [[maybe_unused]] HRESULT hr = m_directManipulationViewport->SetContact(pointerId); + [[maybe_unused]] HRESULT hr = direct_manipulation_viewport_->SetContact(pointerId); GHOST_ASSERT(SUCCEEDED(hr), "Viewport set contact failed\n"); - if (WaitForSingleObject(m_scrollDirectionChangeEvent, 0) == WAIT_OBJECT_0) { - m_isScrollDirectionInverted = getScrollDirectionFromReg(); + if (WaitForSingleObject(scroll_direction_change_event_, 0) == WAIT_OBJECT_0) { + is_scroll_direction_inverted_ = getScrollDirectionFromReg(); registerScrollDirectionChangeListener(); } } void GHOST_DirectManipulationHelper::update() { - if (m_directManipulationEventHandler->dm_status == DIRECTMANIPULATION_RUNNING || - m_directManipulationEventHandler->dm_status == DIRECTMANIPULATION_INERTIA) + if (direct_manipulation_event_handler_->dm_status == DIRECTMANIPULATION_RUNNING || + direct_manipulation_event_handler_->dm_status == DIRECTMANIPULATION_INERTIA) { - [[maybe_unused]] HRESULT hr = m_directManipulationUpdateManager->Update(nullptr); + [[maybe_unused]] HRESULT hr = direct_manipulation_update_manager_->Update(nullptr); GHOST_ASSERT(SUCCEEDED(hr), "DirectManipulationUpdateManager update failed\n"); } } void GHOST_DirectManipulationHelper::setDPI(uint16_t dpi) { - m_directManipulationEventHandler->dpi = dpi; + direct_manipulation_event_handler_->dpi = dpi; } GHOST_TTrackpadInfo GHOST_DirectManipulationHelper::getTrackpadInfo() { - GHOST_TTrackpadInfo result = m_directManipulationEventHandler->accumulated_values; - result.isScrollDirectionInverted = m_isScrollDirectionInverted; + GHOST_TTrackpadInfo result = direct_manipulation_event_handler_->accumulated_values; + result.isScrollDirectionInverted = is_scroll_direction_inverted_; - m_directManipulationEventHandler->accumulated_values = {0, 0, 0}; + direct_manipulation_event_handler_->accumulated_values = {0, 0, 0}; return result; } GHOST_DirectManipulationHelper::~GHOST_DirectManipulationHelper() { HRESULT hr; - hr = m_directManipulationViewport->Stop(); + hr = direct_manipulation_viewport_->Stop(); GHOST_ASSERT(SUCCEEDED(hr), "Viewport stop failed\n"); - hr = m_directManipulationViewport->RemoveEventHandler(m_directManipulationViewportHandlerCookie); + hr = direct_manipulation_viewport_->RemoveEventHandler( + direct_manipulation_viewport_handler_cookie_); GHOST_ASSERT(SUCCEEDED(hr), "Viewport remove event handler failed\n"); - hr = m_directManipulationViewport->Abandon(); + hr = direct_manipulation_viewport_->Abandon(); GHOST_ASSERT(SUCCEEDED(hr), "Viewport abandon failed\n"); - hr = m_directManipulationManager->Deactivate(m_hWnd); + hr = direct_manipulation_manager_->Deactivate(h_wnd_); GHOST_ASSERT(SUCCEEDED(hr), "DirectManipulationManager deactivate failed\n"); - if (m_scrollDirectionChangeEvent) { - CloseHandle(m_scrollDirectionChangeEvent); - m_scrollDirectionChangeEvent = nullptr; + if (scroll_direction_change_event_) { + CloseHandle(scroll_direction_change_event_); + scroll_direction_change_event_ = nullptr; } - if (m_scrollDirectionRegKey) { - RegCloseKey(m_scrollDirectionRegKey); - m_scrollDirectionRegKey = nullptr; + if (scroll_direction_reg_key_) { + RegCloseKey(scroll_direction_reg_key_); + scroll_direction_reg_key_ = nullptr; } } diff --git a/intern/ghost/intern/GHOST_TrackpadWin32.hh b/intern/ghost/intern/GHOST_TrackpadWin32.hh index 0de9de6ce39..55957b27894 100644 --- a/intern/ghost/intern/GHOST_TrackpadWin32.hh +++ b/intern/ghost/intern/GHOST_TrackpadWin32.hh @@ -124,17 +124,17 @@ class GHOST_DirectManipulationHelper { */ void registerScrollDirectionChangeListener(); - HWND m_hWnd; + HWND h_wnd_; - HKEY m_scrollDirectionRegKey; - HANDLE m_scrollDirectionChangeEvent; + HKEY scroll_direction_reg_key_; + HANDLE scroll_direction_change_event_; - Microsoft::WRL::ComPtr m_directManipulationManager; - Microsoft::WRL::ComPtr m_directManipulationUpdateManager; - Microsoft::WRL::ComPtr m_directManipulationViewport; + Microsoft::WRL::ComPtr direct_manipulation_manager_; + Microsoft::WRL::ComPtr direct_manipulation_update_manager_; + Microsoft::WRL::ComPtr direct_manipulation_viewport_; Microsoft::WRL::ComPtr - m_directManipulationEventHandler; - DWORD m_directManipulationViewportHandlerCookie; + direct_manipulation_event_handler_; + DWORD direct_manipulation_viewport_handler_cookie_; - bool m_isScrollDirectionInverted; + bool is_scroll_direction_inverted_; }; diff --git a/intern/ghost/intern/GHOST_Window.cc b/intern/ghost/intern/GHOST_Window.cc index c944040347c..143bac01a8e 100644 --- a/intern/ghost/intern/GHOST_Window.cc +++ b/intern/ghost/intern/GHOST_Window.cc @@ -21,37 +21,37 @@ GHOST_Window::GHOST_Window(uint32_t width, GHOST_TWindowState state, const GHOST_ContextParams &context_params, const bool /*exclusive*/) - : m_drawingContextType(GHOST_kDrawingContextTypeNone), - m_userData(nullptr), - m_cursorVisible(true), - m_cursorGrab(GHOST_kGrabDisable), - m_cursorGrabAxis(GHOST_kAxisNone), - m_cursorGrabInitPos{0, 0}, - m_cursorGrabAccumPos{0, 0}, - m_cursorShape(GHOST_kStandardCursorDefault), - m_progressBarVisible(false), - m_canAcceptDragOperation(false), - m_isUnsavedChanges(false), - m_windowDecorationStyleFlags(GHOST_kDecorationNone), - m_windowDecorationStyleSettings(), - m_want_context_params(context_params), - m_nativePixelSize(1.0f), - m_context(nullptr) + : drawing_context_type_(GHOST_kDrawingContextTypeNone), + user_data_(nullptr), + cursor_visible_(true), + cursor_grab_(GHOST_kGrabDisable), + cursor_grab_axis_(GHOST_kAxisNone), + cursor_grab_init_pos_{0, 0}, + cursor_grab_accum_pos_{0, 0}, + cursor_shape_(GHOST_kStandardCursorDefault), + progress_bar_visible_(false), + can_accept_drag_operation_(false), + is_unsaved_changes_(false), + window_decoration_style_flags_(GHOST_kDecorationNone), + window_decoration_style_settings_(), + want_context_params_(context_params), + native_pixel_size_(1.0f), + context_(nullptr) { const GHOST_ContextParams context_params_none = GHOST_CONTEXT_PARAMS_NONE; - m_context = new GHOST_ContextNone(context_params_none); + context_ = new GHOST_ContextNone(context_params_none); - m_fullScreen = state == GHOST_kWindowStateFullScreen; - if (m_fullScreen) { - m_fullScreenWidth = width; - m_fullScreenHeight = height; + full_screen_ = state == GHOST_kWindowStateFullScreen; + if (full_screen_) { + full_screen_width_ = width; + full_screen_height_ = height; } } GHOST_Window::~GHOST_Window() { - delete m_context; + delete context_; } void *GHOST_Window::getOSWindow() const @@ -61,98 +61,98 @@ void *GHOST_Window::getOSWindow() const GHOST_TWindowDecorationStyleFlags GHOST_Window::getWindowDecorationStyleFlags() { - return m_windowDecorationStyleFlags; + return window_decoration_style_flags_; } -void GHOST_Window::setWindowDecorationStyleFlags(GHOST_TWindowDecorationStyleFlags styleFlags) +void GHOST_Window::setWindowDecorationStyleFlags(GHOST_TWindowDecorationStyleFlags style_flags) { - m_windowDecorationStyleFlags = styleFlags; + window_decoration_style_flags_ = style_flags; } void GHOST_Window::setWindowDecorationStyleSettings( - GHOST_WindowDecorationStyleSettings decorationSettings) + GHOST_WindowDecorationStyleSettings decoration_settings) { - m_windowDecorationStyleSettings = decorationSettings; + window_decoration_style_settings_ = decoration_settings; } GHOST_TSuccess GHOST_Window::setDrawingContextType(GHOST_TDrawingContextType type) { - if (type != m_drawingContextType) { - delete m_context; - m_context = nullptr; + if (type != drawing_context_type_) { + delete context_; + context_ = nullptr; if (type != GHOST_kDrawingContextTypeNone) { - m_context = newDrawingContext(type); + context_ = newDrawingContext(type); } - if (m_context != nullptr) { - m_drawingContextType = type; + if (context_ != nullptr) { + drawing_context_type_ = type; } else { - m_context = new GHOST_ContextNone(m_want_context_params); - m_drawingContextType = GHOST_kDrawingContextTypeNone; + context_ = new GHOST_ContextNone(want_context_params_); + drawing_context_type_ = GHOST_kDrawingContextTypeNone; } - return (type == m_drawingContextType) ? GHOST_kSuccess : GHOST_kFailure; + return (type == drawing_context_type_) ? GHOST_kSuccess : GHOST_kFailure; } return GHOST_kSuccess; } GHOST_IContext *GHOST_Window::getDrawingContext() { - return m_context; + return context_; } GHOST_TSuccess GHOST_Window::swapBuffers() { - return m_context->swapBuffers(); + return context_->swapBuffers(); } GHOST_TSuccess GHOST_Window::setSwapInterval(int interval) { - return m_context->setSwapInterval(interval); + return context_->setSwapInterval(interval); } -GHOST_TSuccess GHOST_Window::getSwapInterval(int &intervalOut) +GHOST_TSuccess GHOST_Window::getSwapInterval(int &interval_out) { - return m_context->getSwapInterval(intervalOut); + return context_->getSwapInterval(interval_out); } GHOST_Context *GHOST_Window::getContext() { - return m_context; + return context_; } uint GHOST_Window::getDefaultFramebuffer() { - return (m_context) ? m_context->getDefaultFramebuffer() : 0; + return (context_) ? context_->getDefaultFramebuffer() : 0; } #ifdef WITH_VULKAN_BACKEND GHOST_TSuccess GHOST_Window::getVulkanSwapChainFormat(GHOST_VulkanSwapChainData *r_swap_chain_data) { - return m_context->getVulkanSwapChainFormat(r_swap_chain_data); + return context_->getVulkanSwapChainFormat(r_swap_chain_data); } #endif GHOST_TSuccess GHOST_Window::activateDrawingContext() { - return m_context->activateDrawingContext(); + return context_->activateDrawingContext(); } GHOST_TSuccess GHOST_Window::updateDrawingContext() { - return m_context->updateDrawingContext(); + return context_->updateDrawingContext(); } GHOST_TSuccess GHOST_Window::releaseNativeHandles() { - return m_context->releaseNativeHandles(); + return context_->releaseNativeHandles(); } GHOST_TSuccess GHOST_Window::setCursorVisibility(bool visible) { if (setWindowCursorVisibility(visible)) { - m_cursorVisible = visible; + cursor_visible_ = visible; return GHOST_kSuccess; } return GHOST_kFailure; @@ -163,29 +163,29 @@ GHOST_TSuccess GHOST_Window::setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_Rect *bounds, int32_t mouse_ungrab_xy[2]) { - if (m_cursorGrab == mode) { + if (cursor_grab_ == mode) { return GHOST_kSuccess; } /* Override with new location. */ if (mouse_ungrab_xy) { assert(mode == GHOST_kGrabDisable); - m_cursorGrabInitPos[0] = mouse_ungrab_xy[0]; - m_cursorGrabInitPos[1] = mouse_ungrab_xy[1]; + cursor_grab_init_pos_[0] = mouse_ungrab_xy[0]; + cursor_grab_init_pos_[1] = mouse_ungrab_xy[1]; } if (setWindowCursorGrab(mode)) { if (mode == GHOST_kGrabDisable) { - m_cursorGrabBounds.m_l = m_cursorGrabBounds.m_r = -1; + cursor_grab_bounds_.l_ = cursor_grab_bounds_.r_ = -1; } else if (bounds) { - m_cursorGrabBounds = *bounds; + cursor_grab_bounds_ = *bounds; } else { /* if bounds not defined, use window */ - getClientBounds(m_cursorGrabBounds); + getClientBounds(cursor_grab_bounds_); } - m_cursorGrab = mode; - m_cursorGrabAxis = wrap_axis; + cursor_grab_ = mode; + cursor_grab_axis_ = wrap_axis; return GHOST_kSuccess; } return GHOST_kFailure; @@ -193,11 +193,11 @@ GHOST_TSuccess GHOST_Window::setCursorGrab(GHOST_TGrabCursorMode mode, GHOST_TSuccess GHOST_Window::getCursorGrabBounds(GHOST_Rect &bounds) const { - if (!(m_cursorGrab == GHOST_kGrabWrap || m_cursorGrab == GHOST_kGrabHide)) { + if (!(cursor_grab_ == GHOST_kGrabWrap || cursor_grab_ == GHOST_kGrabHide)) { return GHOST_kFailure; } - bounds = m_cursorGrabBounds; - return (bounds.m_l == -1 && bounds.m_r == -1) ? GHOST_kFailure : GHOST_kSuccess; + bounds = cursor_grab_bounds_; + return (bounds.l_ == -1 && bounds.r_ == -1) ? GHOST_kFailure : GHOST_kSuccess; } void GHOST_Window::getCursorGrabState(GHOST_TGrabCursorMode &mode, @@ -205,19 +205,19 @@ void GHOST_Window::getCursorGrabState(GHOST_TGrabCursorMode &mode, GHOST_Rect &bounds, bool &use_software_cursor) { - mode = m_cursorGrab; - if (m_cursorGrab == GHOST_kGrabWrap) { - bounds = m_cursorGrabBounds; - wrap_axis = m_cursorGrabAxis; + mode = cursor_grab_; + if (cursor_grab_ == GHOST_kGrabWrap) { + bounds = cursor_grab_bounds_; + wrap_axis = cursor_grab_axis_; } else { - bounds.m_l = -1; - bounds.m_r = -1; - bounds.m_t = -1; - bounds.m_b = -1; + bounds.l_ = -1; + bounds.r_ = -1; + bounds.t_ = -1; + bounds.b_ = -1; wrap_axis = GHOST_kAxisNone; } - use_software_cursor = (m_cursorGrab != GHOST_kGrabDisable) ? getCursorGrabUseSoftwareDisplay() : + use_software_cursor = (cursor_grab_ != GHOST_kGrabDisable) ? getCursorGrabUseSoftwareDisplay() : false; } @@ -227,10 +227,10 @@ bool GHOST_Window::getCursorGrabUseSoftwareDisplay() return false; } -GHOST_TSuccess GHOST_Window::setCursorShape(GHOST_TStandardCursor cursorShape) +GHOST_TSuccess GHOST_Window::setCursorShape(GHOST_TStandardCursor cursor_shape) { - if (setWindowCursorShape(cursorShape)) { - m_cursorShape = cursorShape; + if (setWindowCursorShape(cursor_shape)) { + cursor_shape_ = cursor_shape; return GHOST_kSuccess; } return GHOST_kFailure; @@ -243,7 +243,7 @@ GHOST_TSuccess GHOST_Window::setCustomCursorShape(const uint8_t *bitmap, bool can_invert_color) { if (setWindowCustomCursorShape(bitmap, mask, size, hot_spot, can_invert_color)) { - m_cursorShape = GHOST_kStandardCursorCustom; + cursor_shape_ = GHOST_kStandardCursorCustom; return GHOST_kSuccess; } return GHOST_kFailure; @@ -252,7 +252,7 @@ GHOST_TSuccess GHOST_Window::setCustomCursorShape(const uint8_t *bitmap, GHOST_TSuccess GHOST_Window::setCustomCursorGenerator(GHOST_CursorGenerator *cursor_generator) { if (setWindowCustomCursorGenerator(cursor_generator)) { - m_cursorShape = GHOST_kStandardCursorCustom; + cursor_shape_ = GHOST_kStandardCursorCustom; return GHOST_kSuccess; } return GHOST_kFailure; @@ -264,24 +264,24 @@ GHOST_TSuccess GHOST_Window::getCursorBitmap(GHOST_CursorBitmapRef * /*bitmap*/) return GHOST_kFailure; } -void GHOST_Window::setAcceptDragOperation(bool canAccept) +void GHOST_Window::setAcceptDragOperation(bool can_accept) { - m_canAcceptDragOperation = canAccept; + can_accept_drag_operation_ = can_accept; } bool GHOST_Window::canAcceptDragOperation() const { - return m_canAcceptDragOperation; + return can_accept_drag_operation_; } -GHOST_TSuccess GHOST_Window::setModifiedState(bool isUnsavedChanges) +GHOST_TSuccess GHOST_Window::setModifiedState(bool is_unsaved_changes) { - m_isUnsavedChanges = isUnsavedChanges; + is_unsaved_changes_ = is_unsaved_changes; return GHOST_kSuccess; } bool GHOST_Window::getModifiedState() { - return m_isUnsavedChanges; + return is_unsaved_changes_; } diff --git a/intern/ghost/intern/GHOST_Window.hh b/intern/ghost/intern/GHOST_Window.hh index c595eee0f5a..e6899c45489 100644 --- a/intern/ghost/intern/GHOST_Window.hh +++ b/intern/ghost/intern/GHOST_Window.hh @@ -58,7 +58,7 @@ class GHOST_Window : public GHOST_IWindow { * virtual GHOST_TSuccess setOrder(GHOST_TWindowOrder order) = 0; * virtual GHOST_TSuccess swapBuffers() = 0; * virtual GHOST_TSuccess setSwapInterval() = 0; - * virtual GHOST_TSuccess getSwapInterval(int& intervalOut) = 0; + * virtual GHOST_TSuccess getSwapInterval(int& interval_out) = 0; * virtual GHOST_TSuccess activateDrawingContext() = 0; * virtual GHOST_TSuccess invalidate() = 0; */ @@ -72,7 +72,7 @@ class GHOST_Window : public GHOST_IWindow { /** \copydoc #GHOST_IWindow::getValid */ bool getValid() const override { - return m_context != nullptr; + return context_ != nullptr; } /** \copydoc #GHOST_IWindow::getOSWindow */ @@ -89,11 +89,11 @@ class GHOST_Window : public GHOST_IWindow { /** \copydoc #GHOST_IWindow::setWindowDecorationStyleFlags */ virtual void setWindowDecorationStyleFlags( - GHOST_TWindowDecorationStyleFlags styleFlags) override; + GHOST_TWindowDecorationStyleFlags style_flags) override; /** \copydoc #GHOST_IWindow::setWindowDecorationStyleSettings */ virtual void setWindowDecorationStyleSettings( - GHOST_WindowDecorationStyleSettings decorationSettings) override; + GHOST_WindowDecorationStyleSettings decoration_settings) override; /** \copydoc #GHOST_IWindow::applyWindowDecorationStyle */ virtual GHOST_TSuccess applyWindowDecorationStyle() override @@ -110,7 +110,7 @@ class GHOST_Window : public GHOST_IWindow { } /** \copydoc #GHOST_IWindow::setCursorShape */ - GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursorShape) override; + GHOST_TSuccess setCursorShape(GHOST_TStandardCursor cursor_shape) override; /** \copydoc #GHOST_IWindow::setCustomCursorShape */ GHOST_TSuccess setCustomCursorShape(const uint8_t *bitmap, @@ -167,16 +167,16 @@ class GHOST_Window : public GHOST_IWindow { /** \copydoc #GHOST_IWindow::setSwapInterval */ GHOST_TSuccess setSwapInterval(int interval) override; /** \copydoc #GHOST_IWindow::getSwapInterval */ - GHOST_TSuccess getSwapInterval(int &intervalOut) override; + GHOST_TSuccess getSwapInterval(int &interval_out) override; /** \copydoc #GHOST_IWindow::setAcceptDragOperation */ - void setAcceptDragOperation(bool canAccept) override; + void setAcceptDragOperation(bool can_accept) override; /** \copydoc #GHOST_IWindow::canAcceptDragOperation */ bool canAcceptDragOperation() const override; /** \copydoc #GHOST_IWindow::setModifiedState */ - GHOST_TSuccess setModifiedState(bool isUnsavedChanges) override; + GHOST_TSuccess setModifiedState(bool is_unsaved_changes) override; /** \copydoc #GHOST_IWindow::getModifiedState */ bool getModifiedState() override; @@ -226,20 +226,20 @@ class GHOST_Window : public GHOST_IWindow { /** \copydoc #GHOST_IWindow::getUserData */ GHOST_TUserDataPtr getUserData() const override { - return m_userData; + return user_data_; } /** \copydoc #GHOST_IWindow::setUserData */ - void setUserData(const GHOST_TUserDataPtr userData) override + void setUserData(const GHOST_TUserDataPtr user_data) override { - m_userData = userData; + user_data_ = user_data; } /** \copydoc #GHOST_IWindow::getNativePixelSize */ float getNativePixelSize() override { - if (m_nativePixelSize > 0.0f) { - return m_nativePixelSize; + if (native_pixel_size_ > 0.0f) { + return native_pixel_size_; } return 1.0f; } @@ -305,107 +305,107 @@ class GHOST_Window : public GHOST_IWindow { GHOST_TSuccess releaseNativeHandles(); /** The drawing context installed in this window. */ - GHOST_TDrawingContextType m_drawingContextType; + GHOST_TDrawingContextType drawing_context_type_; /** The window user data */ - GHOST_TUserDataPtr m_userData; + GHOST_TUserDataPtr user_data_; /** The current visibility of the cursor */ - bool m_cursorVisible; + bool cursor_visible_; /** The current grabbed state of the cursor */ - GHOST_TGrabCursorMode m_cursorGrab; + GHOST_TGrabCursorMode cursor_grab_; /** Grab cursor axis. */ - GHOST_TAxisFlag m_cursorGrabAxis; + GHOST_TAxisFlag cursor_grab_axis_; /** Initial grab location. */ - int32_t m_cursorGrabInitPos[2]; + int32_t cursor_grab_init_pos_[2]; - /** Accumulated offset from m_cursorGrabInitPos. */ - int32_t m_cursorGrabAccumPos[2]; + /** Accumulated offset from cursor_grab_init_pos_. */ + int32_t cursor_grab_accum_pos_[2]; /** Wrap the cursor within this region. */ - GHOST_Rect m_cursorGrabBounds; + GHOST_Rect cursor_grab_bounds_; /** The current shape of the cursor */ - GHOST_TStandardCursor m_cursorShape; + GHOST_TStandardCursor cursor_shape_; /** The presence of progress indicator with the application icon */ - bool m_progressBarVisible; + bool progress_bar_visible_; /** The acceptance of the "drop candidate" of the current drag & drop operation. */ - bool m_canAcceptDragOperation; + bool can_accept_drag_operation_; /** Modified state : are there unsaved changes */ - bool m_isUnsavedChanges; + bool is_unsaved_changes_; /** Stores whether this is a full screen window. */ - bool m_fullScreen; + bool full_screen_; /** Window Decoration Styles. */ - GHOST_TWindowDecorationStyleFlags m_windowDecorationStyleFlags; - GHOST_WindowDecorationStyleSettings m_windowDecorationStyleSettings; + GHOST_TWindowDecorationStyleFlags window_decoration_style_flags_; + GHOST_WindowDecorationStyleSettings window_decoration_style_settings_; /** The desired parameters to use when initializing the context for this window. */ - GHOST_ContextParams m_want_context_params; + GHOST_ContextParams want_context_params_; /** Full-screen width */ - uint32_t m_fullScreenWidth; + uint32_t full_screen_width_; /** Full-screen height */ - uint32_t m_fullScreenHeight; + uint32_t full_screen_height_; /* OSX only, retina screens */ - float m_nativePixelSize; + float native_pixel_size_; private: - GHOST_Context *m_context; + GHOST_Context *context_; }; inline GHOST_TDrawingContextType GHOST_Window::getDrawingContextType() { - return m_drawingContextType; + return drawing_context_type_; } inline bool GHOST_Window::getCursorVisibility() const { - return m_cursorVisible; + return cursor_visible_; } inline GHOST_TGrabCursorMode GHOST_Window::getCursorGrabMode() const { - return m_cursorGrab; + return cursor_grab_; } inline bool GHOST_Window::getCursorGrabModeIsWarp() const { - return (m_cursorGrab == GHOST_kGrabWrap) || (m_cursorGrab == GHOST_kGrabHide); + return (cursor_grab_ == GHOST_kGrabWrap) || (cursor_grab_ == GHOST_kGrabHide); } inline GHOST_TAxisFlag GHOST_Window::getCursorGrabAxis() const { - return m_cursorGrabAxis; + return cursor_grab_axis_; } inline void GHOST_Window::getCursorGrabInitPos(int32_t &x, int32_t &y) const { - x = m_cursorGrabInitPos[0]; - y = m_cursorGrabInitPos[1]; + x = cursor_grab_init_pos_[0]; + y = cursor_grab_init_pos_[1]; } inline void GHOST_Window::getCursorGrabAccum(int32_t &x, int32_t &y) const { - x = m_cursorGrabAccumPos[0]; - y = m_cursorGrabAccumPos[1]; + x = cursor_grab_accum_pos_[0]; + y = cursor_grab_accum_pos_[1]; } inline void GHOST_Window::setCursorGrabAccum(int32_t x, int32_t y) { - m_cursorGrabAccumPos[0] = x; - m_cursorGrabAccumPos[1] = y; + cursor_grab_accum_pos_[0] = x; + cursor_grab_accum_pos_[1] = y; } inline GHOST_TStandardCursor GHOST_Window::getCursorShape() const { - return m_cursorShape; + return cursor_shape_; } diff --git a/intern/ghost/intern/GHOST_WindowCocoa.hh b/intern/ghost/intern/GHOST_WindowCocoa.hh index 2cf3aeb4610..bb5658ed04e 100644 --- a/intern/ghost/intern/GHOST_WindowCocoa.hh +++ b/intern/ghost/intern/GHOST_WindowCocoa.hh @@ -54,7 +54,7 @@ class GHOST_WindowCocoa : public GHOST_Window { GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, bool dialog, - GHOST_WindowCocoa *parentWindow, + GHOST_WindowCocoa *parent_window, const GHOST_GPUDevice &preferred_device); /** @@ -139,10 +139,10 @@ class GHOST_WindowCocoa : public GHOST_Window { /** * Sets the window "modified" status, indicating unsaved changes - * \param isUnsavedChanges: Unsaved changes or not. + * \param is_unsaved_changes: Unsaved changes or not. * \return Indication of success. */ - GHOST_TSuccess setModifiedState(bool isUnsavedChanges) override; + GHOST_TSuccess setModifiedState(bool is_unsaved_changes) override; /** * Converts a point in screen coordinates to client rectangle coordinates @@ -217,7 +217,7 @@ class GHOST_WindowCocoa : public GHOST_Window { GHOST_TabletData &GetCocoaTabletData() { - return m_tablet; + return tablet_; } /** @@ -236,17 +236,17 @@ class GHOST_WindowCocoa : public GHOST_Window { /** public function to get the window containing the view */ BlenderWindow *getViewWindow() const { - return m_window; + return window_; }; /* Internal value to ensure proper redraws during animations */ void setImmediateDraw(bool value) { - m_immediateDraw = value; + immediate_draw_ = value; } bool getImmediateDraw() const { - return m_immediateDraw; + return immediate_draw_; } #ifdef WITH_INPUT_IME @@ -297,23 +297,23 @@ class GHOST_WindowCocoa : public GHOST_Window { bool can_invert_color) override; /** The window containing the view */ - BlenderWindow *m_window; + BlenderWindow *window_; /** The view, either Metal or OpenGL */ - CocoaOpenGLView *m_openGLView; - CocoaMetalView *m_metalView; - CAMetalLayer *m_metalLayer; + CocoaOpenGLView *opengl_view_; + CocoaMetalView *metal_view_; + CAMetalLayer *metal_layer_; /** The mother SystemCocoa class to send events */ - GHOST_SystemCocoa *m_systemCocoa; + GHOST_SystemCocoa *system_cocoa_; - NSCursor *m_customCursor; + NSCursor *custom_cursor_; - GHOST_TabletData m_tablet; + GHOST_TabletData tablet_; - bool m_immediateDraw; - bool m_is_dialog; - GHOST_GPUDevice m_preferred_device; + bool immediate_draw_; + bool is_dialog_; + GHOST_GPUDevice preferred_device_; }; #ifdef WITH_INPUT_IME @@ -331,7 +331,7 @@ class GHOST_EventIME : public GHOST_Event { const void *customdata) : GHOST_Event(msec, type, window) { - this->m_data = customdata; + this->data_ = customdata; } }; diff --git a/intern/ghost/intern/GHOST_WindowCocoa.mm b/intern/ghost/intern/GHOST_WindowCocoa.mm index 75d5a8aee3c..cb47c4b280f 100644 --- a/intern/ghost/intern/GHOST_WindowCocoa.mm +++ b/intern/ghost/intern/GHOST_WindowCocoa.mm @@ -51,8 +51,8 @@ @implementation BlenderWindowDelegate : NSObject -@synthesize systemCocoa = m_systemCocoa; -@synthesize windowCocoa = m_windowCocoa; +@synthesize systemCocoa = system_cocoa_; +@synthesize windowCocoa = window_cocoa_; - (instancetype)initWithSystemCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa @@ -60,8 +60,8 @@ self = [super init]; if (self) { - m_systemCocoa = sysCocoa; - m_windowCocoa = winCocoa; + system_cocoa_ = sysCocoa; + window_cocoa_ = winCocoa; } return self; @@ -69,34 +69,34 @@ - (void)windowDidBecomeKey:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowActivate, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowActivate, window_cocoa_); /* Workaround for broken app-switching when combining Command-Tab and mission-control. */ - [(NSWindow *)m_windowCocoa->getOSWindow() orderFrontRegardless]; + [(NSWindow *)window_cocoa_->getOSWindow() orderFrontRegardless]; } - (void)windowDidResignKey:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowDeactivate, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowDeactivate, window_cocoa_); } - (void)windowDidExpose:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowUpdate, window_cocoa_); } - (void)windowDidMove:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowMove, window_cocoa_); } - (void)windowWillMove:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowMove, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowMove, window_cocoa_); } - (void)windowWillEnterFullScreen:(NSNotification *)notification { - m_windowCocoa->setImmediateDraw(true); + window_cocoa_->setImmediateDraw(true); } - (void)windowDidEnterFullScreen:(NSNotification *)notification @@ -104,21 +104,21 @@ /* macOS does not send a window resize event when switching between zoomed * and full-screen, when automatic show/hide of dock and menu bar are enabled. * Send our own to prevent artifacts. */ - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowSize, window_cocoa_); - m_windowCocoa->setImmediateDraw(false); + window_cocoa_->setImmediateDraw(false); } - (void)windowWillExitFullScreen:(NSNotification *)notification { - m_windowCocoa->setImmediateDraw(true); + window_cocoa_->setImmediateDraw(true); } - (void)windowDidExitFullScreen:(NSNotification *)notification { /* See comment for windowWillEnterFullScreen. */ - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, m_windowCocoa); - m_windowCocoa->setImmediateDraw(false); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowSize, window_cocoa_); + window_cocoa_->setImmediateDraw(false); } - (void)windowDidResize:(NSNotification *)notification @@ -128,25 +128,25 @@ #endif { /* Send event only once, at end of resize operation (when user has released mouse button). */ - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowSize, window_cocoa_); } /* Live resize, send event, gets handled in wm_window.c. * Needed because live resize runs in a modal loop, not letting main loop run */ if ([[notification object] inLiveResize]) { - m_systemCocoa->dispatchEvents(); + system_cocoa_->dispatchEvents(); } } - (void)windowDidChangeBackingProperties:(NSNotification *)notification { - m_systemCocoa->handleWindowEvent(GHOST_kEventNativeResolutionChange, m_windowCocoa); - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowSize, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventNativeResolutionChange, window_cocoa_); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowSize, window_cocoa_); } - (BOOL)windowShouldClose:(id)sender; { /* Let Blender close the window rather than closing immediately. */ - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowClose, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowClose, window_cocoa_); return false; } @@ -169,9 +169,9 @@ @implementation BlenderWindow -@synthesize systemCocoa = m_systemCocoa; -@synthesize windowCocoa = m_windowCocoa; -@synthesize draggedObjectType = m_draggedObjectType; +@synthesize systemCocoa = system_cocoa_; +@synthesize windowCocoa = window_cocoa_; +@synthesize draggedObjectType = dragged_object_type_; - (instancetype)initWithSystemCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa @@ -186,8 +186,8 @@ defer:flag]; if (self) { - m_systemCocoa = sysCocoa; - m_windowCocoa = winCocoa; + system_cocoa_ = sysCocoa; + window_cocoa_ = winCocoa; } return self; @@ -196,7 +196,7 @@ - (BOOL)canBecomeKeyWindow { /* Don't make other windows active when a dialog window is open. */ - return (m_windowCocoa->isDialog() || !m_systemCocoa->hasDialogWindow()); + return (window_cocoa_->isDialog() || !system_cocoa_->hasDialogWindow()); } /* The drag & drop dragging destination methods. */ @@ -205,23 +205,23 @@ @autoreleasepool { NSPasteboard *draggingPBoard = sender.draggingPasteboard; if ([[draggingPBoard types] containsObject:NSPasteboardTypeTIFF]) { - m_draggedObjectType = GHOST_kDragnDropTypeBitmap; + dragged_object_type_ = GHOST_kDragnDropTypeBitmap; } else if ([[draggingPBoard types] containsObject:NSFilenamesPboardType]) { - m_draggedObjectType = GHOST_kDragnDropTypeFilenames; + dragged_object_type_ = GHOST_kDragnDropTypeFilenames; } else if ([[draggingPBoard types] containsObject:NSPasteboardTypeString]) { - m_draggedObjectType = GHOST_kDragnDropTypeString; + dragged_object_type_ = GHOST_kDragnDropTypeString; } else { return NSDragOperationNone; } const NSPoint mouseLocation = sender.draggingLocation; - m_windowCocoa->setAcceptDragOperation(TRUE); /* Drag operation is accepted by default. */ - m_systemCocoa->handleDraggingEvent(GHOST_kEventDraggingEntered, - m_draggedObjectType, - m_windowCocoa, + window_cocoa_->setAcceptDragOperation(TRUE); /* Drag operation is accepted by default. */ + system_cocoa_->handleDraggingEvent(GHOST_kEventDraggingEntered, + dragged_object_type_, + window_cocoa_, mouseLocation.x, mouseLocation.y, nil); @@ -238,25 +238,25 @@ { const NSPoint mouseLocation = [sender draggingLocation]; - m_systemCocoa->handleDraggingEvent(GHOST_kEventDraggingUpdated, - m_draggedObjectType, - m_windowCocoa, + system_cocoa_->handleDraggingEvent(GHOST_kEventDraggingUpdated, + dragged_object_type_, + window_cocoa_, mouseLocation.x, mouseLocation.y, nil); - return m_windowCocoa->canAcceptDragOperation() ? NSDragOperationCopy : NSDragOperationNone; + return window_cocoa_->canAcceptDragOperation() ? NSDragOperationCopy : NSDragOperationNone; } - (void)draggingExited:(id)sender { - m_systemCocoa->handleDraggingEvent( - GHOST_kEventDraggingExited, m_draggedObjectType, m_windowCocoa, 0, 0, nil); - m_draggedObjectType = GHOST_kDragnDropTypeUnknown; + system_cocoa_->handleDraggingEvent( + GHOST_kEventDraggingExited, dragged_object_type_, window_cocoa_, 0, 0, nil); + dragged_object_type_ = GHOST_kDragnDropTypeUnknown; } - (BOOL)prepareForDragOperation:(id)sender { - if (m_windowCocoa->canAcceptDragOperation()) { + if (window_cocoa_->canAcceptDragOperation()) { return YES; } return NO; @@ -268,7 +268,7 @@ NSPasteboard *draggingPBoard = sender.draggingPasteboard; id data; - switch (m_draggedObjectType) { + switch (dragged_object_type_) { case GHOST_kDragnDropTypeBitmap: { if (![NSImage canInitWithPasteboard:draggingPBoard]) { return NO; @@ -290,9 +290,9 @@ } const NSPoint mouseLocation = sender.draggingLocation; - m_systemCocoa->handleDraggingEvent(GHOST_kEventDraggingDropDone, - m_draggedObjectType, - m_windowCocoa, + system_cocoa_->handleDraggingEvent(GHOST_kEventDraggingDropDone, + dragged_object_type_, + window_cocoa_, mouseLocation.x, mouseLocation.y, (void *)data); @@ -329,19 +329,19 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, bool is_dialog, - GHOST_WindowCocoa *parentWindow, + GHOST_WindowCocoa *parent_window, const GHOST_GPUDevice &preferred_device) : GHOST_Window(width, height, state, context_params, false), - m_openGLView(nil), - m_metalView(nil), - m_metalLayer(nil), - m_systemCocoa(systemCocoa), - m_customCursor(nullptr), - m_immediateDraw(false), - m_is_dialog(is_dialog), - m_preferred_device(preferred_device) + opengl_view_(nil), + metal_view_(nil), + metal_layer_(nil), + system_cocoa_(systemCocoa), + custom_cursor_(nullptr), + immediate_draw_(false), + is_dialog_(is_dialog), + preferred_device_(preferred_device) { - m_fullScreen = false; + full_screen_ = false; @autoreleasepool { /* Create the window. */ @@ -357,21 +357,21 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, styleMask |= NSWindowStyleMaskMiniaturizable; } - m_window = [[BlenderWindow alloc] initWithSystemCocoa:systemCocoa - windowCocoa:this - contentRect:rect - styleMask:styleMask - backing:NSBackingStoreBuffered - defer:NO]; + window_ = [[BlenderWindow alloc] initWithSystemCocoa:systemCocoa + windowCocoa:this + contentRect:rect + styleMask:styleMask + backing:NSBackingStoreBuffered + defer:NO]; /* By default, AppKit repositions the window in the context of the current "mainMonitor" * (the monitor which has focus), bypass this by forcing the window back into its correct * position. Since we use global screen coordinate indexed on the first, primary screen. */ - [m_window setFrameOrigin:NSMakePoint(left, bottom)]; + [window_ setFrameOrigin:NSMakePoint(left, bottom)]; /* Forbid to resize the window below the blender defined minimum one. */ const NSSize minSize = {320, 240}; - m_window.contentMinSize = minSize; + window_.contentMinSize = minSize; /* Create NSView inside the window. */ id metalDevice = MTLCreateSystemDefaultDevice(); @@ -379,14 +379,14 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, if (metalDevice) { /* Create metal layer and view if supported. */ - m_metalLayer = [[CAMetalLayer alloc] init]; - m_metalLayer.edgeAntialiasingMask = 0; - m_metalLayer.masksToBounds = NO; - m_metalLayer.opaque = YES; - m_metalLayer.framebufferOnly = YES; - m_metalLayer.presentsWithTransaction = NO; - [m_metalLayer removeAllAnimations]; - m_metalLayer.device = metalDevice; + metal_layer_ = [[CAMetalLayer alloc] init]; + metal_layer_.edgeAntialiasingMask = 0; + metal_layer_.masksToBounds = NO; + metal_layer_.opaque = YES; + metal_layer_.framebufferOnly = YES; + metal_layer_.presentsWithTransaction = NO; + [metal_layer_ removeAllAnimations]; + metal_layer_.device = metalDevice; if (type == GHOST_kDrawingContextTypeMetal) { /* Enable EDR support. This is done by: @@ -395,30 +395,30 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, * 3. Setting the extended sRGB color space so that the OS knows how to interpret the * values. */ - m_metalLayer.wantsExtendedDynamicRangeContent = YES; - m_metalLayer.pixelFormat = MTLPixelFormatRGBA16Float; + metal_layer_.wantsExtendedDynamicRangeContent = YES; + metal_layer_.pixelFormat = MTLPixelFormatRGBA16Float; const CFStringRef name = kCGColorSpaceExtendedSRGB; CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(name); - m_metalLayer.colorspace = colorspace; + metal_layer_.colorspace = colorspace; CGColorSpaceRelease(colorspace); } - m_metalView = [[CocoaMetalView alloc] initWithSystemCocoa:systemCocoa + metal_view_ = [[CocoaMetalView alloc] initWithSystemCocoa:systemCocoa windowCocoa:this frame:rect]; - m_metalView.wantsLayer = YES; - m_metalView.layer = m_metalLayer; - view = m_metalView; + metal_view_.wantsLayer = YES; + metal_view_.layer = metal_layer_; + view = metal_view_; } else { /* Fall back to OpenGL view if there is no Metal support. */ - m_openGLView = [[CocoaOpenGLView alloc] initWithSystemCocoa:systemCocoa + opengl_view_ = [[CocoaOpenGLView alloc] initWithSystemCocoa:systemCocoa windowCocoa:this frame:rect]; - view = m_openGLView; + view = opengl_view_; } - if (m_systemCocoa->m_nativePixel) { + if (system_cocoa_->native_pixel_) { /* Needs to happen early when building with the 10.14 SDK, otherwise * has no effect until resizing the window. */ if ([view respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)]) { @@ -426,10 +426,10 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, } } - m_window.contentView = view; - m_window.initialFirstResponder = view; + window_.contentView = view; + window_.initialFirstResponder = view; - [m_window makeKeyAndOrderFront:nil]; + [window_ makeKeyAndOrderFront:nil]; setDrawingContextType(type); updateDrawingContext(); @@ -437,29 +437,29 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, setTitle(title); - m_tablet = GHOST_TABLET_DATA_NONE; + tablet_ = GHOST_TABLET_DATA_NONE; BlenderWindowDelegate *windowDelegate = [[BlenderWindowDelegate alloc] initWithSystemCocoa:systemCocoa windowCocoa:this]; - m_window.delegate = windowDelegate; + window_.delegate = windowDelegate; - m_window.acceptsMouseMovedEvents = YES; + window_.acceptsMouseMovedEvents = YES; - NSView *contentview = m_window.contentView; + NSView *contentview = window_.contentView; contentview.allowedTouchTypes = (NSTouchTypeMaskDirect | NSTouchTypeMaskIndirect); - [m_window registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, - NSPasteboardTypeString, - NSPasteboardTypeTIFF, - nil]]; + [window_ registerForDraggedTypes:[NSArray arrayWithObjects:NSFilenamesPboardType, + NSPasteboardTypeString, + NSPasteboardTypeTIFF, + nil]]; - if (is_dialog && parentWindow) { - [parentWindow->getViewWindow() addChildWindow:m_window ordered:NSWindowAbove]; - m_window.collectionBehavior = NSWindowCollectionBehaviorFullScreenAuxiliary; + if (is_dialog && parent_window) { + [parent_window->getViewWindow() addChildWindow:window_ ordered:NSWindowAbove]; + window_.collectionBehavior = NSWindowCollectionBehaviorFullScreenAuxiliary; } else { - m_window.collectionBehavior = NSWindowCollectionBehaviorFullScreenPrimary; + window_.collectionBehavior = NSWindowCollectionBehaviorFullScreenPrimary; } if (state == GHOST_kWindowStateFullScreen) { @@ -473,40 +473,40 @@ GHOST_WindowCocoa::GHOST_WindowCocoa(GHOST_SystemCocoa *systemCocoa, GHOST_WindowCocoa::~GHOST_WindowCocoa() { @autoreleasepool { - if (m_customCursor) { - [m_customCursor release]; - m_customCursor = nil; + if (custom_cursor_) { + [custom_cursor_ release]; + custom_cursor_ = nil; } releaseNativeHandles(); - if (m_openGLView) { - [m_openGLView release]; - m_openGLView = nil; + if (opengl_view_) { + [opengl_view_ release]; + opengl_view_ = nil; } - if (m_metalView) { - [m_metalView release]; - m_metalView = nil; + if (metal_view_) { + [metal_view_ release]; + metal_view_ = nil; } - if (m_metalLayer) { - [m_metalLayer release]; - m_metalLayer = nil; + if (metal_layer_) { + [metal_layer_ release]; + metal_layer_ = nil; } - if (m_window) { - [m_window close]; + if (window_) { + [window_ close]; } /* Check for other blender opened windows and make the front-most key * NOTE: for some reason the closed window is still in the list. */ NSArray *windowsList = [NSApp orderedWindows]; for (int a = 0; a < [windowsList count]; a++) { - if (m_window != (BlenderWindow *)[windowsList objectAtIndex:a]) { + if (window_ != (BlenderWindow *)[windowsList objectAtIndex:a]) { [[windowsList objectAtIndex:a] makeKeyWindow]; break; } } - m_window = nil; + window_ = nil; } } @@ -516,13 +516,13 @@ GHOST_WindowCocoa::~GHOST_WindowCocoa() bool GHOST_WindowCocoa::getValid() const { - NSView *view = (m_openGLView) ? m_openGLView : m_metalView; - return GHOST_Window::getValid() && m_window != nullptr && view != nullptr; + NSView *view = (opengl_view_) ? opengl_view_ : metal_view_; + return GHOST_Window::getValid() && window_ != nullptr && view != nullptr; } void *GHOST_WindowCocoa::getOSWindow() const { - return (void *)m_window; + return (void *)window_; } void GHOST_WindowCocoa::setTitle(const char *title) @@ -531,7 +531,7 @@ void GHOST_WindowCocoa::setTitle(const char *title) @autoreleasepool { NSString *windowTitle = [[NSString alloc] initWithCString:title encoding:NSUTF8StringEncoding]; - m_window.title = windowTitle; + window_.title = windowTitle; [windowTitle release]; } @@ -543,7 +543,7 @@ std::string GHOST_WindowCocoa::getTitle() const std::string title; @autoreleasepool { - NSString *windowTitle = m_window.title; + NSString *windowTitle = window_.title; if (windowTitle != nil) { title = windowTitle.UTF8String; } @@ -560,7 +560,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setPath(const char *filepath) encoding:NSUTF8StringEncoding] autorelease]; - m_window.representedFilename = associatedFileName; + window_.representedFilename = associatedFileName; } return GHOST_kSuccess; @@ -569,14 +569,14 @@ GHOST_TSuccess GHOST_WindowCocoa::setPath(const char *filepath) GHOST_TSuccess GHOST_WindowCocoa::applyWindowDecorationStyle() { @autoreleasepool { - if (m_windowDecorationStyleFlags & GHOST_kDecorationColoredTitleBar) { - const float *background_color = m_windowDecorationStyleSettings.colored_titlebar_bg_color; + if (window_decoration_style_flags_ & GHOST_kDecorationColoredTitleBar) { + const float *background_color = window_decoration_style_settings_.colored_titlebar_bg_color; /* Title-bar background color. */ - m_window.backgroundColor = [NSColor colorWithRed:background_color[0] - green:background_color[1] - blue:background_color[2] - alpha:1.0]; + window_.backgroundColor = [NSColor colorWithRed:background_color[0] + green:background_color[1] + blue:background_color[2] + alpha:1.0]; /* Title-bar foreground color. * Use the value component of the title-bar background's HSV representation to determine @@ -588,11 +588,11 @@ GHOST_TSuccess GHOST_WindowCocoa::applyWindowDecorationStyle() const NSAppearanceName win_appearance = hsv_v > 0.5 ? NSAppearanceNameVibrantLight : NSAppearanceNameVibrantDark; - m_window.appearance = [NSAppearance appearanceNamed:win_appearance]; - m_window.titlebarAppearsTransparent = YES; + window_.appearance = [NSAppearance appearanceNamed:win_appearance]; + window_.titlebarAppearsTransparent = YES; } else { - m_window.titlebarAppearsTransparent = NO; + window_.titlebarAppearsTransparent = NO; } } return GHOST_kSuccess; @@ -605,7 +605,7 @@ void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect &bounds) const @autoreleasepool { /* All coordinates are based off the primary screen. */ const NSRect screenFrame = [getPrimaryScreen() visibleFrame]; - const NSRect windowFrame = m_window.frame; + const NSRect windowFrame = window_.frame; /* Flip the Y axis, from bottom left coordinate to top left, which is the expected coordinate * return format for GHOST, even though the Window Manager later reflips it to bottom-left @@ -616,11 +616,11 @@ void GHOST_WindowCocoa::getWindowBounds(GHOST_Rect &bounds) const /* Flip the coordinates vertically from a bottom-left origin to a top-left origin, * as expected by GHOST. */ - bounds.m_b = screenMaxY - windowFrame.origin.y; - bounds.m_t = screenMaxY - windowFrame.origin.y - windowFrame.size.height; + bounds.b_ = screenMaxY - windowFrame.origin.y; + bounds.t_ = screenMaxY - windowFrame.origin.y - windowFrame.size.height; - bounds.m_l = windowFrame.origin.x; - bounds.m_r = windowFrame.origin.x + windowFrame.size.width; + bounds.l_ = windowFrame.origin.x; + bounds.r_ = windowFrame.origin.x + windowFrame.size.width; } } @@ -633,21 +633,21 @@ void GHOST_WindowCocoa::getClientBounds(GHOST_Rect &bounds) const const NSRect screenFrame = [getPrimaryScreen() visibleFrame]; /* Screen Content Rectangle (excluding Menu Bar and Dock). */ const NSRect screenContentRect = [NSWindow contentRectForFrameRect:screenFrame - styleMask:[m_window styleMask]]; + styleMask:[window_ styleMask]]; - const NSRect windowFrame = m_window.frame; + const NSRect windowFrame = window_.frame; /* Window Content Rectangle (excluding Titlebar and borders) */ - const NSRect windowContentRect = [m_window contentRectForFrameRect:windowFrame]; + const NSRect windowContentRect = [window_ contentRectForFrameRect:windowFrame]; const int32_t screenMaxY = screenContentRect.origin.y + screenContentRect.size.height; /* Flip the coordinates vertically from a bottom-left origin to a top-left origin, * as expected by GHOST. */ - bounds.m_b = screenMaxY - windowContentRect.origin.y; - bounds.m_t = screenMaxY - windowContentRect.origin.y - windowContentRect.size.height; + bounds.b_ = screenMaxY - windowContentRect.origin.y; + bounds.t_ = screenMaxY - windowContentRect.origin.y - windowContentRect.size.height; - bounds.m_l = windowContentRect.origin.x; - bounds.m_r = windowContentRect.origin.x + windowContentRect.size.width; + bounds.l_ = windowContentRect.origin.x; + bounds.r_ = windowContentRect.origin.x + windowContentRect.size.width; } } @@ -661,7 +661,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setClientWidth(uint32_t width) if ((uint32_t(cBnds.getWidth())) != width) { const NSSize size = {(CGFloat)width, (CGFloat)cBnds.getHeight()}; - [m_window setContentSize:size]; + [window_ setContentSize:size]; } } return GHOST_kSuccess; @@ -677,7 +677,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setClientHeight(uint32_t height) if ((uint32_t(cBnds.getHeight())) != height) { const NSSize size = {(CGFloat)cBnds.getWidth(), (CGFloat)height}; - [m_window setContentSize:size]; + [window_ setContentSize:size]; } } return GHOST_kSuccess; @@ -692,7 +692,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setClientSize(uint32_t width, uint32_t height) getClientBounds(cBnds); if (((uint32_t(cBnds.getWidth())) != width) || ((uint32_t(cBnds.getHeight())) != height)) { const NSSize size = {(CGFloat)width, (CGFloat)height}; - [m_window setContentSize:size]; + [window_ setContentSize:size]; } } return GHOST_kSuccess; @@ -703,22 +703,22 @@ GHOST_TWindowState GHOST_WindowCocoa::getState() const GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::getState(): window invalid"); @autoreleasepool { - NSUInteger masks = m_window.styleMask; + NSUInteger masks = window_.styleMask; if (masks & NSWindowStyleMaskFullScreen) { /* Lion style full-screen. */ - if (!m_immediateDraw) { + if (!immediate_draw_) { return GHOST_kWindowStateFullScreen; } return GHOST_kWindowStateNormal; } - if (m_window.isMiniaturized) { + if (window_.isMiniaturized) { return GHOST_kWindowStateMinimized; } - if (m_window.isZoomed) { + if (window_.isZoomed) { return GHOST_kWindowStateMaximized; } - if (m_immediateDraw) { + if (immediate_draw_) { return GHOST_kWindowStateFullScreen; } return GHOST_kWindowStateNormal; @@ -763,7 +763,7 @@ void GHOST_WindowCocoa::screenToClientIntern(int32_t inX, NSRect screenCoord; screenCoord.origin = {(CGFloat)inX, (CGFloat)inY}; - const NSRect baseCoord = [m_window convertRectFromScreen:screenCoord]; + const NSRect baseCoord = [window_ convertRectFromScreen:screenCoord]; outX = baseCoord.origin.x; outY = baseCoord.origin.y; @@ -777,7 +777,7 @@ void GHOST_WindowCocoa::clientToScreenIntern(int32_t inX, NSRect baseCoord; baseCoord.origin = {(CGFloat)inX, (CGFloat)inY}; - const NSRect screenCoord = [m_window convertRectToScreen:baseCoord]; + const NSRect screenCoord = [window_ convertRectToScreen:baseCoord]; outX = screenCoord.origin.x; outY = screenCoord.origin.y; @@ -785,7 +785,7 @@ void GHOST_WindowCocoa::clientToScreenIntern(int32_t inX, NSScreen *GHOST_WindowCocoa::getScreen() const { - return m_window.screen; + return window_.screen; } NSScreen *GHOST_WindowCocoa::getPrimaryScreen() @@ -797,13 +797,13 @@ NSScreen *GHOST_WindowCocoa::getPrimaryScreen() /* called for event, when window leaves monitor to another */ void GHOST_WindowCocoa::setNativePixelSize() { - NSView *view = (m_openGLView) ? m_openGLView : m_metalView; + NSView *view = (opengl_view_) ? opengl_view_ : metal_view_; const NSRect backingBounds = [view convertRectToBacking:[view bounds]]; GHOST_Rect rect; getClientBounds(rect); - m_nativePixelSize = float(backingBounds.size.width) / float(rect.getWidth()); + native_pixel_size_ = float(backingBounds.size.width) / float(rect.getWidth()); } /** @@ -820,34 +820,34 @@ GHOST_TSuccess GHOST_WindowCocoa::setState(GHOST_TWindowState state) @autoreleasepool { switch (state) { case GHOST_kWindowStateMinimized: - [m_window miniaturize:nil]; + [window_ miniaturize:nil]; break; case GHOST_kWindowStateMaximized: - [m_window zoom:nil]; + [window_ zoom:nil]; break; case GHOST_kWindowStateFullScreen: { - const NSUInteger masks = m_window.styleMask; + const NSUInteger masks = window_.styleMask; if (!(masks & NSWindowStyleMaskFullScreen)) { - [m_window toggleFullScreen:nil]; + [window_ toggleFullScreen:nil]; } break; } case GHOST_kWindowStateNormal: default: @autoreleasepool { - const NSUInteger masks = m_window.styleMask; + const NSUInteger masks = window_.styleMask; if (masks & NSWindowStyleMaskFullScreen) { /* Lion style full-screen. */ - [m_window toggleFullScreen:nil]; + [window_ toggleFullScreen:nil]; } - else if (m_window.isMiniaturized) { - [m_window deminiaturize:nil]; + else if (window_.isMiniaturized) { + [window_ deminiaturize:nil]; } - else if (m_window.isZoomed) { - [m_window zoom:nil]; + else if (window_.isZoomed) { + [window_ zoom:nil]; } } break; @@ -856,12 +856,12 @@ GHOST_TSuccess GHOST_WindowCocoa::setState(GHOST_TWindowState state) return GHOST_kSuccess; } -GHOST_TSuccess GHOST_WindowCocoa::setModifiedState(bool isUnsavedChanges) +GHOST_TSuccess GHOST_WindowCocoa::setModifiedState(bool is_unsaved_changes) { @autoreleasepool { - m_window.documentEdited = isUnsavedChanges; + window_.documentEdited = is_unsaved_changes; } - return GHOST_Window::setModifiedState(isUnsavedChanges); + return GHOST_Window::setModifiedState(is_unsaved_changes); } GHOST_TSuccess GHOST_WindowCocoa::setOrder(GHOST_TWindowOrder order) @@ -871,12 +871,12 @@ GHOST_TSuccess GHOST_WindowCocoa::setOrder(GHOST_TWindowOrder order) @autoreleasepool { if (order == GHOST_kWindowOrderTop) { [NSApp activateIgnoringOtherApps:YES]; - [m_window makeKeyAndOrderFront:nil]; + [window_ makeKeyAndOrderFront:nil]; } else { NSArray *windowsList; - [m_window orderBack:nil]; + [window_ orderBack:nil]; /* Check for other blender opened windows and make the front-most key. */ windowsList = [NSApp orderedWindows]; @@ -898,7 +898,7 @@ GHOST_Context *GHOST_WindowCocoa::newDrawingContext(GHOST_TDrawingContextType ty #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { GHOST_Context *context = new GHOST_ContextVK( - m_want_context_params, m_metalLayer, 1, 2, true, m_preferred_device); + want_context_params_, metal_layer_, 1, 2, true, preferred_device_); if (context->initializeDrawingContext()) { return context; } @@ -910,7 +910,7 @@ GHOST_Context *GHOST_WindowCocoa::newDrawingContext(GHOST_TDrawingContextType ty #ifdef WITH_METAL_BACKEND case GHOST_kDrawingContextTypeMetal: { GHOST_Context *context = new GHOST_ContextMTL( - m_want_context_params, m_metalView, m_metalLayer); + want_context_params_, metal_view_, metal_layer_); if (context->initializeDrawingContext()) { return context; } @@ -934,7 +934,7 @@ GHOST_TSuccess GHOST_WindowCocoa::invalidate() GHOST_ASSERT(getValid(), "GHOST_WindowCocoa::invalidate(): window invalid"); @autoreleasepool { - NSView *view = (m_openGLView) ? m_openGLView : m_metalView; + NSView *view = (opengl_view_) ? opengl_view_ : metal_view_; view.needsDisplay = YES; } return GHOST_kSuccess; @@ -976,7 +976,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setProgressBar(float progress) [NSApp setApplicationIconImage:dockIcon]; [dockIcon release]; - m_progressBarVisible = true; + progress_bar_visible_ = true; } } return GHOST_kSuccess; @@ -984,10 +984,10 @@ GHOST_TSuccess GHOST_WindowCocoa::setProgressBar(float progress) GHOST_TSuccess GHOST_WindowCocoa::endProgressBar() { - if (!m_progressBarVisible) { + if (!progress_bar_visible_) { return GHOST_kFailure; } - m_progressBarVisible = false; + progress_bar_visible_ = false; /* Reset application icon to remove the progress bar. */ @autoreleasepool { @@ -1040,8 +1040,8 @@ NSCursor *GHOST_WindowCocoa::getStandardCursor(GHOST_TStandardCursor shape) cons @autoreleasepool { switch (shape) { case GHOST_kStandardCursorCustom: - if (m_customCursor) { - return m_customCursor; + if (custom_cursor_) { + return custom_cursor_; } else { return nullptr; @@ -1158,13 +1158,13 @@ void GHOST_WindowCocoa::loadCursor(bool visible, GHOST_TStandardCursor shape) co bool GHOST_WindowCocoa::isDialog() const { - return m_is_dialog; + return is_dialog_; } GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorVisibility(bool visible) { @autoreleasepool { - if (m_window.isVisible) { + if (window_.isVisible) { loadCursor(visible, getCursorShape()); } } @@ -1178,7 +1178,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(GHOST_TGrabCursorMode mode /* No need to perform grab without warp as it is always enabled in OS X. */ if (mode != GHOST_kGrabNormal) { @autoreleasepool { - m_systemCocoa->getCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]); + system_cocoa_->getCursorPosition(cursor_grab_init_pos_[0], cursor_grab_init_pos_[1]); setCursorGrabAccum(0, 0); if (mode == GHOST_kGrabHide) { @@ -1186,20 +1186,20 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(GHOST_TGrabCursorMode mode } /* Make window key if it wasn't to get the mouse move events. */ - [m_window makeKeyWindow]; + [window_ makeKeyWindow]; } } } else { - if (m_cursorGrab == GHOST_kGrabHide) { - m_systemCocoa->setCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]); + if (cursor_grab_ == GHOST_kGrabHide) { + system_cocoa_->setCursorPosition(cursor_grab_init_pos_[0], cursor_grab_init_pos_[1]); setWindowCursorVisibility(true); } /* Almost works without but important otherwise the mouse GHOST location * can be incorrect on exit. */ setCursorGrabAccum(0, 0); - m_cursorGrabBounds.m_l = m_cursorGrabBounds.m_r = -1; /* disable */ + cursor_grab_bounds_.l_ = cursor_grab_bounds_.r_ = -1; /* disable */ } } return GHOST_kSuccess; @@ -1208,7 +1208,7 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorGrab(GHOST_TGrabCursorMode mode GHOST_TSuccess GHOST_WindowCocoa::setWindowCursorShape(GHOST_TStandardCursor shape) { @autoreleasepool { - if (m_window.isVisible) { + if (window_.isVisible) { loadCursor(getCursorVisibility(), shape); } } @@ -1251,9 +1251,9 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(const uint8_t *bitm const bool can_invert_color) { @autoreleasepool { - if (m_customCursor) { - [m_customCursor release]; - m_customCursor = nil; + if (custom_cursor_) { + [custom_cursor_ release]; + custom_cursor_ = nil; } NSBitmapImageRep *cursorImageRep = [[NSBitmapImageRep alloc] @@ -1294,12 +1294,12 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(const uint8_t *bitm const NSPoint hotSpotPoint = {(CGFloat)(hot_spot[0]), (CGFloat)(hot_spot[1])}; /* Foreground and background color parameter is not handled for now (10.6). */ - m_customCursor = [[NSCursor alloc] initWithImage:cursorImage hotSpot:hotSpotPoint]; + custom_cursor_ = [[NSCursor alloc] initWithImage:cursorImage hotSpot:hotSpotPoint]; [cursorImageRep release]; [cursorImage release]; - if (m_window.isVisible) { + if (window_.isVisible) { loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom); } } @@ -1309,21 +1309,21 @@ GHOST_TSuccess GHOST_WindowCocoa::setWindowCustomCursorShape(const uint8_t *bitm #ifdef WITH_INPUT_IME void GHOST_WindowCocoa::beginIME(int32_t x, int32_t y, int32_t w, int32_t h, bool completed) { - if (m_openGLView) { - [m_openGLView beginIME:x y:y w:w h:h completed:completed]; + if (opengl_view_) { + [opengl_view_ beginIME:x y:y w:w h:h completed:completed]; } else { - [m_metalView beginIME:x y:y w:w h:h completed:completed]; + [metal_view_ beginIME:x y:y w:w h:h completed:completed]; } } void GHOST_WindowCocoa::endIME() { - if (m_openGLView) { - [m_openGLView endIME]; + if (opengl_view_) { + [opengl_view_ endIME]; } else { - [m_metalView endIME]; + [metal_view_ endIME]; } } #endif /* WITH_INPUT_IME */ diff --git a/intern/ghost/intern/GHOST_WindowManager.cc b/intern/ghost/intern/GHOST_WindowManager.cc index 6ad85a7d6fb..f8e761239b9 100644 --- a/intern/ghost/intern/GHOST_WindowManager.cc +++ b/intern/ghost/intern/GHOST_WindowManager.cc @@ -15,9 +15,9 @@ #include "GHOST_Window.hh" #include -GHOST_WindowManager::GHOST_WindowManager() : m_activeWindow(nullptr) {} +GHOST_WindowManager::GHOST_WindowManager() : active_window_(nullptr) {} -/* m_windows is freed by GHOST_System::disposeWindow */ +/* windows_ is freed by GHOST_System::disposeWindow */ GHOST_WindowManager::~GHOST_WindowManager() = default; GHOST_TSuccess GHOST_WindowManager::addWindow(GHOST_IWindow *window) @@ -26,7 +26,7 @@ GHOST_TSuccess GHOST_WindowManager::addWindow(GHOST_IWindow *window) if (window) { if (!getWindowFound(window)) { /* Store the pointer to the window. */ - m_windows.push_back(window); + windows_.push_back(window); success = GHOST_kSuccess; } } @@ -37,11 +37,10 @@ GHOST_TSuccess GHOST_WindowManager::removeWindow(const GHOST_IWindow *window) { GHOST_TSuccess success = GHOST_kFailure; if (window) { - std::vector::iterator result = find( - m_windows.begin(), m_windows.end(), window); - if (result != m_windows.end()) { + std::vector::iterator result = find(windows_.begin(), windows_.end(), window); + if (result != windows_.end()) { setWindowInactive(window); - m_windows.erase(result); + windows_.erase(result); success = GHOST_kSuccess; } } @@ -53,8 +52,8 @@ bool GHOST_WindowManager::getWindowFound(const GHOST_IWindow *window) const bool found = false; if (window) { std::vector::const_iterator result = find( - m_windows.begin(), m_windows.end(), window); - if (result != m_windows.end()) { + windows_.begin(), windows_.end(), window); + if (result != windows_.end()) { found = true; } } @@ -64,9 +63,9 @@ bool GHOST_WindowManager::getWindowFound(const GHOST_IWindow *window) const GHOST_TSuccess GHOST_WindowManager::setActiveWindow(GHOST_IWindow *window) { GHOST_TSuccess success = GHOST_kSuccess; - if (window != m_activeWindow) { + if (window != active_window_) { if (getWindowFound(window)) { - m_activeWindow = window; + active_window_ = window; } else { success = GHOST_kFailure; @@ -77,26 +76,26 @@ GHOST_TSuccess GHOST_WindowManager::setActiveWindow(GHOST_IWindow *window) GHOST_IWindow *GHOST_WindowManager::getActiveWindow() const { - return m_activeWindow; + return active_window_; } void GHOST_WindowManager::setWindowInactive(const GHOST_IWindow *window) { - if (window == m_activeWindow) { - m_activeWindow = nullptr; + if (window == active_window_) { + active_window_ = nullptr; } } const std::vector &GHOST_WindowManager::getWindows() const { - return m_windows; + return windows_; } GHOST_IWindow *GHOST_WindowManager::getWindowAssociatedWithOSWindow(const void *osWindow) { std::vector::iterator iter; - for (iter = m_windows.begin(); iter != m_windows.end(); ++iter) { + for (iter = windows_.begin(); iter != windows_.end(); ++iter) { if ((*iter)->getOSWindow() == osWindow) { return *iter; } diff --git a/intern/ghost/intern/GHOST_WindowManager.hh b/intern/ghost/intern/GHOST_WindowManager.hh index 645e484f3a3..38d08725399 100644 --- a/intern/ghost/intern/GHOST_WindowManager.hh +++ b/intern/ghost/intern/GHOST_WindowManager.hh @@ -86,10 +86,10 @@ class GHOST_WindowManager { protected: /** The list of windows managed */ - std::vector m_windows; + std::vector windows_; /** The active window. */ - GHOST_IWindow *m_activeWindow; + GHOST_IWindow *active_window_; MEM_CXX_CLASS_ALLOC_FUNCS("GHOST:GHOST_WindowManager") }; diff --git a/intern/ghost/intern/GHOST_WindowNULL.hh b/intern/ghost/intern/GHOST_WindowNULL.hh index 490c43853af..b81cf6dd8b1 100644 --- a/intern/ghost/intern/GHOST_WindowNULL.hh +++ b/intern/ghost/intern/GHOST_WindowNULL.hh @@ -17,7 +17,7 @@ class GHOST_SystemHeadless; class GHOST_WindowNULL : public GHOST_Window { public: - GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor /*cursorShape*/) override + GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor /*cursor_shape*/) override { return GHOST_kSuccess; } @@ -28,7 +28,7 @@ class GHOST_WindowNULL : public GHOST_Window { uint32_t width, uint32_t height, GHOST_TWindowState state, - const GHOST_IWindow * /*parentWindow*/, + const GHOST_IWindow * /*parent_window*/, GHOST_TDrawingContextType /*type*/, const GHOST_ContextParams &context_params) : GHOST_Window(width, height, state, context_params, false) diff --git a/intern/ghost/intern/GHOST_WindowSDL.cc b/intern/ghost/intern/GHOST_WindowSDL.cc index e9e33df0289..3114ab93b6e 100644 --- a/intern/ghost/intern/GHOST_WindowSDL.cc +++ b/intern/ghost/intern/GHOST_WindowSDL.cc @@ -23,30 +23,30 @@ GHOST_WindowSDL::GHOST_WindowSDL(GHOST_SystemSDL *system, GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, const bool exclusive, - const GHOST_IWindow * /*parentWindow*/) + const GHOST_IWindow * /*parent_window*/) : GHOST_Window(width, height, state, context_params, exclusive), - m_system(system), - m_valid_setup(false), - m_invalid_window(false), - m_sdl_custom_cursor(nullptr) + system_(system), + valid_setup_(false), + invalid_window_(false), + sdl_custom_cursor_(nullptr) { /* creating the window _must_ come after setting attributes */ - m_sdl_win = SDL_CreateWindow(title, - left, - top, - width, - height, - SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN); + sdl_win_ = SDL_CreateWindow(title, + left, + top, + width, + height, + SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN); /* now set up the rendering context. */ if (setDrawingContextType(type) == GHOST_kSuccess) { - m_valid_setup = true; + valid_setup_ = true; GHOST_PRINT("Created window\n"); } if (exclusive) { - SDL_RaiseWindow(m_sdl_win); + SDL_RaiseWindow(sdl_win_); } setTitle(title); @@ -54,13 +54,13 @@ GHOST_WindowSDL::GHOST_WindowSDL(GHOST_SystemSDL *system, GHOST_WindowSDL::~GHOST_WindowSDL() { - if (m_sdl_custom_cursor) { - SDL_FreeCursor(m_sdl_custom_cursor); + if (sdl_custom_cursor_) { + SDL_FreeCursor(sdl_custom_cursor_); } releaseNativeHandles(); - SDL_DestroyWindow(m_sdl_win); + SDL_DestroyWindow(sdl_win_); } GHOST_Context *GHOST_WindowSDL::newDrawingContext(GHOST_TDrawingContextType type) @@ -71,8 +71,8 @@ GHOST_Context *GHOST_WindowSDL::newDrawingContext(GHOST_TDrawingContextType type case GHOST_kDrawingContextTypeOpenGL: { for (int minor = 6; minor >= 3; --minor) { GHOST_Context *context = new GHOST_ContextSDL( - m_want_context_params, - m_sdl_win, + want_context_params_, + sdl_win_, 0, /* Profile bit. */ 4, minor, @@ -96,9 +96,9 @@ GHOST_Context *GHOST_WindowSDL::newDrawingContext(GHOST_TDrawingContextType type GHOST_TSuccess GHOST_WindowSDL::invalidate() { - if (m_invalid_window == false) { - m_system->addDirtyWindow(this); - m_invalid_window = true; + if (invalid_window_ == false) { + system_->addDirtyWindow(this); + invalid_window_ = true; } return GHOST_kSuccess; @@ -108,18 +108,18 @@ GHOST_TSuccess GHOST_WindowSDL::setState(GHOST_TWindowState state) { switch (state) { case GHOST_kWindowStateNormal: - SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE); - SDL_RestoreWindow(m_sdl_win); + SDL_SetWindowFullscreen(sdl_win_, SDL_FALSE); + SDL_RestoreWindow(sdl_win_); break; case GHOST_kWindowStateMaximized: - SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE); - SDL_MaximizeWindow(m_sdl_win); + SDL_SetWindowFullscreen(sdl_win_, SDL_FALSE); + SDL_MaximizeWindow(sdl_win_); break; case GHOST_kWindowStateMinimized: - SDL_MinimizeWindow(m_sdl_win); + SDL_MinimizeWindow(sdl_win_); break; case GHOST_kWindowStateFullScreen: - SDL_SetWindowFullscreen(m_sdl_win, SDL_TRUE); + SDL_SetWindowFullscreen(sdl_win_, SDL_TRUE); break; default: break; @@ -130,7 +130,7 @@ GHOST_TSuccess GHOST_WindowSDL::setState(GHOST_TWindowState state) GHOST_TWindowState GHOST_WindowSDL::getState() const { - Uint32 flags = SDL_GetWindowFlags(m_sdl_win); + Uint32 flags = SDL_GetWindowFlags(sdl_win_); if (flags & SDL_WINDOW_FULLSCREEN) { return GHOST_kWindowStateFullScreen; @@ -146,17 +146,17 @@ GHOST_TWindowState GHOST_WindowSDL::getState() const bool GHOST_WindowSDL::getValid() const { - return GHOST_Window::getValid() && m_valid_setup; + return GHOST_Window::getValid() && valid_setup_; } void GHOST_WindowSDL::setTitle(const char *title) { - SDL_SetWindowTitle(m_sdl_win, title); + SDL_SetWindowTitle(sdl_win_, title); } std::string GHOST_WindowSDL::getTitle() const { - return SDL_GetWindowTitle(m_sdl_win); + return SDL_GetWindowTitle(sdl_win_); } void GHOST_WindowSDL::getWindowBounds(GHOST_Rect &bounds) const @@ -167,34 +167,34 @@ void GHOST_WindowSDL::getWindowBounds(GHOST_Rect &bounds) const void GHOST_WindowSDL::getClientBounds(GHOST_Rect &bounds) const { int x, y, w, h; - SDL_GetWindowSize(m_sdl_win, &w, &h); - SDL_GetWindowPosition(m_sdl_win, &x, &y); + SDL_GetWindowSize(sdl_win_, &w, &h); + SDL_GetWindowPosition(sdl_win_, &x, &y); - bounds.m_l = x; - bounds.m_r = x + w; - bounds.m_t = y; - bounds.m_b = y + h; + bounds.l_ = x; + bounds.r_ = x + w; + bounds.t_ = y; + bounds.b_ = y + h; } GHOST_TSuccess GHOST_WindowSDL::setClientWidth(uint32_t width) { int height; - SDL_GetWindowSize(m_sdl_win, nullptr, &height); - SDL_SetWindowSize(m_sdl_win, width, height); + SDL_GetWindowSize(sdl_win_, nullptr, &height); + SDL_SetWindowSize(sdl_win_, width, height); return GHOST_kSuccess; } GHOST_TSuccess GHOST_WindowSDL::setClientHeight(uint32_t height) { int width; - SDL_GetWindowSize(m_sdl_win, &width, nullptr); - SDL_SetWindowSize(m_sdl_win, width, height); + SDL_GetWindowSize(sdl_win_, &width, nullptr); + SDL_SetWindowSize(sdl_win_, width, height); return GHOST_kSuccess; } GHOST_TSuccess GHOST_WindowSDL::setClientSize(uint32_t width, uint32_t height) { - SDL_SetWindowSize(m_sdl_win, width, height); + SDL_SetWindowSize(sdl_win_, width, height); return GHOST_kSuccess; } @@ -202,7 +202,7 @@ void GHOST_WindowSDL::screenToClient(int32_t inX, int32_t inY, int32_t &outX, in { /* XXXSDL_WEAK_ABS_COORDS */ int x_win, y_win; - SDL_GetWindowPosition(m_sdl_win, &x_win, &y_win); + SDL_GetWindowPosition(sdl_win_, &x_win, &y_win); outX = inX - x_win; outY = inY - y_win; @@ -211,7 +211,7 @@ void GHOST_WindowSDL::clientToScreen(int32_t inX, int32_t inY, int32_t &outX, in { /* XXXSDL_WEAK_ABS_COORDS */ int x_win, y_win; - SDL_GetWindowPosition(m_sdl_win, &x_win, &y_win); + SDL_GetWindowPosition(sdl_win_, &x_win, &y_win); outX = inX + x_win; outY = inY + y_win; @@ -623,14 +623,14 @@ GHOST_TSuccess GHOST_WindowSDL::setWindowCustomCursorShape(const uint8_t *bitmap const int hot_spot[2], bool /*can_invert_color*/) { - if (m_sdl_custom_cursor) { - SDL_FreeCursor(m_sdl_custom_cursor); + if (sdl_custom_cursor_) { + SDL_FreeCursor(sdl_custom_cursor_); } - m_sdl_custom_cursor = sdl_ghost_CreateCursor( + sdl_custom_cursor_ = sdl_ghost_CreateCursor( bitmap, mask, size[0], size[1], hot_spot[0], hot_spot[1]); - SDL_SetCursor(m_sdl_custom_cursor); + SDL_SetCursor(sdl_custom_cursor_); return GHOST_kSuccess; } @@ -642,7 +642,7 @@ GHOST_TSuccess GHOST_WindowSDL::setWindowCursorVisibility(bool visible) uint16_t GHOST_WindowSDL::getDPIHint() { - int displayIndex = SDL_GetWindowDisplayIndex(m_sdl_win); + int displayIndex = SDL_GetWindowDisplayIndex(sdl_win_); if (displayIndex < 0) { return 96; } diff --git a/intern/ghost/intern/GHOST_WindowSDL.hh b/intern/ghost/intern/GHOST_WindowSDL.hh index abe47f58684..053e2464c2a 100644 --- a/intern/ghost/intern/GHOST_WindowSDL.hh +++ b/intern/ghost/intern/GHOST_WindowSDL.hh @@ -26,12 +26,12 @@ class GHOST_SystemSDL; class GHOST_WindowSDL : public GHOST_Window { private: - GHOST_SystemSDL *m_system; - bool m_valid_setup; - bool m_invalid_window; + GHOST_SystemSDL *system_; + bool valid_setup_; + bool invalid_window_; - SDL_Window *m_sdl_win; - SDL_Cursor *m_sdl_custom_cursor; + SDL_Window *sdl_win_; + SDL_Cursor *sdl_custom_cursor_; public: GHOST_WindowSDL(GHOST_SystemSDL *system, @@ -44,14 +44,14 @@ class GHOST_WindowSDL : public GHOST_Window { GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, const bool exclusive = false, - const GHOST_IWindow *parentWindow = nullptr); + const GHOST_IWindow *parent_window = nullptr); ~GHOST_WindowSDL(); /* SDL specific */ SDL_Window *getSDLWindow() { - return m_sdl_win; + return sdl_win_; } GHOST_TSuccess invalidate() override; @@ -63,7 +63,7 @@ class GHOST_WindowSDL : public GHOST_Window { void validate() { - m_invalid_window = false; + invalid_window_ = false; } bool getValid() const override; diff --git a/intern/ghost/intern/GHOST_WindowViewCocoa.hh b/intern/ghost/intern/GHOST_WindowViewCocoa.hh index a03a2171007..c2d2cd0f901 100644 --- a/intern/ghost/intern/GHOST_WindowViewCocoa.hh +++ b/intern/ghost/intern/GHOST_WindowViewCocoa.hh @@ -49,8 +49,8 @@ @implementation COCOA_VIEW_CLASS -@synthesize systemCocoa = m_systemCocoa; -@synthesize windowCocoa = m_windowCocoa; +@synthesize systemCocoa = system_cocoa_; +@synthesize windowCocoa = window_cocoa_; - (instancetype)initWithSystemCocoa:(GHOST_SystemCocoa *)sysCocoa windowCocoa:(GHOST_WindowCocoa *)winCocoa @@ -59,8 +59,8 @@ self = [super init]; if (self) { - m_systemCocoa = sysCocoa; - m_windowCocoa = winCocoa; + system_cocoa_ = sysCocoa; + window_cocoa_ = winCocoa; composing = false; composing_text = nil; @@ -108,7 +108,7 @@ #endif if (!ime_process) { - m_systemCocoa->handleKeyEvent(event); + system_cocoa_->handleKeyEvent(event); } /* Start or continue composing? */ @@ -127,7 +127,7 @@ const int controlCharForKorean = (GHOST_IME_COMPOSITION_EVENT | GHOST_IME_RESULT_EVENT | GHOST_IME_KEY_CONTROL_CHAR); if (((ime.state_flag & controlCharForKorean) == controlCharForKorean)) { - m_systemCocoa->handleKeyEvent(event); + system_cocoa_->handleKeyEvent(event); } ime.state_flag &= ~(GHOST_IME_COMPOSITION_EVENT | GHOST_IME_RESULT_EVENT); @@ -142,19 +142,19 @@ #define HANDLE_KEY_EVENT(eventType) \ -(void)eventType : (NSEvent *)event \ { \ - m_systemCocoa->handleKeyEvent(event); \ + system_cocoa_->handleKeyEvent(event); \ } #define HANDLE_MOUSE_EVENT(eventType) \ -(void)eventType : (NSEvent *)event \ { \ - m_systemCocoa->handleMouseEvent(event); \ + system_cocoa_->handleMouseEvent(event); \ } #define HANDLE_TABLET_EVENT(eventType) \ -(void)eventType : (NSEvent *)event \ { \ - m_systemCocoa->handleMouseEvent(event); \ + system_cocoa_->handleMouseEvent(event); \ } HANDLE_KEY_EVENT(keyUp) @@ -190,12 +190,12 @@ HANDLE_TABLET_EVENT(tabletProximity) } else { [super drawRect:rect]; - m_systemCocoa->handleWindowEvent(GHOST_kEventWindowUpdate, m_windowCocoa); + system_cocoa_->handleWindowEvent(GHOST_kEventWindowUpdate, window_cocoa_); /* For some cases like entering full-screen we need to redraw immediately * so our window does not show blank during the animation */ - if (m_windowCocoa->getImmediateDraw()) { - m_systemCocoa->dispatchEvents(); + if (window_cocoa_->getImmediateDraw()) { + system_cocoa_->dispatchEvents(); } } } @@ -391,7 +391,7 @@ HANDLE_TABLET_EVENT(tabletProximity) - (void)setImeCandidateWinPos:(int32_t)x y:(int32_t)y w:(int32_t)w h:(int32_t)h { int32_t outX, outY; - m_windowCocoa->clientToScreen(x, y, outX, outY); + window_cocoa_->clientToScreen(x, y, outX, outY); ime.candidate_window_position = NSMakeRect((CGFloat)outX, (CGFloat)outY, (CGFloat)w, (CGFloat)h); } @@ -417,8 +417,8 @@ HANDLE_TABLET_EVENT(tabletProximity) - (void)processImeEvent:(GHOST_TEventType)imeEventType { GHOST_Event *event = new GHOST_EventIME( - m_systemCocoa->getMilliSeconds(), imeEventType, m_windowCocoa, &ime.event); - m_systemCocoa->pushEvent(event); + system_cocoa_->getMilliSeconds(), imeEventType, window_cocoa_, &ime.event); + system_cocoa_->pushEvent(event); } - (std::string)convertNSString:(NSString *)inString diff --git a/intern/ghost/intern/GHOST_WindowWayland.cc b/intern/ghost/intern/GHOST_WindowWayland.cc index 1d124e52389..0e4d9e1329f 100644 --- a/intern/ghost/intern/GHOST_WindowWayland.cc +++ b/intern/ghost/intern/GHOST_WindowWayland.cc @@ -1731,7 +1731,7 @@ GHOST_WindowWayland::GHOST_WindowWayland(GHOST_SystemWayland *system, const uint32_t width, const uint32_t height, const GHOST_TWindowState state, - const GHOST_IWindow *parentWindow, + const GHOST_IWindow *parent_window, const GHOST_TDrawingContextType type, const bool is_dialog, const GHOST_ContextParams &context_params, @@ -1813,9 +1813,9 @@ GHOST_WindowWayland::GHOST_WindowWayland(GHOST_SystemWayland *system, libdecor_frame_set_min_content_size(decor.frame, UNPACK2(size_min)); libdecor_frame_set_app_id(decor.frame, xdg_app_id); - if (parentWindow) { + if (parent_window) { GWL_LibDecor_Window &decor_parent = - *dynamic_cast(parentWindow)->window_->libdecor; + *dynamic_cast(parent_window)->window_->libdecor; libdecor_frame_set_parent(decor.frame, decor_parent.frame); } } @@ -1834,9 +1834,9 @@ GHOST_WindowWayland::GHOST_WindowWayland(GHOST_SystemWayland *system, xdg_surface_add_listener(decor.surface, &xdg_surface_listener, window_); xdg_toplevel_add_listener(decor.toplevel, &xdg_toplevel_listener, window_); - if (parentWindow && is_dialog) { + if (parent_window && is_dialog) { GWL_XDG_Decor_Window &decor_parent = - *dynamic_cast(parentWindow)->window_->xdg_decor; + *dynamic_cast(parent_window)->window_->xdg_decor; xdg_toplevel_set_parent(decor.toplevel, decor_parent.toplevel); } } @@ -2172,9 +2172,9 @@ GHOST_TSuccess GHOST_WindowWayland::swapBuffers() } #endif /* USE_EVENT_BACKGROUND_THREAD */ -GHOST_TSuccess GHOST_WindowWayland::hasCursorShape(GHOST_TStandardCursor cursorShape) +GHOST_TSuccess GHOST_WindowWayland::hasCursorShape(GHOST_TStandardCursor cursor_shape) { - return system_->cursor_shape_check(cursorShape); + return system_->cursor_shape_check(cursor_shape); } GHOST_TSuccess GHOST_WindowWayland::setWindowCursorGrab(GHOST_TGrabCursorMode mode) @@ -2185,7 +2185,7 @@ GHOST_TSuccess GHOST_WindowWayland::setWindowCursorGrab(GHOST_TGrabCursorMode mo GHOST_Rect bounds_buf; const GHOST_Rect *bounds = nullptr; - if (m_cursorGrab == GHOST_kGrabWrap) { + if (cursor_grab_ == GHOST_kGrabWrap) { if (getCursorGrabBounds(bounds_buf) == GHOST_kFailure) { getClientBounds(bounds_buf); } @@ -2193,10 +2193,10 @@ GHOST_TSuccess GHOST_WindowWayland::setWindowCursorGrab(GHOST_TGrabCursorMode mo } if (system_->window_cursor_grab_set(mode, - m_cursorGrab, - m_cursorGrabInitPos, + cursor_grab_, + cursor_grab_init_pos_, bounds, - m_cursorGrabAxis, + cursor_grab_axis_, window_->wl.surface, this->scale_params_get())) { @@ -2214,16 +2214,16 @@ GHOST_TSuccess GHOST_WindowWayland::setWindowCursorShape(GHOST_TStandardCursor s const bool is_active = this == static_cast( system_->getWindowManager()->getActiveWindow()); gwl_window_cursor_custom_clear(&window_->cursor_generator); - m_cursorShape = shape; + cursor_shape_ = shape; GHOST_TSuccess ok; if (is_active) { - ok = system_->cursor_shape_set(m_cursorShape); + ok = system_->cursor_shape_set(cursor_shape_); GHOST_TSuccess ok_test = ok; if (ok == GHOST_kFailure) { /* Failed, try again with the default cursor. */ - m_cursorShape = GHOST_kStandardCursorDefault; - ok_test = system_->cursor_shape_set(m_cursorShape); + cursor_shape_ = GHOST_kStandardCursorDefault; + ok_test = system_->cursor_shape_set(cursor_shape_); } wl_display *display = system_->wl_display_get(); @@ -2243,7 +2243,7 @@ GHOST_TSuccess GHOST_WindowWayland::setWindowCursorShape(GHOST_TStandardCursor s /* Set later when activating the window. */ ok = system_->cursor_shape_check(shape); if (ok == GHOST_kFailure) { - m_cursorShape = GHOST_kStandardCursorDefault; + cursor_shape_ = GHOST_kStandardCursorDefault; } } return ok; @@ -2254,7 +2254,7 @@ bool GHOST_WindowWayland::getCursorGrabUseSoftwareDisplay() #ifdef USE_EVENT_BACKGROUND_THREAD std::lock_guard lock_server_guard{*system_->server_mutex}; #endif - return system_->cursor_grab_use_software_display_get(m_cursorGrab); + return system_->cursor_grab_use_software_display_get(cursor_grab_); } GHOST_TSuccess GHOST_WindowWayland::setWindowCustomCursorGenerator( @@ -2264,7 +2264,7 @@ GHOST_TSuccess GHOST_WindowWayland::setWindowCustomCursorGenerator( #ifdef USE_EVENT_BACKGROUND_THREAD std::lock_guard lock_server_guard{*system_->server_mutex}; #endif - m_cursorShape = GHOST_kStandardCursorCustom; + cursor_shape_ = GHOST_kStandardCursorCustom; if (window_->cursor_generator) { gwl_window_cursor_custom_free(window_->cursor_generator); } @@ -2457,13 +2457,13 @@ GHOST_Context *GHOST_WindowWayland::newDrawingContext(GHOST_TDrawingContextType { switch (type) { case GHOST_kDrawingContextTypeNone: { - GHOST_Context *context = new GHOST_ContextNone(m_want_context_params); + GHOST_Context *context = new GHOST_ContextNone(want_context_params_); return context; } #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { - GHOST_ContextVK *context = new GHOST_ContextVK(m_want_context_params, + GHOST_ContextVK *context = new GHOST_ContextVK(want_context_params_, GHOST_kVulkanPlatformWayland, 0, nullptr, @@ -2486,14 +2486,14 @@ GHOST_Context *GHOST_WindowWayland::newDrawingContext(GHOST_TDrawingContextType for (int minor = 6; minor >= 3; --minor) { GHOST_Context *context = new GHOST_ContextEGL( system_, - m_want_context_params, + want_context_params_, EGLNativeWindowType(window_->backend.egl_window), EGLNativeDisplayType(system_->wl_display_get()), EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, 4, minor, GHOST_OPENGL_EGL_CONTEXT_FLAGS | - (m_want_context_params.is_debug ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0), + (want_context_params_.is_debug ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0), GHOST_OPENGL_EGL_RESET_NOTIFICATION_STRATEGY, EGL_OPENGL_API); @@ -2675,7 +2675,7 @@ GHOST_TSuccess GHOST_WindowWayland::cursor_shape_refresh() return GHOST_kSuccess; } #endif - return gwl_window_cursor_shape_refresh(m_cursorShape, window_->cursor_generator, system_); + return gwl_window_cursor_shape_refresh(cursor_shape_, window_->cursor_generator, system_); } void GHOST_WindowWayland::outputs_changed_update_scale_tag() diff --git a/intern/ghost/intern/GHOST_WindowWayland.hh b/intern/ghost/intern/GHOST_WindowWayland.hh index 02e39cbce16..4aeab9e0acf 100644 --- a/intern/ghost/intern/GHOST_WindowWayland.hh +++ b/intern/ghost/intern/GHOST_WindowWayland.hh @@ -64,7 +64,7 @@ struct GWL_Window; class GHOST_WindowWayland : public GHOST_Window { public: - GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor cursorShape) override; + GHOST_TSuccess hasCursorShape(GHOST_TStandardCursor cursor_shape) override; GHOST_WindowWayland(GHOST_SystemWayland *system, const char *title, @@ -73,7 +73,7 @@ class GHOST_WindowWayland : public GHOST_Window { uint32_t width, uint32_t height, GHOST_TWindowState state, - const GHOST_IWindow *parentWindow, + const GHOST_IWindow *parent_window, GHOST_TDrawingContextType type, const bool is_dialog, const GHOST_ContextParams &context_params, diff --git a/intern/ghost/intern/GHOST_WindowWin32.cc b/intern/ghost/intern/GHOST_WindowWin32.cc index 741edd78308..9a72007d791 100644 --- a/intern/ghost/intern/GHOST_WindowWin32.cc +++ b/intern/ghost/intern/GHOST_WindowWin32.cc @@ -60,31 +60,31 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, GHOST_TWindowState state, GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, - GHOST_WindowWin32 *parentwindow, + GHOST_WindowWin32 *parent_window, bool dialog, const GHOST_GPUDevice &preferred_device) : GHOST_Window(width, height, state, context_params, false), - m_mousePresent(false), - m_inLiveResize(false), - m_system(system), - m_dropTarget(nullptr), - m_hWnd(0), - m_hDC(0), - m_isDialog(dialog), - m_preferred_device(preferred_device), - m_hasMouseCaptured(false), - m_hasGrabMouse(false), - m_nPressedButtons(0), - m_customCursor(0), - m_Bar(nullptr), - m_wintab(nullptr), - m_lastPointerTabletData(GHOST_TABLET_DATA_NONE), - m_normal_state(GHOST_kWindowStateNormal), - m_user32(::LoadLibrary("user32.dll")), - m_parentWindowHwnd(parentwindow ? parentwindow->m_hWnd : HWND_DESKTOP), - m_directManipulationHelper(nullptr) + mouse_present_(false), + in_live_resize_(false), + system_(system), + drop_target_(nullptr), + h_wnd_(0), + h_DC_(0), + is_dialog_(dialog), + preferred_device_(preferred_device), + has_mouse_captured_(false), + has_grab_mouse_(false), + n_pressed_buttons_(0), + custom_cursor_(0), + bar_(nullptr), + wintab_(nullptr), + last_pointer_tablet_data_(GHOST_TABLET_DATA_NONE), + normal_state_(GHOST_kWindowStateNormal), + user32_(::LoadLibrary("user32.dll")), + parent_window_hwnd_(parent_window ? parent_window->h_wnd_ : HWND_DESKTOP), + direct_manipulation_helper_(nullptr) { - DWORD style = parentwindow ? + DWORD style = parent_window ? WS_POPUPWINDOW | WS_CAPTION | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SIZEBOX : WS_OVERLAPPEDWINDOW; @@ -93,7 +93,7 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, } /* Forces owned windows onto taskbar and allows minimization. */ - DWORD extended_style = parentwindow ? WS_EX_APPWINDOW : 0; + DWORD extended_style = parent_window ? WS_EX_APPWINDOW : 0; if (dialog) { /* When we are ready to make windows of this type: @@ -106,7 +106,7 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, adjustWindowRectForClosestMonitor(&win_rect, style, extended_style); wchar_t *title_16 = alloc_utf16_from_8((char *)title, 0); - m_hWnd = ::CreateWindowExW(extended_style, /* window extended style */ + h_wnd_ = ::CreateWindowExW(extended_style, /* window extended style */ s_windowClassName, /* pointer to registered class name */ title_16, /* pointer to window name */ style, /* window style */ @@ -114,20 +114,20 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, win_rect.top, /* vertical position of window */ win_rect.right - win_rect.left, /* window width */ win_rect.bottom - win_rect.top, /* window height */ - m_parentWindowHwnd, /* handle to parent or owner window */ + parent_window_hwnd_, /* handle to parent or owner window */ 0, /* handle to menu or child-window identifier */ ::GetModuleHandle(0), /* handle to application instance */ 0); /* pointer to window-creation data */ free(title_16); - if (m_hWnd == nullptr) { + if (h_wnd_ == nullptr) { return; } registerWindowAppUserModelProperties(); /* Store the device context. */ - m_hDC = ::GetDC(m_hWnd); + h_DC_ = ::GetDC(h_wnd_); if (!setDrawingContextType(type)) { const char *title = "Blender - Unsupported Graphics Card Configuration"; @@ -157,34 +157,34 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, "this issue. Installing the latest driver for your graphics card could also help."; } } - MessageBox(m_hWnd, text, title, MB_OK | MB_ICONERROR); - ::ReleaseDC(m_hWnd, m_hDC); - ::DestroyWindow(m_hWnd); - m_hWnd = nullptr; - if (!parentwindow) { + MessageBox(h_wnd_, text, title, MB_OK | MB_ICONERROR); + ::ReleaseDC(h_wnd_, h_DC_); + ::DestroyWindow(h_wnd_); + h_wnd_ = nullptr; + if (!parent_window) { exit(0); } return; } - RegisterTouchWindow(m_hWnd, 0); + RegisterTouchWindow(h_wnd_, 0); /* Register as drop-target. #OleInitialize(0) required first, done in GHOST_SystemWin32. */ - m_dropTarget = new GHOST_DropTargetWin32(this, m_system); - ::RegisterDragDrop(m_hWnd, m_dropTarget); + drop_target_ = new GHOST_DropTargetWin32(this, system_); + ::RegisterDragDrop(h_wnd_, drop_target_); /* Store a pointer to this class in the window structure. */ - ::SetWindowLongPtr(m_hWnd, GWLP_USERDATA, (LONG_PTR)this); + ::SetWindowLongPtr(h_wnd_, GWLP_USERDATA, (LONG_PTR)this); - if (!m_system->m_windowFocus) { + if (!system_->window_focus_) { /* If we don't want focus then lower to bottom. */ - ::SetWindowPos(m_hWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); + ::SetWindowPos(h_wnd_, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE); } - if (parentwindow) { + if (parent_window) { /* Release any parent capture to allow immediate interaction (#90110). */ ::ReleaseCapture(); - parentwindow->lostMouseCapture(); + parent_window->lostMouseCapture(); } /* Show the window. */ @@ -195,17 +195,17 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, nCmdShow = SW_SHOWMAXIMIZED; break; case GHOST_kWindowStateMinimized: - nCmdShow = (m_system->m_windowFocus) ? SW_SHOWMINIMIZED : SW_SHOWMINNOACTIVE; + nCmdShow = (system_->window_focus_) ? SW_SHOWMINIMIZED : SW_SHOWMINNOACTIVE; break; case GHOST_kWindowStateNormal: default: - nCmdShow = (m_system->m_windowFocus) ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE; + nCmdShow = (system_->window_focus_) ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE; break; } ThemeRefresh(); - ::ShowWindow(m_hWnd, nCmdShow); + ::ShowWindow(h_wnd_, nCmdShow); /* Initialize WINTAB. */ if (system->getTabletAPI() != GHOST_kTabletWinPointer) { @@ -214,99 +214,99 @@ GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system, /* Allow the showing of a progress bar on the taskbar. */ CoCreateInstance( - CLSID_TaskbarList, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (LPVOID *)&m_Bar); + CLSID_TaskbarList, nullptr, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (LPVOID *)&bar_); /* Initialize Direct Manipulation. */ - m_directManipulationHelper = GHOST_DirectManipulationHelper::create(m_hWnd, getDPIHint()); + direct_manipulation_helper_ = GHOST_DirectManipulationHelper::create(h_wnd_, getDPIHint()); } void GHOST_WindowWin32::updateDirectManipulation() { - if (!m_directManipulationHelper) { + if (!direct_manipulation_helper_) { return; } - m_directManipulationHelper->update(); + direct_manipulation_helper_->update(); } void GHOST_WindowWin32::onPointerHitTest(WPARAM wParam) { /* Only #DM_POINTERHITTEST can be the first message of input sequence of touch-pad input. */ - if (!m_directManipulationHelper) { + if (!direct_manipulation_helper_) { return; } UINT32 pointerId = GET_POINTERID_WPARAM(wParam); POINTER_INPUT_TYPE pointerType; if (GetPointerType(pointerId, &pointerType) && pointerType == PT_TOUCHPAD) { - m_directManipulationHelper->onPointerHitTest(pointerId); + direct_manipulation_helper_->onPointerHitTest(pointerId); } } GHOST_TTrackpadInfo GHOST_WindowWin32::getTrackpadInfo() { - if (!m_directManipulationHelper) { + if (!direct_manipulation_helper_) { return {0, 0, 0}; } - return m_directManipulationHelper->getTrackpadInfo(); + return direct_manipulation_helper_->getTrackpadInfo(); } GHOST_WindowWin32::~GHOST_WindowWin32() { - if (m_hWnd) { + if (h_wnd_) { unregisterWindowAppUserModelProperties(); } - if (m_Bar) { - m_Bar->SetProgressState(m_hWnd, TBPF_NOPROGRESS); - m_Bar->Release(); - m_Bar = nullptr; + if (bar_) { + bar_->SetProgressState(h_wnd_, TBPF_NOPROGRESS); + bar_->Release(); + bar_ = nullptr; } closeWintab(); - if (m_user32) { - FreeLibrary(m_user32); - m_user32 = nullptr; + if (user32_) { + FreeLibrary(user32_); + user32_ = nullptr; } - if (m_customCursor) { - DestroyCursor(m_customCursor); - m_customCursor = nullptr; + if (custom_cursor_) { + DestroyCursor(custom_cursor_); + custom_cursor_ = nullptr; } - if (m_hWnd != nullptr && m_hDC != nullptr && releaseNativeHandles()) { - ::ReleaseDC(m_hWnd, m_hDC); - m_hDC = nullptr; + if (h_wnd_ != nullptr && h_DC_ != nullptr && releaseNativeHandles()) { + ::ReleaseDC(h_wnd_, h_DC_); + h_DC_ = nullptr; } - if (m_hWnd) { + if (h_wnd_) { /* If this window is referenced by others as parent, clear that relation or windows will free * the handle while we still reference it. */ - for (GHOST_IWindow *iter_win : m_system->getWindowManager()->getWindows()) { + for (GHOST_IWindow *iter_win : system_->getWindowManager()->getWindows()) { GHOST_WindowWin32 *iter_winwin = (GHOST_WindowWin32 *)iter_win; - if (iter_winwin->m_parentWindowHwnd == m_hWnd) { - ::SetWindowLongPtr(iter_winwin->m_hWnd, GWLP_HWNDPARENT, 0); - iter_winwin->m_parentWindowHwnd = 0; + if (iter_winwin->parent_window_hwnd_ == h_wnd_) { + ::SetWindowLongPtr(iter_winwin->h_wnd_, GWLP_HWNDPARENT, 0); + iter_winwin->parent_window_hwnd_ = 0; } } - if (m_dropTarget) { + if (drop_target_) { /* Disable DragDrop. */ - RevokeDragDrop(m_hWnd); + RevokeDragDrop(h_wnd_); /* Release our reference of the DropTarget and it will delete itself eventually. */ - m_dropTarget->Release(); - m_dropTarget = nullptr; + drop_target_->Release(); + drop_target_ = nullptr; } - ::SetWindowLongPtr(m_hWnd, GWLP_USERDATA, 0); - ::DestroyWindow(m_hWnd); - m_hWnd = 0; + ::SetWindowLongPtr(h_wnd_, GWLP_USERDATA, 0); + ::DestroyWindow(h_wnd_); + h_wnd_ = 0; } - delete m_directManipulationHelper; - m_directManipulationHelper = nullptr; + delete direct_manipulation_helper_; + direct_manipulation_helper_ = nullptr; } void GHOST_WindowWin32::adjustWindowRectForClosestMonitor(LPRECT win_rect, @@ -330,9 +330,9 @@ void GHOST_WindowWin32::adjustWindowRectForClosestMonitor(LPRECT win_rect, /* With Windows 10 and newer we can adjust for chrome that differs with DPI and scale. */ GHOST_WIN32_AdjustWindowRectExForDpi fpAdjustWindowRectExForDpi = nullptr; - if (m_user32) { + if (user32_) { fpAdjustWindowRectExForDpi = (GHOST_WIN32_AdjustWindowRectExForDpi)::GetProcAddress( - m_user32, "AdjustWindowRectExForDpi"); + user32_, "AdjustWindowRectExForDpi"); } /* Adjust to allow for caption, borders, shadows, scaling, etc. Resulting values can be @@ -352,30 +352,30 @@ void GHOST_WindowWin32::adjustWindowRectForClosestMonitor(LPRECT win_rect, bool GHOST_WindowWin32::getValid() const { - return GHOST_Window::getValid() && m_hWnd != 0 && m_hDC != 0; + return GHOST_Window::getValid() && h_wnd_ != 0 && h_DC_ != 0; } HWND GHOST_WindowWin32::getHWND() const { - return m_hWnd; + return h_wnd_; } void *GHOST_WindowWin32::getOSWindow() const { - return (void *)m_hWnd; + return (void *)h_wnd_; } void GHOST_WindowWin32::setTitle(const char *title) { wchar_t *title_16 = alloc_utf16_from_8((char *)title, 0); - ::SetWindowTextW(m_hWnd, (wchar_t *)title_16); + ::SetWindowTextW(h_wnd_, (wchar_t *)title_16); free(title_16); } std::string GHOST_WindowWin32::getTitle() const { - std::wstring wtitle(::GetWindowTextLengthW(m_hWnd) + 1, L'\0'); - ::GetWindowTextW(m_hWnd, &wtitle[0], wtitle.capacity()); + std::wstring wtitle(::GetWindowTextLengthW(h_wnd_) + 1, L'\0'); + ::GetWindowTextW(h_wnd_, &wtitle[0], wtitle.capacity()); std::string title(count_utf_8_from_16(wtitle.c_str()) + 1, '\0'); conv_utf_16_to_8(wtitle.c_str(), &title[0], title.capacity()); @@ -388,11 +388,11 @@ GHOST_TSuccess GHOST_WindowWin32::applyWindowDecorationStyle() /* DWMWINDOWATTRIBUTE::DWMWA_CAPTION_COLOR */ constexpr DWORD caption_color_attr = 35; - if (m_windowDecorationStyleFlags & GHOST_kDecorationColoredTitleBar) { - const float *color = m_windowDecorationStyleSettings.colored_titlebar_bg_color; + if (window_decoration_style_flags_ & GHOST_kDecorationColoredTitleBar) { + const float *color = window_decoration_style_settings_.colored_titlebar_bg_color; const COLORREF colorref = RGB( char(color[0] * 255.0f), char(color[1] * 255.0f), char(color[2] * 255.0f)); - if (!SUCCEEDED(DwmSetWindowAttribute(m_hWnd, caption_color_attr, &colorref, sizeof(colorref)))) + if (!SUCCEEDED(DwmSetWindowAttribute(h_wnd_, caption_color_attr, &colorref, sizeof(colorref)))) { return GHOST_kFailure; } @@ -403,39 +403,39 @@ GHOST_TSuccess GHOST_WindowWin32::applyWindowDecorationStyle() void GHOST_WindowWin32::getWindowBounds(GHOST_Rect &bounds) const { RECT rect; - ::GetWindowRect(m_hWnd, &rect); - bounds.m_b = rect.bottom; - bounds.m_l = rect.left; - bounds.m_r = rect.right; - bounds.m_t = rect.top; + ::GetWindowRect(h_wnd_, &rect); + bounds.b_ = rect.bottom; + bounds.l_ = rect.left; + bounds.r_ = rect.right; + bounds.t_ = rect.top; } void GHOST_WindowWin32::getClientBounds(GHOST_Rect &bounds) const { RECT rect; POINT coord; - if (!IsIconic(m_hWnd)) { - ::GetClientRect(m_hWnd, &rect); + if (!IsIconic(h_wnd_)) { + ::GetClientRect(h_wnd_, &rect); coord.x = rect.left; coord.y = rect.top; - ::ClientToScreen(m_hWnd, &coord); + ::ClientToScreen(h_wnd_, &coord); - bounds.m_l = coord.x; - bounds.m_t = coord.y; + bounds.l_ = coord.x; + bounds.t_ = coord.y; coord.x = rect.right; coord.y = rect.bottom; - ::ClientToScreen(m_hWnd, &coord); + ::ClientToScreen(h_wnd_, &coord); - bounds.m_r = coord.x; - bounds.m_b = coord.y; + bounds.r_ = coord.x; + bounds.b_ = coord.y; } else { - bounds.m_b = 0; - bounds.m_l = 0; - bounds.m_r = 0; - bounds.m_t = 0; + bounds.b_ = 0; + bounds.l_ = 0; + bounds.r_ = 0; + bounds.t_ = 0; } } @@ -448,7 +448,7 @@ GHOST_TSuccess GHOST_WindowWin32::setClientWidth(uint32_t width) getWindowBounds(wBnds); int cx = wBnds.getWidth() + width - cBnds.getWidth(); int cy = wBnds.getHeight(); - success = ::SetWindowPos(m_hWnd, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? + success = ::SetWindowPos(h_wnd_, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? GHOST_kSuccess : GHOST_kFailure; } @@ -467,7 +467,7 @@ GHOST_TSuccess GHOST_WindowWin32::setClientHeight(uint32_t height) getWindowBounds(wBnds); int cx = wBnds.getWidth(); int cy = wBnds.getHeight() + height - cBnds.getHeight(); - success = ::SetWindowPos(m_hWnd, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? + success = ::SetWindowPos(h_wnd_, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? GHOST_kSuccess : GHOST_kFailure; } @@ -486,7 +486,7 @@ GHOST_TSuccess GHOST_WindowWin32::setClientSize(uint32_t width, uint32_t height) getWindowBounds(wBnds); int cx = wBnds.getWidth() + width - cBnds.getWidth(); int cy = wBnds.getHeight() + height - cBnds.getHeight(); - success = ::SetWindowPos(m_hWnd, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? + success = ::SetWindowPos(h_wnd_, HWND_TOP, 0, 0, cx, cy, SWP_NOMOVE | SWP_NOZORDER) ? GHOST_kSuccess : GHOST_kFailure; } @@ -498,11 +498,11 @@ GHOST_TSuccess GHOST_WindowWin32::setClientSize(uint32_t width, uint32_t height) GHOST_TWindowState GHOST_WindowWin32::getState() const { - if (::IsIconic(m_hWnd)) { + if (::IsIconic(h_wnd_)) { return GHOST_kWindowStateMinimized; } - else if (::IsZoomed(m_hWnd)) { - LONG_PTR result = ::GetWindowLongPtr(m_hWnd, GWL_STYLE); + else if (::IsZoomed(h_wnd_)) { + LONG_PTR result = ::GetWindowLongPtr(h_wnd_, GWL_STYLE); return (result & WS_CAPTION) ? GHOST_kWindowStateMaximized : GHOST_kWindowStateFullScreen; } return GHOST_kWindowStateNormal; @@ -514,7 +514,7 @@ void GHOST_WindowWin32::screenToClient(int32_t inX, int32_t &outY) const { POINT point = {inX, inY}; - ::ScreenToClient(m_hWnd, &point); + ::ScreenToClient(h_wnd_, &point); outX = point.x; outY = point.y; } @@ -525,7 +525,7 @@ void GHOST_WindowWin32::clientToScreen(int32_t inX, int32_t &outY) const { POINT point = {inX, inY}; - ::ClientToScreen(m_hWnd, &point); + ::ClientToScreen(h_wnd_, &point); outX = point.x; outY = point.y; } @@ -533,10 +533,10 @@ void GHOST_WindowWin32::clientToScreen(int32_t inX, GHOST_TSuccess GHOST_WindowWin32::setState(GHOST_TWindowState state) { GHOST_TWindowState curstate = getState(); - LONG_PTR style = GetWindowLongPtr(m_hWnd, GWL_STYLE) | WS_CAPTION; + LONG_PTR style = GetWindowLongPtr(h_wnd_, GWL_STYLE) | WS_CAPTION; WINDOWPLACEMENT wp; wp.length = sizeof(WINDOWPLACEMENT); - ::GetWindowPlacement(m_hWnd, &wp); + ::GetWindowPlacement(h_wnd_, &wp); switch (state) { case GHOST_kWindowStateMinimized: @@ -547,7 +547,7 @@ GHOST_TSuccess GHOST_WindowWin32::setState(GHOST_TWindowState state) break; case GHOST_kWindowStateFullScreen: if (curstate != state && curstate != GHOST_kWindowStateMinimized) { - m_normal_state = curstate; + normal_state_ = curstate; } wp.showCmd = SW_SHOWMAXIMIZED; wp.ptMaxPosition.x = 0; @@ -556,22 +556,21 @@ GHOST_TSuccess GHOST_WindowWin32::setState(GHOST_TWindowState state) break; case GHOST_kWindowStateNormal: default: - if (curstate == GHOST_kWindowStateFullScreen && - m_normal_state == GHOST_kWindowStateMaximized) + if (curstate == GHOST_kWindowStateFullScreen && normal_state_ == GHOST_kWindowStateMaximized) { wp.showCmd = SW_SHOWMAXIMIZED; - m_normal_state = GHOST_kWindowStateNormal; + normal_state_ = GHOST_kWindowStateNormal; } else { wp.showCmd = SW_SHOWNORMAL; } break; } - ::SetWindowLongPtr(m_hWnd, GWL_STYLE, style); + ::SetWindowLongPtr(h_wnd_, GWL_STYLE, style); /* #SetWindowLongPtr Docs: * Frame changes not visible until #SetWindowPos with #SWP_FRAMECHANGED. */ - ::SetWindowPos(m_hWnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); - return ::SetWindowPlacement(m_hWnd, &wp) == TRUE ? GHOST_kSuccess : GHOST_kFailure; + ::SetWindowPos(h_wnd_, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED); + return ::SetWindowPlacement(h_wnd_, &wp) == TRUE ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_WindowWin32::setOrder(GHOST_TWindowOrder order) @@ -580,7 +579,7 @@ GHOST_TSuccess GHOST_WindowWin32::setOrder(GHOST_TWindowOrder order) if (order == GHOST_kWindowOrderBottom) { hWndInsertAfter = HWND_BOTTOM; - hWndToRaise = ::GetWindow(m_hWnd, GW_HWNDNEXT); /* the window to raise */ + hWndToRaise = ::GetWindow(h_wnd_, GW_HWNDNEXT); /* the window to raise */ } else { if (getState() == GHOST_kWindowStateMinimized) { @@ -590,7 +589,7 @@ GHOST_TSuccess GHOST_WindowWin32::setOrder(GHOST_TWindowOrder order) hWndToRaise = nullptr; } - if (::SetWindowPos(m_hWnd, hWndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE) == FALSE) { + if (::SetWindowPos(h_wnd_, hWndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE) == FALSE) { return GHOST_kFailure; } @@ -605,8 +604,8 @@ GHOST_TSuccess GHOST_WindowWin32::setOrder(GHOST_TWindowOrder order) GHOST_TSuccess GHOST_WindowWin32::invalidate() { GHOST_TSuccess success; - if (m_hWnd) { - success = ::InvalidateRect(m_hWnd, 0, FALSE) != 0 ? GHOST_kSuccess : GHOST_kFailure; + if (h_wnd_) { + success = ::InvalidateRect(h_wnd_, 0, FALSE) != 0 ? GHOST_kSuccess : GHOST_kFailure; } else { success = GHOST_kFailure; @@ -620,7 +619,7 @@ GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType ty #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { GHOST_Context *context = new GHOST_ContextVK( - m_want_context_params, m_hWnd, 1, 2, m_preferred_device); + want_context_params_, h_wnd_, 1, 2, preferred_device_); if (context->initializeDrawingContext()) { return context; } @@ -633,14 +632,14 @@ GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType ty case GHOST_kDrawingContextTypeOpenGL: { for (int minor = 6; minor >= 3; --minor) { GHOST_Context *context = new GHOST_ContextWGL( - m_want_context_params, + want_context_params_, false, - m_hWnd, - m_hDC, + h_wnd_, + h_DC_, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, 4, minor, - (m_want_context_params.is_debug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0), + (want_context_params_.is_debug ? WGL_CONTEXT_DEBUG_BIT_ARB : 0), GHOST_OPENGL_WGL_RESET_NOTIFICATION_STRATEGY); if (context->initializeDrawingContext()) { @@ -653,7 +652,7 @@ GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType ty #endif case GHOST_kDrawingContextTypeD3D: { - GHOST_Context *context = new GHOST_ContextD3D(m_want_context_params, m_hWnd); + GHOST_Context *context = new GHOST_ContextD3D(want_context_params_, h_wnd_); if (context->initializeDrawingContext()) { return context; @@ -670,44 +669,44 @@ GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType ty void GHOST_WindowWin32::lostMouseCapture() { - if (m_hasMouseCaptured) { - m_hasGrabMouse = false; - m_nPressedButtons = 0; - m_hasMouseCaptured = false; + if (has_mouse_captured_) { + has_grab_mouse_ = false; + n_pressed_buttons_ = 0; + has_mouse_captured_ = false; } } bool GHOST_WindowWin32::isDialog() const { - return m_isDialog; + return is_dialog_; } void GHOST_WindowWin32::updateMouseCapture(GHOST_MouseCaptureEventWin32 event) { switch (event) { case MousePressed: - m_nPressedButtons++; + n_pressed_buttons_++; break; case MouseReleased: - if (m_nPressedButtons) { - m_nPressedButtons--; + if (n_pressed_buttons_) { + n_pressed_buttons_--; } break; case OperatorGrab: - m_hasGrabMouse = true; + has_grab_mouse_ = true; break; case OperatorUngrab: - m_hasGrabMouse = false; + has_grab_mouse_ = false; break; } - if (!m_nPressedButtons && !m_hasGrabMouse && m_hasMouseCaptured) { + if (!n_pressed_buttons_ && !has_grab_mouse_ && has_mouse_captured_) { ::ReleaseCapture(); - m_hasMouseCaptured = false; + has_mouse_captured_ = false; } - else if ((m_nPressedButtons || m_hasGrabMouse) && !m_hasMouseCaptured) { - ::SetCapture(m_hWnd); - m_hasMouseCaptured = true; + else if ((n_pressed_buttons_ || has_grab_mouse_) && !has_mouse_captured_) { + ::SetCapture(h_wnd_); + has_mouse_captured_ = true; } } @@ -720,8 +719,8 @@ HCURSOR GHOST_WindowWin32::getStandardCursor(GHOST_TStandardCursor shape) const switch (shape) { case GHOST_kStandardCursorCustom: - if (m_customCursor) { - return m_customCursor; + if (custom_cursor_) { + return custom_cursor_; } else { return nullptr; @@ -789,7 +788,7 @@ void GHOST_WindowWin32::loadCursor(bool visible, GHOST_TStandardCursor shape) co GHOST_TSuccess GHOST_WindowWin32::setWindowCursorVisibility(bool visible) { - if (::GetForegroundWindow() == m_hWnd) { + if (::GetForegroundWindow() == h_wnd_) { loadCursor(visible, getCursorShape()); } @@ -800,7 +799,7 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCursorGrab(GHOST_TGrabCursorMode mode { if (mode != GHOST_kGrabDisable) { if (mode != GHOST_kGrabNormal) { - m_system->getCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]); + system_->getCursorPosition(cursor_grab_init_pos_[0], cursor_grab_init_pos_[1]); setCursorGrabAccum(0, 0); if (mode == GHOST_kGrabHide) { @@ -810,41 +809,41 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCursorGrab(GHOST_TGrabCursorMode mode updateMouseCapture(OperatorGrab); } else { - if (m_cursorGrab == GHOST_kGrabHide) { - m_system->setCursorPosition(m_cursorGrabInitPos[0], m_cursorGrabInitPos[1]); + if (cursor_grab_ == GHOST_kGrabHide) { + system_->setCursorPosition(cursor_grab_init_pos_[0], cursor_grab_init_pos_[1]); setWindowCursorVisibility(true); } - if (m_cursorGrab != GHOST_kGrabNormal) { + if (cursor_grab_ != GHOST_kGrabNormal) { /* Use to generate a mouse move event, otherwise the last event * blender gets can be outside the screen causing menus not to show * properly unless the user moves the mouse. */ int32_t pos[2]; - m_system->getCursorPosition(pos[0], pos[1]); - m_system->setCursorPosition(pos[0], pos[1]); + system_->getCursorPosition(pos[0], pos[1]); + system_->setCursorPosition(pos[0], pos[1]); } /* Almost works without but important otherwise the mouse GHOST location * can be incorrect on exit. */ setCursorGrabAccum(0, 0); - m_cursorGrabBounds.m_l = m_cursorGrabBounds.m_r = -1; /* disable */ + cursor_grab_bounds_.l_ = cursor_grab_bounds_.r_ = -1; /* disable */ updateMouseCapture(OperatorUngrab); } return GHOST_kSuccess; } -GHOST_TSuccess GHOST_WindowWin32::setWindowCursorShape(GHOST_TStandardCursor cursorShape) +GHOST_TSuccess GHOST_WindowWin32::setWindowCursorShape(GHOST_TStandardCursor cursor_shape) { - if (::GetForegroundWindow() == m_hWnd) { - loadCursor(getCursorVisibility(), cursorShape); + if (::GetForegroundWindow() == h_wnd_) { + loadCursor(getCursorVisibility(), cursor_shape); } return GHOST_kSuccess; } -GHOST_TSuccess GHOST_WindowWin32::hasCursorShape(GHOST_TStandardCursor cursorShape) +GHOST_TSuccess GHOST_WindowWin32::hasCursorShape(GHOST_TStandardCursor cursor_shape) { - return (getStandardCursor(cursorShape)) ? GHOST_kSuccess : GHOST_kFailure; + return (getStandardCursor(cursor_shape)) ? GHOST_kSuccess : GHOST_kFailure; } GHOST_TSuccess GHOST_WindowWin32::getPointerInfo( @@ -930,7 +929,7 @@ GHOST_TSuccess GHOST_WindowWin32::getPointerInfo( } if (!outPointerInfo.empty()) { - m_lastPointerTabletData = outPointerInfo.back().tabletData; + last_pointer_tablet_data_ = outPointerInfo.back().tabletData; } return GHOST_kSuccess; @@ -938,31 +937,31 @@ GHOST_TSuccess GHOST_WindowWin32::getPointerInfo( void GHOST_WindowWin32::resetPointerPenInfo() { - m_lastPointerTabletData = GHOST_TABLET_DATA_NONE; + last_pointer_tablet_data_ = GHOST_TABLET_DATA_NONE; } GHOST_Wintab *GHOST_WindowWin32::getWintab() const { - return m_wintab; + return wintab_; } void GHOST_WindowWin32::loadWintab(bool enable) { - if (!m_wintab) { - WINTAB_PRINTF("Loading Wintab for window %p\n", m_hWnd); - if (m_wintab = GHOST_Wintab::loadWintab(m_hWnd)) { + if (!wintab_) { + WINTAB_PRINTF("Loading Wintab for window %p\n", h_wnd_); + if (wintab_ = GHOST_Wintab::loadWintab(h_wnd_)) { if (enable) { - m_wintab->enable(); + wintab_->enable(); /* Focus Wintab if cursor is inside this window. This ensures Wintab is enabled when the * tablet is used to change the Tablet API. */ int32_t x, y; - if (m_system->getCursorPosition(x, y)) { + if (system_->getCursorPosition(x, y)) { GHOST_Rect rect; getClientBounds(rect); if (rect.isInside(x, y)) { - m_wintab->gainFocus(); + wintab_->gainFocus(); } } } @@ -972,18 +971,18 @@ void GHOST_WindowWin32::loadWintab(bool enable) void GHOST_WindowWin32::closeWintab() { - WINTAB_PRINTF("Closing Wintab for window %p\n", m_hWnd); - delete m_wintab; - m_wintab = nullptr; + WINTAB_PRINTF("Closing Wintab for window %p\n", h_wnd_); + delete wintab_; + wintab_ = nullptr; } bool GHOST_WindowWin32::usingTabletAPI(GHOST_TTabletAPI api) const { - if (m_system->getTabletAPI() == api) { + if (system_->getTabletAPI() == api) { return true; } - else if (m_system->getTabletAPI() == GHOST_kTabletAutomatic) { - if (m_wintab && m_wintab->devicesPresent()) { + else if (system_->getTabletAPI() == GHOST_kTabletAutomatic) { + if (wintab_ && wintab_->devicesPresent()) { return api == GHOST_kTabletWintab; } else { @@ -998,10 +997,10 @@ bool GHOST_WindowWin32::usingTabletAPI(GHOST_TTabletAPI api) const GHOST_TabletData GHOST_WindowWin32::getTabletData() { if (usingTabletAPI(GHOST_kTabletWintab)) { - return m_wintab ? m_wintab->getLastTabletData() : GHOST_TABLET_DATA_NONE; + return wintab_ ? wintab_->getLastTabletData() : GHOST_TABLET_DATA_NONE; } else { - return m_lastPointerTabletData; + return last_pointer_tablet_data_; } } @@ -1022,25 +1021,25 @@ void GHOST_WindowWin32::ThemeRefresh() /* `20 == DWMWA_USE_IMMERSIVE_DARK_MODE` in Windows 11 SDK. * This value was undocumented for Windows 10 versions 2004 and later, * supported for Windows 11 Build 22000 and later. */ - DwmSetWindowAttribute(this->m_hWnd, 20, &DarkMode, sizeof(DarkMode)); + DwmSetWindowAttribute(this->h_wnd_, 20, &DarkMode, sizeof(DarkMode)); } } void GHOST_WindowWin32::updateDPI() { - if (m_directManipulationHelper) { - m_directManipulationHelper->setDPI(getDPIHint()); + if (direct_manipulation_helper_) { + direct_manipulation_helper_->setDPI(getDPIHint()); } } uint16_t GHOST_WindowWin32::getDPIHint() { - if (m_user32) { + if (user32_) { GHOST_WIN32_GetDpiForWindow fpGetDpiForWindow = (GHOST_WIN32_GetDpiForWindow)::GetProcAddress( - m_user32, "GetDpiForWindow"); + user32_, "GetDpiForWindow"); if (fpGetDpiForWindow) { - return fpGetDpiForWindow(this->m_hWnd); + return fpGetDpiForWindow(this->h_wnd_); } } @@ -1086,9 +1085,9 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(const uint8_t *bitm cols++; } - if (m_customCursor) { - DestroyCursor(m_customCursor); - m_customCursor = nullptr; + if (custom_cursor_) { + DestroyCursor(custom_cursor_); + custom_cursor_ = nullptr; } memset(&andData, 0xFF, sizeof(andData)); @@ -1107,14 +1106,14 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(const uint8_t *bitm andData[y] = ~fullMaskRow; } - m_customCursor = ::CreateCursor( + custom_cursor_ = ::CreateCursor( ::GetModuleHandle(0), hot_spot[0], hot_spot[1], 32, 32, andData, xorData); - if (!m_customCursor) { + if (!custom_cursor_) { return GHOST_kFailure; } - if (::GetForegroundWindow() == m_hWnd) { + if (::GetForegroundWindow() == h_wnd_) { loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom); } @@ -1138,7 +1137,7 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(const uint8_t *bitm header.bV5BlueMask = 0x000000FF; header.bV5AlphaMask = 0xFF000000; - HDC hdc = GetDC(m_hWnd); + HDC hdc = GetDC(h_wnd_); void *bits = nullptr; HBITMAP bmp = CreateDIBSection( hdc, (BITMAPINFO *)&header, DIB_RGB_COLORS, (void **)&bits, NULL, (DWORD)0); @@ -1166,15 +1165,15 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(const uint8_t *bitm icon_info.hbmMask = empty_mask; icon_info.hbmColor = bmp; - m_customCursor = CreateIconIndirect(&icon_info); + custom_cursor_ = CreateIconIndirect(&icon_info); DeleteObject(bmp); DeleteObject(empty_mask); - if (!m_customCursor) { + if (!custom_cursor_) { return GHOST_kFailure; } - if (::GetForegroundWindow() == m_hWnd) { + if (::GetForegroundWindow() == h_wnd_) { loadCursor(getCursorVisibility(), GHOST_kStandardCursorCustom); } @@ -1184,7 +1183,7 @@ GHOST_TSuccess GHOST_WindowWin32::setWindowCustomCursorShape(const uint8_t *bitm GHOST_TSuccess GHOST_WindowWin32::setProgressBar(float progress) { /* #SetProgressValue sets state to #TBPF_NORMAL automatically. */ - if (m_Bar && S_OK == m_Bar->SetProgressValue(m_hWnd, 10000 * progress, 10000)) { + if (bar_ && S_OK == bar_->SetProgressValue(h_wnd_, 10000 * progress, 10000)) { return GHOST_kSuccess; } @@ -1193,7 +1192,7 @@ GHOST_TSuccess GHOST_WindowWin32::setProgressBar(float progress) GHOST_TSuccess GHOST_WindowWin32::endProgressBar() { - if (m_Bar && S_OK == m_Bar->SetProgressState(m_hWnd, TBPF_NOPROGRESS)) { + if (bar_ && S_OK == bar_->SetProgressState(h_wnd_, TBPF_NOPROGRESS)) { return GHOST_kSuccess; } @@ -1203,12 +1202,12 @@ GHOST_TSuccess GHOST_WindowWin32::endProgressBar() #ifdef WITH_INPUT_IME void GHOST_WindowWin32::beginIME(int32_t x, int32_t y, int32_t /*w*/, int32_t h, bool completed) { - m_imeInput.BeginIME(m_hWnd, GHOST_Rect(x, y - h, x, y), completed); + ime_input_.BeginIME(h_wnd_, GHOST_Rect(x, y - h, x, y), completed); } void GHOST_WindowWin32::endIME() { - m_imeInput.EndIME(m_hWnd); + ime_input_.EndIME(h_wnd_); } #endif /* WITH_INPUT_IME */ @@ -1225,7 +1224,7 @@ void GHOST_WindowWin32::registerWindowAppUserModelProperties() return; } - HRESULT hr = SHGetPropertyStoreForWindow(m_hWnd, IID_PPV_ARGS(&pstore)); + HRESULT hr = SHGetPropertyStoreForWindow(h_wnd_, IID_PPV_ARGS(&pstore)); if (!SUCCEEDED(hr)) { return; } @@ -1253,7 +1252,7 @@ void GHOST_WindowWin32::registerWindowAppUserModelProperties() void GHOST_WindowWin32::unregisterWindowAppUserModelProperties() { IPropertyStore *pstore; - HRESULT hr = SHGetPropertyStoreForWindow(m_hWnd, IID_PPV_ARGS(&pstore)); + HRESULT hr = SHGetPropertyStoreForWindow(h_wnd_, IID_PPV_ARGS(&pstore)); if (SUCCEEDED(hr)) { PROPVARIANT value; PropVariantInit(&value); diff --git a/intern/ghost/intern/GHOST_WindowWin32.hh b/intern/ghost/intern/GHOST_WindowWin32.hh index d9e6fa40d90..73c3dd3be54 100644 --- a/intern/ghost/intern/GHOST_WindowWin32.hh +++ b/intern/ghost/intern/GHOST_WindowWin32.hh @@ -77,7 +77,7 @@ class GHOST_WindowWin32 : public GHOST_Window { GHOST_TWindowState state, GHOST_TDrawingContextType type, const GHOST_ContextParams &context_params, - GHOST_WindowWin32 *parentWindow, + GHOST_WindowWin32 *parent_window, bool dialog, const GHOST_GPUDevice &preferred_device); @@ -238,10 +238,10 @@ class GHOST_WindowWin32 : public GHOST_Window { /** * Loads the windows equivalent of a standard GHOST cursor. * \param visible: Flag for cursor visibility. - * \param cursorShape: The cursor shape. + * \param cursor_shape: The cursor shape. */ HCURSOR getStandardCursor(GHOST_TStandardCursor shape) const; - void loadCursor(bool visible, GHOST_TStandardCursor cursorShape) const; + void loadCursor(bool visible, GHOST_TStandardCursor cursor_shape) const; /** * Query whether given tablet API should be used. @@ -294,10 +294,10 @@ class GHOST_WindowWin32 : public GHOST_Window { uint16_t getDPIHint() override; /** True if the mouse is either over or captured by the window. */ - bool m_mousePresent; + bool mouse_present_; /** True if the window currently resizing. */ - bool m_inLiveResize; + bool in_live_resize_; /** Called when OS colors change and when the window is created. */ void ThemeRefresh(); @@ -305,7 +305,7 @@ class GHOST_WindowWin32 : public GHOST_Window { #ifdef WITH_INPUT_IME GHOST_ImeWin32 *getImeInput() { - return &m_imeInput; + return &ime_input_; } void beginIME(int32_t x, int32_t y, int32_t w, int32_t h, bool completed); @@ -368,52 +368,52 @@ class GHOST_WindowWin32 : public GHOST_Window { void unregisterWindowAppUserModelProperties(); /** Pointer to system. */ - GHOST_SystemWin32 *m_system; + GHOST_SystemWin32 *system_; /** Pointer to COM #IDropTarget implementer. */ - GHOST_DropTargetWin32 *m_dropTarget; + GHOST_DropTargetWin32 *drop_target_; /** Window handle. */ - HWND m_hWnd; + HWND h_wnd_; /** Device context handle. */ - HDC m_hDC; + HDC h_DC_; - bool m_isDialog; - GHOST_GPUDevice m_preferred_device; + bool is_dialog_; + GHOST_GPUDevice preferred_device_; /** Flag for if window has captured the mouse. */ - bool m_hasMouseCaptured; + bool has_mouse_captured_; /** * Flag if an operator grabs the mouse with #WM_cursor_grab_enable, #WM_cursor_grab_disable * Multiple grabs must be released with a single un-grab. */ - bool m_hasGrabMouse; + bool has_grab_mouse_; /** Count of number of pressed buttons. */ - int m_nPressedButtons; + int n_pressed_buttons_; /** HCURSOR structure of the custom cursor. */ - HCURSOR m_customCursor; + HCURSOR custom_cursor_; /** ITaskbarList3 structure for progress bar. */ - ITaskbarList3 *m_Bar; + ITaskbarList3 *bar_; static const wchar_t *s_windowClassName; static const int s_maxTitleLength; /** Pointer to Wintab manager if Wintab is loaded. */ - GHOST_Wintab *m_wintab; + GHOST_Wintab *wintab_; /** Most recent tablet data. */ - GHOST_TabletData m_lastPointerTabletData; + GHOST_TabletData last_pointer_tablet_data_; - GHOST_TWindowState m_normal_state; + GHOST_TWindowState normal_state_; /** `user32.dll` handle */ - HMODULE m_user32; + HMODULE user32_; - HWND m_parentWindowHwnd; + HWND parent_window_hwnd_; - GHOST_DirectManipulationHelper *m_directManipulationHelper; + GHOST_DirectManipulationHelper *direct_manipulation_helper_; #ifdef WITH_INPUT_IME /** Handle input method editors event */ - GHOST_ImeWin32 m_imeInput; + GHOST_ImeWin32 ime_input_; #endif }; diff --git a/intern/ghost/intern/GHOST_WindowX11.cc b/intern/ghost/intern/GHOST_WindowX11.cc index a28de4bfa6a..242237233d8 100644 --- a/intern/ghost/intern/GHOST_WindowX11.cc +++ b/intern/ghost/intern/GHOST_WindowX11.cc @@ -107,46 +107,46 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_WindowX11 *parentWindow, + GHOST_WindowX11 *parent_window, GHOST_TDrawingContextType type, const bool is_dialog, const GHOST_ContextParams &context_params, const bool exclusive, const GHOST_GPUDevice &preferred_device) : GHOST_Window(width, height, state, context_params, exclusive), - m_display(display), - m_visualInfo(nullptr), - m_fbconfig(nullptr), - m_normal_state(GHOST_kWindowStateNormal), - m_system(system), - m_invalid_window(false), - m_empty_cursor(None), - m_custom_cursor(None), - m_visible_cursor(None), + display_(display), + visual_info_(nullptr), + fbconfig_(nullptr), + normal_state_(GHOST_kWindowStateNormal), + system_(system), + invalid_window_(false), + empty_cursor_(None), + custom_cursor_(None), + visible_cursor_(None), #ifdef WITH_XDND - m_dropTarget(nullptr), + drop_target_(nullptr), #endif - m_tabletData(GHOST_TABLET_DATA_NONE), + tablet_data_(GHOST_TABLET_DATA_NONE), #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) - m_xic(nullptr), + xic_(nullptr), #endif - m_valid_setup(false), - m_preferred_device(preferred_device) + valid_setup_(false), + preferred_device_(preferred_device) { #ifdef WITH_OPENGL_BACKEND if (type == GHOST_kDrawingContextTypeOpenGL) { - m_visualInfo = get_x11_visualinfo(m_display); + visual_info_ = get_x11_visualinfo(display_); } else #endif { XVisualInfo tmp = {nullptr}; int n; - m_visualInfo = XGetVisualInfo(m_display, 0, &tmp, &n); + visual_info_ = XGetVisualInfo(display_, 0, &tmp, &n); } /* caller needs to check 'getValid()' */ - if (m_visualInfo == nullptr) { + if (visual_info_ == nullptr) { fprintf(stderr, "initial window could not find the GLX extension\n"); return; } @@ -174,25 +174,25 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, xattributes_valuemask |= CWColormap; xattributes.colormap = XCreateColormap( - m_display, RootWindow(m_display, m_visualInfo->screen), m_visualInfo->visual, AllocNone); + display_, RootWindow(display_, visual_info_->screen), visual_info_->visual, AllocNone); /* create the window! */ - m_window = XCreateWindow(m_display, - RootWindow(m_display, m_visualInfo->screen), - left, - top, - width, - height, - 0, /* no border. */ - m_visualInfo->depth, - InputOutput, - m_visualInfo->visual, - xattributes_valuemask, - &xattributes); + window_ = XCreateWindow(display_, + RootWindow(display_, visual_info_->screen), + left, + top, + width, + height, + 0, /* no border. */ + visual_info_->depth, + InputOutput, + visual_info_->visual, + xattributes_valuemask, + &xattributes); #ifdef WITH_XDND /* initialize drop target for newly created window */ - m_dropTarget = new GHOST_DropTargetX11(this, m_system); + drop_target_ = new GHOST_DropTargetX11(this, system_); GHOST_PRINT("Set drop target\n"); #endif @@ -200,22 +200,22 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, Atom atoms[2]; int count = 0; if (state == GHOST_kWindowStateMaximized) { - atoms[count++] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_VERT; - atoms[count++] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_HORZ; + atoms[count++] = system_->atom_._NET_WM_STATE_MAXIMIZED_VERT; + atoms[count++] = system_->atom_._NET_WM_STATE_MAXIMIZED_HORZ; } else { - atoms[count++] = m_system->m_atom._NET_WM_STATE_FULLSCREEN; + atoms[count++] = system_->atom_._NET_WM_STATE_FULLSCREEN; } - XChangeProperty(m_display, - m_window, - m_system->m_atom._NET_WM_STATE, + XChangeProperty(display_, + window_, + system_->atom_._NET_WM_STATE, XA_ATOM, 32, PropModeReplace, (uchar *)atoms, count); - m_post_init = False; + post_init_ = False; } /* * One of the problem with WM-spec is that can't set a property @@ -225,20 +225,20 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, * To fix this, we first need know that the window is really * map waiting for the MapNotify event. * - * So, m_post_init indicate that we need wait for the MapNotify - * event and then set the Window state to the m_post_state. + * So, post_init_ indicate that we need wait for the MapNotify + * event and then set the Window state to the post_state_. */ else if (!ELEM(state, GHOST_kWindowStateNormal, GHOST_kWindowStateMinimized)) { - m_post_init = True; - m_post_state = state; + post_init_ = True; + post_state_ = state; } else { - m_post_init = False; - m_post_state = GHOST_kWindowStateNormal; + post_init_ = False; + post_state_ = GHOST_kWindowStateNormal; } - if (is_dialog && parentWindow) { - setDialogHints(parentWindow); + if (is_dialog && parent_window) { + setDialogHints(parent_window); } /* Create some hints for the window manager on how @@ -254,7 +254,7 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, xsizehints->min_height = 240; /* Limits are also arbitrary, but should not allow 1x1 window. */ xsizehints->max_width = 65535; xsizehints->max_height = 65535; - XSetWMNormalHints(m_display, m_window, xsizehints); + XSetWMNormalHints(display_, window_, xsizehints); XFree(xsizehints); } @@ -266,29 +266,29 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, memcpy(wmclass, title, len * sizeof(char)); xclasshint->res_name = wmclass; xclasshint->res_class = wmclass; - XSetClassHint(m_display, m_window, xclasshint); + XSetClassHint(display_, window_, xclasshint); free(wmclass); XFree(xclasshint); } /* The basic for a good ICCCM "work" */ - if (m_system->m_atom.WM_PROTOCOLS) { + if (system_->atom_.WM_PROTOCOLS) { Atom atoms[2]; int natom = 0; - if (m_system->m_atom.WM_DELETE_WINDOW) { - atoms[natom] = m_system->m_atom.WM_DELETE_WINDOW; + if (system_->atom_.WM_DELETE_WINDOW) { + atoms[natom] = system_->atom_.WM_DELETE_WINDOW; natom++; } - if (m_system->m_atom.WM_TAKE_FOCUS && m_system->m_windowFocus) { - atoms[natom] = m_system->m_atom.WM_TAKE_FOCUS; + if (system_->atom_.WM_TAKE_FOCUS && system_->window_focus_) { + atoms[natom] = system_->atom_.WM_TAKE_FOCUS; natom++; } if (natom) { // printf("Register atoms: %d\n", natom); - XSetWMProtocols(m_display, m_window, atoms, natom); + XSetWMProtocols(display_, window_, atoms, natom); } } @@ -296,17 +296,17 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, { XWMHints *xwmhints = XAllocWMHints(); xwmhints->initial_state = NormalState; - xwmhints->input = (m_system->m_windowFocus) ? True : False; + xwmhints->input = (system_->window_focus_) ? True : False; xwmhints->flags = InputHint | StateHint; - XSetWMHints(display, m_window, xwmhints); + XSetWMHints(display, window_, xwmhints); XFree(xwmhints); } /* set the icon */ { - Atom _NET_WM_ICON = XInternAtom(m_display, "_NET_WM_ICON", False); - XChangeProperty(m_display, - m_window, + Atom _NET_WM_ICON = XInternAtom(display_, "_NET_WM_ICON", False); + XChangeProperty(display_, + window_, _NET_WM_ICON, XA_CARDINAL, 32, @@ -317,10 +317,10 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, /* set the process ID (_NET_WM_PID) */ { - Atom _NET_WM_PID = XInternAtom(m_display, "_NET_WM_PID", False); + Atom _NET_WM_PID = XInternAtom(display_, "_NET_WM_PID", False); pid_t pid = getpid(); XChangeProperty( - m_display, m_window, _NET_WM_PID, XA_CARDINAL, 32, PropModeReplace, (uchar *)&pid, 1); + display_, window_, _NET_WM_PID, XA_CARDINAL, 32, PropModeReplace, (uchar *)&pid, 1); } /* set the hostname (WM_CLIENT_MACHINE) */ @@ -334,7 +334,7 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, text_array[0] = hostname; XStringListToTextProperty(text_array, 1, &text_prop); - XSetWMClientMachine(m_display, m_window, &text_prop); + XSetWMClientMachine(display_, window_, &text_prop); XFree(text_prop.value); } @@ -344,7 +344,7 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, /* now set up the rendering context. */ if (setDrawingContextType(type) == GHOST_kSuccess) { - m_valid_setup = true; + valid_setup_ = true; GHOST_PRINT("Created window\n"); } else { @@ -360,19 +360,19 @@ GHOST_WindowX11::GHOST_WindowX11(GHOST_SystemX11 *system, setTitle(title); - if (exclusive && system->m_windowFocus) { - XMapRaised(m_display, m_window); + if (exclusive && system->window_focus_) { + XMapRaised(display_, window_); } else { - XMapWindow(m_display, m_window); + XMapWindow(display_, window_); - if (!system->m_windowFocus) { - XLowerWindow(m_display, m_window); + if (!system->window_focus_) { + XLowerWindow(display_, window_); } } GHOST_PRINT("Mapped window\n"); - XFlush(m_display); + XFlush(display_); } #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) @@ -389,36 +389,36 @@ static Bool destroyICCallback(XIC /*xic*/, XPointer ptr, XPointer /*data*/) bool GHOST_WindowX11::createX11_XIC() { - XIM xim = m_system->getX11_XIM(); + XIM xim = system_->getX11_XIM(); if (!xim) { return false; } XICCallback destroy; destroy.callback = (XICProc)destroyICCallback; - destroy.client_data = (XPointer)&m_xic; - m_xic = XCreateIC(xim, - XNClientWindow, - m_window, - XNFocusWindow, - m_window, - XNInputStyle, - XIMPreeditNothing | XIMStatusNothing, - XNResourceName, - GHOST_X11_RES_NAME, - XNResourceClass, - GHOST_X11_RES_CLASS, - XNDestroyCallback, - &destroy, - nullptr); - if (!m_xic) { + destroy.client_data = (XPointer)&xic_; + xic_ = XCreateIC(xim, + XNClientWindow, + window_, + XNFocusWindow, + window_, + XNInputStyle, + XIMPreeditNothing | XIMStatusNothing, + XNResourceName, + GHOST_X11_RES_NAME, + XNResourceClass, + GHOST_X11_RES_CLASS, + XNDestroyCallback, + &destroy, + nullptr); + if (!xic_) { return false; } ulong fevent; - XGetICValues(m_xic, XNFilterEvents, &fevent, nullptr); - XSelectInput(m_display, - m_window, + XGetICValues(xic_, XNFilterEvents, &fevent, nullptr); + XSelectInput(display_, + window_, ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask | EnterWindowMask | LeaveWindowMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | PropertyChangeMask | KeymapStateMask | @@ -430,10 +430,10 @@ bool GHOST_WindowX11::createX11_XIC() #ifdef WITH_X11_XINPUT void GHOST_WindowX11::refreshXInputDevices() { - if (m_system->m_xinput_version.present) { + if (system_->xinput_version_.present) { std::vector xevents; - for (GHOST_SystemX11::GHOST_TabletX11 &xtablet : m_system->GetXTablets()) { + for (GHOST_SystemX11::GHOST_TabletX11 &xtablet : system_->GetXTablets()) { /* With modern XInput (XLIB 1.6.2 at least and/or EVDEV 2.9.0) and some 'no-name' tablets * like 'UC-LOGIC Tablet WP5540U', we also need to 'select' ButtonPress for motion event, * otherwise we do not get any tablet motion event once pen is pressed... See #43367. @@ -458,7 +458,7 @@ void GHOST_WindowX11::refreshXInputDevices() } } - XSelectExtensionEvent(m_display, m_window, xevents.data(), int(xevents.size())); + XSelectExtensionEvent(display_, window_, xevents.data(), int(xevents.size())); } } @@ -466,33 +466,33 @@ void GHOST_WindowX11::refreshXInputDevices() Window GHOST_WindowX11::getXWindow() { - return m_window; + return window_; } bool GHOST_WindowX11::getValid() const { - return GHOST_Window::getValid() && m_valid_setup; + return GHOST_Window::getValid() && valid_setup_; } void GHOST_WindowX11::setTitle(const char *title) { - Atom name = XInternAtom(m_display, "_NET_WM_NAME", 0); - Atom utf8str = XInternAtom(m_display, "UTF8_STRING", 0); + Atom name = XInternAtom(display_, "_NET_WM_NAME", 0); + Atom utf8str = XInternAtom(display_, "UTF8_STRING", 0); XChangeProperty( - m_display, m_window, name, utf8str, 8, PropModeReplace, (const uchar *)title, strlen(title)); + display_, window_, name, utf8str, 8, PropModeReplace, (const uchar *)title, strlen(title)); /* This should convert to valid x11 string * and getTitle would need matching change */ - XStoreName(m_display, m_window, title); + XStoreName(display_, window_, title); - XFlush(m_display); + XFlush(display_); } std::string GHOST_WindowX11::getTitle() const { char *name = nullptr; - XFetchName(m_display, m_window, &name); + XFetchName(display_, window_, &name); std::string title = name ? name : "untitled"; XFree(name); return title; @@ -512,8 +512,8 @@ void GHOST_WindowX11::getClientBounds(GHOST_Rect &bounds) const uint w_return, h_return, border_w_return, depth_return; int32_t screen_x, screen_y; - XGetGeometry(m_display, - m_window, + XGetGeometry(display_, + window_, &root_return, &x_return, &y_return, @@ -524,10 +524,10 @@ void GHOST_WindowX11::getClientBounds(GHOST_Rect &bounds) const clientToScreen(0, 0, screen_x, screen_y); - bounds.m_l = screen_x; - bounds.m_r = bounds.m_l + w_return; - bounds.m_t = screen_y; - bounds.m_b = bounds.m_t + h_return; + bounds.l_ = screen_x; + bounds.r_ = bounds.l_ + w_return; + bounds.t_ = screen_y; + bounds.b_ = bounds.t_ + h_return; } GHOST_TSuccess GHOST_WindowX11::setClientWidth(uint32_t width) @@ -535,7 +535,7 @@ GHOST_TSuccess GHOST_WindowX11::setClientWidth(uint32_t width) XWindowChanges values; uint value_mask = CWWidth; values.width = width; - XConfigureWindow(m_display, m_window, value_mask, &values); + XConfigureWindow(display_, window_, value_mask, &values); return GHOST_kSuccess; } @@ -545,7 +545,7 @@ GHOST_TSuccess GHOST_WindowX11::setClientHeight(uint32_t height) XWindowChanges values; uint value_mask = CWHeight; values.height = height; - XConfigureWindow(m_display, m_window, value_mask, &values); + XConfigureWindow(display_, window_, value_mask, &values); return GHOST_kSuccess; } @@ -555,7 +555,7 @@ GHOST_TSuccess GHOST_WindowX11::setClientSize(uint32_t width, uint32_t height) uint value_mask = CWWidth | CWHeight; values.width = width; values.height = height; - XConfigureWindow(m_display, m_window, value_mask, &values); + XConfigureWindow(display_, window_, value_mask, &values); return GHOST_kSuccess; } @@ -567,7 +567,7 @@ void GHOST_WindowX11::screenToClient(int32_t inX, int32_t inY, int32_t &outX, in /* Use (0, 0) instead of (inX, inY) to work around overflow of signed int16 in * the implementation of this function. */ XTranslateCoordinates( - m_display, RootWindow(m_display, m_visualInfo->screen), m_window, 0, 0, &ax, &ay, &temp); + display_, RootWindow(display_, visual_info_->screen), window_, 0, 0, &ax, &ay, &temp); outX = ax + inX; outY = ay + inY; } @@ -578,27 +578,21 @@ void GHOST_WindowX11::clientToScreen(int32_t inX, int32_t inY, int32_t &outX, in Window temp; XTranslateCoordinates( - m_display, m_window, RootWindow(m_display, m_visualInfo->screen), inX, inY, &ax, &ay, &temp); + display_, window_, RootWindow(display_, visual_info_->screen), inX, inY, &ax, &ay, &temp); outX = ax; outY = ay; } -GHOST_TSuccess GHOST_WindowX11::setDialogHints(GHOST_WindowX11 *parentWindow) +GHOST_TSuccess GHOST_WindowX11::setDialogHints(GHOST_WindowX11 *parent_window) { - Atom atom_window_type = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE", False); - Atom atom_dialog = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE_DIALOG", False); + Atom atom_window_type = XInternAtom(display_, "_NET_WM_WINDOW_TYPE", False); + Atom atom_dialog = XInternAtom(display_, "_NET_WM_WINDOW_TYPE_DIALOG", False); MotifWmHints hints = {0}; - XChangeProperty(m_display, - m_window, - atom_window_type, - XA_ATOM, - 32, - PropModeReplace, - (uchar *)&atom_dialog, - 1); - XSetTransientForHint(m_display, m_window, parentWindow->m_window); + XChangeProperty( + display_, window_, atom_window_type, XA_ATOM, 32, PropModeReplace, (uchar *)&atom_dialog, 1); + XSetTransientForHint(display_, window_, parent_window->window_); /* Disable minimizing of the window for now. * Actually, most window managers disable minimizing and maximizing for dialogs, ignoring this. @@ -607,10 +601,10 @@ GHOST_TSuccess GHOST_WindowX11::setDialogHints(GHOST_WindowX11 *parentWindow) hints.flags = MWM_HINTS_FUNCTIONS; hints.functions = MWM_FUNCTION_RESIZE | MWM_FUNCTION_MOVE | MWM_FUNCTION_MAXIMIZE | MWM_FUNCTION_CLOSE; - XChangeProperty(m_display, - m_window, - m_system->m_atom._MOTIF_WM_HINTS, - m_system->m_atom._MOTIF_WM_HINTS, + XChangeProperty(display_, + window_, + system_->atom_._MOTIF_WM_HINTS, + system_->atom_._MOTIF_WM_HINTS, 32, PropModeReplace, (uchar *)&hints, @@ -630,13 +624,13 @@ void GHOST_WindowX11::icccmSetState(int state) xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; - xev.xclient.display = m_display; - xev.xclient.window = m_window; + xev.xclient.display = display_; + xev.xclient.window = window_; xev.xclient.format = 32; - xev.xclient.message_type = m_system->m_atom.WM_CHANGE_STATE; + xev.xclient.message_type = system_->atom_.WM_CHANGE_STATE; xev.xclient.data.l[0] = state; - XSendEvent(m_display, - RootWindow(m_display, m_visualInfo->screen), + XSendEvent(display_, + RootWindow(display_, visual_info_->screen), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev); @@ -654,13 +648,13 @@ int GHOST_WindowX11::icccmGetState() const CARD32 st; prop_ret = nullptr; - ret = XGetWindowProperty(m_display, - m_window, - m_system->m_atom.WM_STATE, + ret = XGetWindowProperty(display_, + window_, + system_->atom_.WM_STATE, 0, 2, False, - m_system->m_atom.WM_STATE, + system_->atom_.WM_STATE, &type_ret, &format_ret, &num_ret, @@ -687,8 +681,8 @@ void GHOST_WindowX11::netwmMaximized(bool set) xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; - xev.xclient.window = m_window; - xev.xclient.message_type = m_system->m_atom._NET_WM_STATE; + xev.xclient.window = window_; + xev.xclient.message_type = system_->atom_._NET_WM_STATE; xev.xclient.format = 32; if (set == True) { @@ -698,12 +692,12 @@ void GHOST_WindowX11::netwmMaximized(bool set) xev.xclient.data.l[0] = _NET_WM_STATE_REMOVE; } - xev.xclient.data.l[1] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_HORZ; - xev.xclient.data.l[2] = m_system->m_atom._NET_WM_STATE_MAXIMIZED_VERT; + xev.xclient.data.l[1] = system_->atom_._NET_WM_STATE_MAXIMIZED_HORZ; + xev.xclient.data.l[2] = system_->atom_._NET_WM_STATE_MAXIMIZED_VERT; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; - XSendEvent(m_display, - RootWindow(m_display, m_visualInfo->screen), + XSendEvent(display_, + RootWindow(display_, visual_info_->screen), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); @@ -719,9 +713,9 @@ bool GHOST_WindowX11::netwmIsMaximized() const prop_ret = nullptr; st = False; - ret = XGetWindowProperty(m_display, - m_window, - m_system->m_atom._NET_WM_STATE, + ret = XGetWindowProperty(display_, + window_, + system_->atom_._NET_WM_STATE, 0, INT_MAX, False, @@ -734,10 +728,10 @@ bool GHOST_WindowX11::netwmIsMaximized() const if ((ret == Success) && (prop_ret) && (format_ret == 32)) { count = 0; for (i = 0; i < num_ret; i++) { - if (prop_ret[i] == m_system->m_atom._NET_WM_STATE_MAXIMIZED_HORZ) { + if (prop_ret[i] == system_->atom_._NET_WM_STATE_MAXIMIZED_HORZ) { count++; } - if (prop_ret[i] == m_system->m_atom._NET_WM_STATE_MAXIMIZED_VERT) { + if (prop_ret[i] == system_->atom_._NET_WM_STATE_MAXIMIZED_VERT) { count++; } if (count == 2) { @@ -760,8 +754,8 @@ void GHOST_WindowX11::netwmFullScreen(bool set) xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; - xev.xclient.window = m_window; - xev.xclient.message_type = m_system->m_atom._NET_WM_STATE; + xev.xclient.window = window_; + xev.xclient.message_type = system_->atom_._NET_WM_STATE; xev.xclient.format = 32; if (set == True) { @@ -771,12 +765,12 @@ void GHOST_WindowX11::netwmFullScreen(bool set) xev.xclient.data.l[0] = _NET_WM_STATE_REMOVE; } - xev.xclient.data.l[1] = m_system->m_atom._NET_WM_STATE_FULLSCREEN; + xev.xclient.data.l[1] = system_->atom_._NET_WM_STATE_FULLSCREEN; xev.xclient.data.l[2] = 0; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; - XSendEvent(m_display, - RootWindow(m_display, m_visualInfo->screen), + XSendEvent(display_, + RootWindow(display_, visual_info_->screen), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); @@ -792,9 +786,9 @@ bool GHOST_WindowX11::netwmIsFullScreen() const prop_ret = nullptr; st = False; - ret = XGetWindowProperty(m_display, - m_window, - m_system->m_atom._NET_WM_STATE, + ret = XGetWindowProperty(display_, + window_, + system_->atom_._NET_WM_STATE, 0, INT_MAX, False, @@ -806,7 +800,7 @@ bool GHOST_WindowX11::netwmIsFullScreen() const (uchar **)&prop_ret); if ((ret == Success) && (prop_ret) && (format_ret == 32)) { for (i = 0; i < num_ret; i++) { - if (prop_ret[i] == m_system->m_atom._NET_WM_STATE_FULLSCREEN) { + if (prop_ret[i] == system_->atom_._NET_WM_STATE_FULLSCREEN) { st = True; break; } @@ -831,10 +825,10 @@ void GHOST_WindowX11::motifFullScreen(bool set) hints.decorations = 1; } - XChangeProperty(m_display, - m_window, - m_system->m_atom._MOTIF_WM_HINTS, - m_system->m_atom._MOTIF_WM_HINTS, + XChangeProperty(display_, + window_, + system_->atom_._MOTIF_WM_HINTS, + system_->atom_._MOTIF_WM_HINTS, 32, PropModeReplace, (uchar *)&hints, @@ -851,13 +845,13 @@ bool GHOST_WindowX11::motifIsFullScreen() const prop_ret = nullptr; state = False; - st = XGetWindowProperty(m_display, - m_window, - m_system->m_atom._MOTIF_WM_HINTS, + st = XGetWindowProperty(display_, + window_, + system_->atom_._MOTIF_WM_HINTS, 0, INT_MAX, False, - m_system->m_atom._MOTIF_WM_HINTS, + system_->atom_._MOTIF_WM_HINTS, &type_ret, &format_ret, &num_ret, @@ -929,7 +923,7 @@ GHOST_TSuccess GHOST_WindowX11::setState(GHOST_TWindowState state) is_motif_full = motifIsFullScreen(); if (state == GHOST_kWindowStateNormal) { - state = m_normal_state; + state = normal_state_; } if (state == GHOST_kWindowStateNormal) { @@ -955,7 +949,7 @@ GHOST_TSuccess GHOST_WindowX11::setState(GHOST_TWindowState state) return GHOST_kFailure; } - m_normal_state = cur_state; + normal_state_ = cur_state; if (is_max == True) { netwmMaximized(False); @@ -1012,9 +1006,9 @@ GHOST_TSuccess GHOST_WindowX11::setOrder(GHOST_TWindowOrder order) * window managers ignore the former (e.g. KWIN from KDE) and others * don't implement the latter (e.g. FLUXBOX before 0.9.9). */ - XRaiseWindow(m_display, m_window); + XRaiseWindow(display_, window_); - atom = XInternAtom(m_display, "_NET_ACTIVE_WINDOW", True); + atom = XInternAtom(display_, "_NET_ACTIVE_WINDOW", True); if (atom != None) { Window root; @@ -1024,33 +1018,33 @@ GHOST_TSuccess GHOST_WindowX11::setOrder(GHOST_TWindowOrder order) xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; - xev.xclient.window = m_window; + xev.xclient.window = window_; xev.xclient.message_type = atom; xev.xclient.format = 32; xev.xclient.data.l[0] = 1; xev.xclient.data.l[1] = CurrentTime; - xev.xclient.data.l[2] = m_window; + xev.xclient.data.l[2] = window_; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 0; - root = RootWindow(m_display, m_visualInfo->screen); + root = RootWindow(display_, visual_info_->screen); eventmask = SubstructureRedirectMask | SubstructureNotifyMask; - XSendEvent(m_display, root, False, eventmask, &xev); + XSendEvent(display_, root, False, eventmask, &xev); } - XGetWindowAttributes(m_display, m_window, &attr); + XGetWindowAttributes(display_, window_, &attr); /* Minimized windows give bad match error. */ if (attr.map_state == IsViewable) { - XSetInputFocus(m_display, m_window, RevertToPointerRoot, CurrentTime); + XSetInputFocus(display_, window_, RevertToPointerRoot, CurrentTime); } - XFlush(m_display); + XFlush(display_); } else if (order == GHOST_kWindowOrderBottom) { - XLowerWindow(m_display, m_window); - XFlush(m_display); + XLowerWindow(display_, window_); + XFlush(display_); } else { return GHOST_kFailure; @@ -1061,8 +1055,8 @@ GHOST_TSuccess GHOST_WindowX11::setOrder(GHOST_TWindowOrder order) bool GHOST_WindowX11::isDialog() const { - Atom atom_window_type = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE", False); - Atom atom_dialog = XInternAtom(m_display, "_NET_WM_WINDOW_TYPE_DIALOG", False); + Atom atom_window_type = XInternAtom(display_, "_NET_WM_WINDOW_TYPE", False); + Atom atom_dialog = XInternAtom(display_, "_NET_WM_WINDOW_TYPE_DIALOG", False); Atom *prop_ret; ulong bytes_after, num_ret; @@ -1072,8 +1066,8 @@ bool GHOST_WindowX11::isDialog() const prop_ret = nullptr; st = False; - ret = XGetWindowProperty(m_display, - m_window, + ret = XGetWindowProperty(display_, + window_, atom_window_type, 0, INT_MAX, @@ -1112,9 +1106,9 @@ GHOST_TSuccess GHOST_WindowX11::invalidate() * At the same time we queue the dirty windows in the system class * and generate events for them at the next processEvents call. */ - if (m_invalid_window == false) { - m_system->addDirtyWindow(this); - m_invalid_window = true; + if (invalid_window_ == false) { + system_->addDirtyWindow(this); + invalid_window_ = true; } return GHOST_kSuccess; @@ -1127,59 +1121,59 @@ GHOST_TSuccess GHOST_WindowX11::invalidate() void GHOST_WindowX11::validate() { - m_invalid_window = false; + invalid_window_ = false; } GHOST_WindowX11::~GHOST_WindowX11() { - std::map::iterator it = m_standard_cursors.begin(); - for (; it != m_standard_cursors.end(); ++it) { - XFreeCursor(m_display, it->second); + std::map::iterator it = standard_cursors_.begin(); + for (; it != standard_cursors_.end(); ++it) { + XFreeCursor(display_, it->second); } - if (m_empty_cursor) { - XFreeCursor(m_display, m_empty_cursor); + if (empty_cursor_) { + XFreeCursor(display_, empty_cursor_); } - if (m_custom_cursor) { - XFreeCursor(m_display, m_custom_cursor); + if (custom_cursor_) { + XFreeCursor(display_, custom_cursor_); } - if (m_valid_setup) { + if (valid_setup_) { static Atom Primary_atom, Clipboard_atom; Window p_owner, c_owner; /* Change the owner of the Atoms to None if we are the owner. */ - Primary_atom = XInternAtom(m_display, "PRIMARY", False); - Clipboard_atom = XInternAtom(m_display, "CLIPBOARD", False); + Primary_atom = XInternAtom(display_, "PRIMARY", False); + Clipboard_atom = XInternAtom(display_, "CLIPBOARD", False); - p_owner = XGetSelectionOwner(m_display, Primary_atom); - c_owner = XGetSelectionOwner(m_display, Clipboard_atom); + p_owner = XGetSelectionOwner(display_, Primary_atom); + c_owner = XGetSelectionOwner(display_, Clipboard_atom); - if (p_owner == m_window) { - XSetSelectionOwner(m_display, Primary_atom, None, CurrentTime); + if (p_owner == window_) { + XSetSelectionOwner(display_, Primary_atom, None, CurrentTime); } - if (c_owner == m_window) { - XSetSelectionOwner(m_display, Clipboard_atom, None, CurrentTime); + if (c_owner == window_) { + XSetSelectionOwner(display_, Clipboard_atom, None, CurrentTime); } } - if (m_visualInfo) { - XFree(m_visualInfo); + if (visual_info_) { + XFree(visual_info_); } #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) - if (m_xic) { - XDestroyIC(m_xic); + if (xic_) { + XDestroyIC(xic_); } #endif #ifdef WITH_XDND - delete m_dropTarget; + delete drop_target_; #endif releaseNativeHandles(); - if (m_valid_setup) { - XDestroyWindow(m_display, m_window); + if (valid_setup_) { + XDestroyWindow(display_, window_); } } @@ -1188,16 +1182,16 @@ GHOST_Context *GHOST_WindowX11::newDrawingContext(GHOST_TDrawingContextType type switch (type) { #ifdef WITH_VULKAN_BACKEND case GHOST_kDrawingContextTypeVulkan: { - GHOST_Context *context = new GHOST_ContextVK(m_want_context_params, + GHOST_Context *context = new GHOST_ContextVK(want_context_params_, GHOST_kVulkanPlatformX11, - m_window, - m_display, + window_, + display_, nullptr, nullptr, nullptr, 1, 2, - m_preferred_device); + preferred_device_); if (context->initializeDrawingContext()) { return context; } @@ -1212,15 +1206,15 @@ GHOST_Context *GHOST_WindowX11::newDrawingContext(GHOST_TDrawingContextType type /* Try to initialize an EGL context. */ for (int minor = 6; minor >= 3; --minor) { GHOST_Context *context = GHOST_ContextEGL( - this->m_system, - m_want_context_params, - EGLNativeWindowType(m_window), - EGLNativeDisplayType(m_display), + this->system_, + want_context_params_, + EGLNativeWindowType(window_), + EGLNativeDisplayType(display_), EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, 4, minor, GHOST_OPENGL_EGL_CONTEXT_FLAGS | - (m_want_context_params.is_debug ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0), + (want_context_params_.is_debug ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0), GHOST_OPENGL_EGL_RESET_NOTIFICATION_STRATEGY, EGL_OPENGL_API); if (context->initializeDrawingContext()) { @@ -1233,15 +1227,15 @@ GHOST_Context *GHOST_WindowX11::newDrawingContext(GHOST_TDrawingContextType type for (int minor = 6; minor >= 3; --minor) { GHOST_Context *context = new GHOST_ContextGLX( - m_want_context_params, - m_window, - m_display, - (GLXFBConfig)m_fbconfig, + want_context_params_, + window_, + display_, + (GLXFBConfig)fbconfig_, GLX_CONTEXT_CORE_PROFILE_BIT_ARB, 4, minor, GHOST_OPENGL_GLX_CONTEXT_FLAGS | - (m_want_context_params.is_debug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0), + (want_context_params_.is_debug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0), GHOST_OPENGL_GLX_RESET_NOTIFICATION_STRATEGY); if (context->initializeDrawingContext()) { return context; @@ -1313,12 +1307,12 @@ GHOST_TSuccess GHOST_WindowX11::getStandardCursor(GHOST_TStandardCursor g_cursor return GHOST_kFailure; } - xcursor = m_standard_cursors[xcursor_id]; + xcursor = standard_cursors_[xcursor_id]; if (!xcursor) { - xcursor = XCreateFontCursor(m_display, xcursor_id); + xcursor = XCreateFontCursor(display_, xcursor_id); - m_standard_cursors[xcursor_id] = xcursor; + standard_cursors_[xcursor_id] = xcursor; } return GHOST_kSuccess; @@ -1326,20 +1320,20 @@ GHOST_TSuccess GHOST_WindowX11::getStandardCursor(GHOST_TStandardCursor g_cursor Cursor GHOST_WindowX11::getEmptyCursor() { - if (!m_empty_cursor) { + if (!empty_cursor_) { Pixmap blank; XColor dummy = {0}; char data[1] = {0}; /* make a blank cursor */ blank = XCreateBitmapFromData( - m_display, RootWindow(m_display, m_visualInfo->screen), data, 1, 1); + display_, RootWindow(display_, visual_info_->screen), data, 1, 1); - m_empty_cursor = XCreatePixmapCursor(m_display, blank, blank, &dummy, &dummy, 0, 0); - XFreePixmap(m_display, blank); + empty_cursor_ = XCreatePixmapCursor(display_, blank, blank, &dummy, &dummy, 0, 0); + XFreePixmap(display_, blank); } - return m_empty_cursor; + return empty_cursor_; } GHOST_TSuccess GHOST_WindowX11::setWindowCursorVisibility(bool visible) @@ -1347,8 +1341,8 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorVisibility(bool visible) Cursor xcursor; if (visible) { - if (m_visible_cursor) { - xcursor = m_visible_cursor; + if (visible_cursor_) { + xcursor = visible_cursor_; } else if (getStandardCursor(getCursorShape(), xcursor) == GHOST_kFailure) { getStandardCursor(getCursorShape(), xcursor); @@ -1358,8 +1352,8 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorVisibility(bool visible) xcursor = getEmptyCursor(); } - XDefineCursor(m_display, m_window, xcursor); - XFlush(m_display); + XDefineCursor(display_, window_, xcursor); + XFlush(display_); return GHOST_kSuccess; } @@ -1368,7 +1362,7 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorGrab(GHOST_TGrabCursorMode mode) { if (mode != GHOST_kGrabDisable) { if (mode != GHOST_kGrabNormal) { - m_system->getCursorPosition(UNPACK2(m_cursorGrabInitPos)); + system_->getCursorPosition(UNPACK2(cursor_grab_init_pos_)); setCursorGrabAccum(0, 0); if (mode == GHOST_kGrabHide) { @@ -1376,8 +1370,8 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorGrab(GHOST_TGrabCursorMode mode) } } #ifdef GHOST_X11_GRAB - XGrabPointer(m_display, - m_window, + XGrabPointer(display_, + window_, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, @@ -1388,45 +1382,44 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorGrab(GHOST_TGrabCursorMode mode) #endif } else { - if (m_cursorGrab == GHOST_kGrabHide) { - m_system->setCursorPosition(UNPACK2(m_cursorGrabInitPos)); + if (cursor_grab_ == GHOST_kGrabHide) { + system_->setCursorPosition(UNPACK2(cursor_grab_init_pos_)); } - if (m_cursorGrab != GHOST_kGrabNormal) { + if (cursor_grab_ != GHOST_kGrabNormal) { /* use to generate a mouse move event, otherwise the last event * blender gets can be outside the screen causing menus not to show * properly unless the user moves the mouse */ #if defined(WITH_X11_XINPUT) && defined(USE_X11_XINPUT_WARP) - if ((m_system->m_xinput_version.present) && (m_system->m_xinput_version.major_version >= 2)) - { + if ((system_->xinput_version_.present) && (system_->xinput_version_.major_version >= 2)) { int device_id; - if (XIGetClientPointer(m_display, None, &device_id) != False) { - XIWarpPointer(m_display, device_id, None, None, 0, 0, 0, 0, 0, 0); + if (XIGetClientPointer(display_, None, &device_id) != False) { + XIWarpPointer(display_, device_id, None, None, 0, 0, 0, 0, 0, 0); } } else #endif { - XWarpPointer(m_display, None, None, 0, 0, 0, 0, 0, 0); + XWarpPointer(display_, None, None, 0, 0, 0, 0, 0, 0); } } /* Perform this last so to workaround XWayland bug, see: #53004. */ - if (m_cursorGrab == GHOST_kGrabHide) { + if (cursor_grab_ == GHOST_kGrabHide) { setWindowCursorVisibility(true); } /* Almost works without but important * otherwise the mouse GHOST location can be incorrect on exit. */ setCursorGrabAccum(0, 0); - m_cursorGrabBounds.m_l = m_cursorGrabBounds.m_r = -1; /* disable */ + cursor_grab_bounds_.l_ = cursor_grab_bounds_.r_ = -1; /* disable */ #ifdef GHOST_X11_GRAB - XUngrabPointer(m_display, CurrentTime); + XUngrabPointer(display_, CurrentTime); #endif } - XFlush(m_display); + XFlush(display_); return GHOST_kSuccess; } @@ -1438,10 +1431,10 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCursorShape(GHOST_TStandardCursor shape getStandardCursor(GHOST_kStandardCursorDefault, xcursor); } - m_visible_cursor = xcursor; + visible_cursor_ = xcursor; - XDefineCursor(m_display, m_window, xcursor); - XFlush(m_display); + XDefineCursor(display_, window_, xcursor); + XFlush(display_); return GHOST_kSuccess; } @@ -1458,36 +1451,36 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCustomCursorShape(const uint8_t *bitmap const int hot_spot[2], bool /*can_invert_color*/) { - Colormap colormap = DefaultColormap(m_display, m_visualInfo->screen); + Colormap colormap = DefaultColormap(display_, visual_info_->screen); Pixmap bitmap_pix, mask_pix; XColor fg, bg; - if (XAllocNamedColor(m_display, colormap, "White", &fg, &fg) == 0) { + if (XAllocNamedColor(display_, colormap, "White", &fg, &fg) == 0) { return GHOST_kFailure; } - if (XAllocNamedColor(m_display, colormap, "Black", &bg, &bg) == 0) { + if (XAllocNamedColor(display_, colormap, "Black", &bg, &bg) == 0) { return GHOST_kFailure; } - if (m_custom_cursor) { - XFreeCursor(m_display, m_custom_cursor); + if (custom_cursor_) { + XFreeCursor(display_, custom_cursor_); } - bitmap_pix = XCreateBitmapFromData(m_display, m_window, (char *)bitmap, size[0], size[1]); - mask_pix = XCreateBitmapFromData(m_display, m_window, (char *)mask, size[0], size[1]); + bitmap_pix = XCreateBitmapFromData(display_, window_, (char *)bitmap, size[0], size[1]); + mask_pix = XCreateBitmapFromData(display_, window_, (char *)mask, size[0], size[1]); - m_custom_cursor = XCreatePixmapCursor( - m_display, bitmap_pix, mask_pix, &fg, &bg, hot_spot[0], hot_spot[1]); - XDefineCursor(m_display, m_window, m_custom_cursor); - XFlush(m_display); + custom_cursor_ = XCreatePixmapCursor( + display_, bitmap_pix, mask_pix, &fg, &bg, hot_spot[0], hot_spot[1]); + XDefineCursor(display_, window_, custom_cursor_); + XFlush(display_); - m_visible_cursor = m_custom_cursor; + visible_cursor_ = custom_cursor_; - XFreePixmap(m_display, bitmap_pix); - XFreePixmap(m_display, mask_pix); + XFreePixmap(display_, bitmap_pix); + XFreePixmap(display_, mask_pix); - XFreeColors(m_display, colormap, &fg.pixel, 1, 0L); - XFreeColors(m_display, colormap, &bg.pixel, 1, 0L); + XFreeColors(display_, colormap, &fg.pixel, 1, 0L); + XFreeColors(display_, colormap, &bg.pixel, 1, 0L); return GHOST_kSuccess; } @@ -1495,7 +1488,7 @@ GHOST_TSuccess GHOST_WindowX11::setWindowCustomCursorShape(const uint8_t *bitmap uint16_t GHOST_WindowX11::getDPIHint() { /* Try to read DPI setting set using xrdb */ - char *resMan = XResourceManagerString(m_display); + char *resMan = XResourceManagerString(display_); if (resMan) { XrmDatabase xrdb = XrmGetStringDatabase(resMan); if (xrdb) { @@ -1519,7 +1512,7 @@ uint16_t GHOST_WindowX11::getDPIHint() /* Fall back to calculating DPI using X reported DPI, set using `xrandr --dpi`. */ XWindowAttributes attr; - if (!XGetWindowAttributes(m_display, m_window, &attr)) { + if (!XGetWindowAttributes(display_, window_, &attr)) { /* Failed to get window attributes, return X11 default DPI */ return 96; } diff --git a/intern/ghost/intern/GHOST_WindowX11.hh b/intern/ghost/intern/GHOST_WindowX11.hh index 29bbd340ab8..b0237c1ce78 100644 --- a/intern/ghost/intern/GHOST_WindowX11.hh +++ b/intern/ghost/intern/GHOST_WindowX11.hh @@ -42,7 +42,7 @@ class GHOST_WindowX11 : public GHOST_Window { * \param width: The width the window. * \param height: The height the window. * \param state: The state the window is initially opened with. - * \param parentWindow: Parent (embedder) window. + * \param parent_window: Parent (embedder) window. * \param type: The type of drawing context installed in this window. * \param context_params: Parameters to use when initializing the context. * \param preferred_device: Preferred device to use when new device will be created. @@ -55,7 +55,7 @@ class GHOST_WindowX11 : public GHOST_Window { uint32_t width, uint32_t height, GHOST_TWindowState state, - GHOST_WindowX11 *parentWindow, + GHOST_WindowX11 *parent_window, GHOST_TDrawingContextType type, const bool is_dialog, const GHOST_ContextParams &context_params, @@ -120,13 +120,13 @@ class GHOST_WindowX11 : public GHOST_Window { GHOST_TabletData &GetTabletData() { - return m_tabletData; + return tablet_data_; } #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) XIC getX11_XIC() { - return m_xic; + return xic_; } bool createX11_XIC(); @@ -139,7 +139,7 @@ class GHOST_WindowX11 : public GHOST_Window { #ifdef WITH_XDND GHOST_DropTargetX11 *getDropTarget() { - return m_dropTarget; + return drop_target_; } #endif @@ -148,10 +148,10 @@ class GHOST_WindowX11 : public GHOST_Window { * in FullScree or Maximized state. * Check GHOST_WindowX11.cc */ - bool m_post_init; - GHOST_TWindowState m_post_state; + bool post_init_; + GHOST_TWindowState post_state_; - GHOST_TSuccess setDialogHints(GHOST_WindowX11 *parentWindow); + GHOST_TSuccess setDialogHints(GHOST_WindowX11 *parent_window); uint16_t getDPIHint() override; @@ -204,43 +204,43 @@ class GHOST_WindowX11 : public GHOST_Window { Cursor getEmptyCursor(); - Window m_window; - Display *m_display; - XVisualInfo *m_visualInfo; - void *m_fbconfig; + Window window_; + Display *display_; + XVisualInfo *visual_info_; + void *fbconfig_; - GHOST_TWindowState m_normal_state; + GHOST_TWindowState normal_state_; /** A pointer to the typed system class. */ - GHOST_SystemX11 *m_system; + GHOST_SystemX11 *system_; /** Used to concatenate calls to invalidate() on this window. */ - bool m_invalid_window; + bool invalid_window_; /** XCursor structure of an empty (blank) cursor */ - Cursor m_empty_cursor; + Cursor empty_cursor_; /** XCursor structure of the custom cursor */ - Cursor m_custom_cursor; + Cursor custom_cursor_; /** XCursor to show when cursor is visible */ - Cursor m_visible_cursor; + Cursor visible_cursor_; /** Cache of XC_* ID's to XCursor structures */ - std::map m_standard_cursors; + std::map standard_cursors_; #ifdef WITH_XDND - GHOST_DropTargetX11 *m_dropTarget; + GHOST_DropTargetX11 *drop_target_; #endif - GHOST_TabletData m_tabletData; + GHOST_TabletData tablet_data_; #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING) - XIC m_xic; + XIC xic_; #endif - bool m_valid_setup; - GHOST_GPUDevice m_preferred_device; + bool valid_setup_; + GHOST_GPUDevice preferred_device_; void icccmSetState(int state); int icccmGetState() const; diff --git a/intern/ghost/intern/GHOST_Wintab.cc b/intern/ghost/intern/GHOST_Wintab.cc index 3f37a6361f5..945d6090ee4 100644 --- a/intern/ghost/intern/GHOST_Wintab.cc +++ b/intern/ghost/intern/GHOST_Wintab.cc @@ -224,20 +224,20 @@ GHOST_Wintab::GHOST_Wintab(unique_hmodule handle, Coord tablet, Coord system, size_t queueSize) - : m_handle{std::move(handle)}, - m_fpInfo{info}, - m_fpGet{get}, - m_fpSet{set}, - m_fpPacketsGet{packetsGet}, - m_fpEnable{enable}, - m_fpOverlap{overlap}, - m_context{std::move(hctx)}, - m_tabletCoord{tablet}, - m_systemCoord{system}, - m_pkts{queueSize} + : handle_{std::move(handle)}, + fp_info_{info}, + fp_get_{get}, + fp_set_{set}, + fp_packets_get_{packetsGet}, + fp_enable_{enable}, + fp_overlap_{overlap}, + context_{std::move(hctx)}, + tablet_coord_{tablet}, + system_coord_{system}, + pkts_{queueSize} { - m_fpInfo(WTI_INTERFACE, IFC_NDEVICES, &m_numDevices); - WINTAB_PRINTF("Wintab Devices: %d\n", m_numDevices); + fp_info_(WTI_INTERFACE, IFC_NDEVICES, &num_devices_); + WINTAB_PRINTF("Wintab Devices: %d\n", num_devices_); updateCursorInfo(); @@ -247,63 +247,63 @@ GHOST_Wintab::GHOST_Wintab(unique_hmodule handle, GHOST_Wintab::~GHOST_Wintab() { - WINTAB_PRINTF("Closing Wintab context %p\n", m_context.get()); + WINTAB_PRINTF("Closing Wintab context %p\n", context_.get()); } void GHOST_Wintab::enable() { - m_fpEnable(m_context.get(), true); - m_enabled = true; + fp_enable_(context_.get(), true); + enabled_ = true; } void GHOST_Wintab::disable() { - if (m_focused) { + if (focused_) { loseFocus(); } - m_fpEnable(m_context.get(), false); - m_enabled = false; + fp_enable_(context_.get(), false); + enabled_ = false; } void GHOST_Wintab::gainFocus() { - m_fpOverlap(m_context.get(), true); - m_focused = true; + fp_overlap_(context_.get(), true); + focused_ = true; } void GHOST_Wintab::loseFocus() { - if (m_lastTabletData.Active != GHOST_kTabletModeNone) { + if (last_tablet_data_.Active != GHOST_kTabletModeNone) { leaveRange(); } /* Mouse mode of tablet or display layout may change when Wintab or Window is inactive. Don't * trust for mouse movement until re-verified. */ - m_coordTrusted = false; + coord_trusted_ = false; - m_fpOverlap(m_context.get(), false); - m_focused = false; + fp_overlap_(context_.get(), false); + focused_ = false; } void GHOST_Wintab::leaveRange() { /* Button state can't be tracked while out of range, reset it. */ - m_buttons = 0; + buttons_ = 0; /* Set to none to indicate tablet is inactive. */ - m_lastTabletData = GHOST_TABLET_DATA_NONE; + last_tablet_data_ = GHOST_TABLET_DATA_NONE; /* Clear the packet queue. */ - m_fpPacketsGet(m_context.get(), m_pkts.size(), m_pkts.data()); + fp_packets_get_(context_.get(), pkts_.size(), pkts_.data()); } void GHOST_Wintab::remapCoordinates() { LOGCONTEXT lc = {0}; - if (m_fpInfo(WTI_DEFSYSCTX, 0, &lc)) { - extractCoordinates(lc, m_tabletCoord, m_systemCoord); + if (fp_info_(WTI_DEFSYSCTX, 0, &lc)) { + extractCoordinates(lc, tablet_coord_, system_coord_); modifyContext(lc); - m_fpSet(m_context.get(), &lc); + fp_set_(context_.get(), &lc); } } @@ -311,52 +311,52 @@ void GHOST_Wintab::updateCursorInfo() { AXIS Pressure, Orientation[3]; - BOOL pressureSupport = m_fpInfo(WTI_DEVICES, DVC_NPRESSURE, &Pressure); - m_maxPressure = pressureSupport ? Pressure.axMax : 0; - WINTAB_PRINTF("HCTX %p %s maxPressure: %d\n", m_context.get(), __func__, m_maxPressure); + BOOL pressureSupport = fp_info_(WTI_DEVICES, DVC_NPRESSURE, &Pressure); + max_pressure_ = pressureSupport ? Pressure.axMax : 0; + WINTAB_PRINTF("HCTX %p %s maxPressure: %d\n", context_.get(), __func__, max_pressure_); - BOOL tiltSupport = m_fpInfo(WTI_DEVICES, DVC_ORIENTATION, &Orientation); + BOOL tiltSupport = fp_info_(WTI_DEVICES, DVC_ORIENTATION, &Orientation); /* Check if tablet supports azimuth [0] and altitude [1], encoded in axResolution. */ if (tiltSupport && Orientation[0].axResolution && Orientation[1].axResolution) { - m_maxAzimuth = Orientation[0].axMax; - m_maxAltitude = Orientation[1].axMax; + max_azimuth_ = Orientation[0].axMax; + max_altitude_ = Orientation[1].axMax; } else { - m_maxAzimuth = m_maxAltitude = 0; + max_azimuth_ = max_altitude_ = 0; } WINTAB_PRINTF("HCTX %p %s maxAzimuth: %d, maxAltitude: %d\n", - m_context.get(), + context_.get(), __func__, - m_maxAzimuth, - m_maxAltitude); + max_azimuth_, + max_altitude_); } void GHOST_Wintab::processInfoChange(LPARAM lParam) { /* Update number of connected Wintab digitizers. */ if (LOWORD(lParam) == WTI_INTERFACE && HIWORD(lParam) == IFC_NDEVICES) { - m_fpInfo(WTI_INTERFACE, IFC_NDEVICES, &m_numDevices); - WINTAB_PRINTF("HCTX %p %s numDevices: %d\n", m_context.get(), __func__, m_numDevices); + fp_info_(WTI_INTERFACE, IFC_NDEVICES, &num_devices_); + WINTAB_PRINTF("HCTX %p %s numDevices: %d\n", context_.get(), __func__, num_devices_); } } bool GHOST_Wintab::devicesPresent() { - return m_numDevices > 0; + return num_devices_ > 0; } GHOST_TabletData GHOST_Wintab::getLastTabletData() { - return m_lastTabletData; + return last_tablet_data_; } void GHOST_Wintab::getInput(std::vector &outWintabInfo) { - const int numPackets = m_fpPacketsGet(m_context.get(), m_pkts.size(), m_pkts.data()); + const int numPackets = fp_packets_get_(context_.get(), pkts_.size(), pkts_.data()); outWintabInfo.reserve(numPackets); for (int i = 0; i < numPackets; i++) { - const PACKET pkt = m_pkts[i]; + const PACKET pkt = pkts_[i]; GHOST_WintabInfoWin32 out; /* % 3 for multiple devices ("DualTrack"). */ @@ -376,11 +376,11 @@ void GHOST_Wintab::getInput(std::vector &outWintabInfo) out.x = pkt.pkX; out.y = pkt.pkY; - if (m_maxPressure > 0) { - out.tabletData.Pressure = float(pkt.pkNormalPressure) / float(m_maxPressure); + if (max_pressure_ > 0) { + out.tabletData.Pressure = float(pkt.pkNormalPressure) / float(max_pressure_); } - if ((m_maxAzimuth > 0) && (m_maxAltitude > 0)) { + if ((max_azimuth_ > 0) && (max_altitude_ > 0)) { /* From the wintab spec: * orAzimuth: Specifies the clockwise rotation of the cursor about the z axis through a * full circular range. @@ -397,8 +397,8 @@ void GHOST_Wintab::getInput(std::vector &outWintabInfo) ORIENTATION ort = pkt.pkOrientation; /* Convert raw fixed point data to radians. */ - float altRad = float((fabs(float(ort.orAltitude)) / float(m_maxAltitude)) * M_PI_2); - float azmRad = float((float(ort.orAzimuth) / float(m_maxAzimuth)) * M_PI * 2.0); + float altRad = float((fabs(float(ort.orAltitude)) / float(max_altitude_)) * M_PI_2); + float azmRad = float((float(ort.orAzimuth) / float(max_azimuth_)) * M_PI * 2.0); /* Find length of the stylus' projected vector on the XY plane. */ float vecLen = cos(altRad); @@ -416,9 +416,9 @@ void GHOST_Wintab::getInput(std::vector &outWintabInfo) /* Some Wintab libraries don't handle relative button input, so we track button presses * manually. */ - DWORD buttonsChanged = m_buttons ^ pkt.pkButtons; + DWORD buttonsChanged = buttons_ ^ pkt.pkButtons; /* We only needed the prior button state to compare to current, so we can overwrite it now. */ - m_buttons = pkt.pkButtons; + buttons_ = pkt.pkButtons; /* Iterate over button flag indices until all flags are clear. */ for (WORD buttonIndex = 0; buttonsChanged; buttonIndex++, buttonsChanged >>= 1) { @@ -443,7 +443,7 @@ void GHOST_Wintab::getInput(std::vector &outWintabInfo) } if (!outWintabInfo.empty()) { - m_lastTabletData = outWintabInfo.back().tabletData; + last_tablet_data_ = outWintabInfo.back().tabletData; } } @@ -453,8 +453,8 @@ GHOST_TButton GHOST_Wintab::mapWintabToGhostButton(uint cursor, WORD physicalBut BYTE logicalButtons[numButtons] = {0}; BYTE systemButtons[numButtons] = {0}; - if (!m_fpInfo(WTI_CURSORS + cursor, CSR_BUTTONMAP, &logicalButtons) || - !m_fpInfo(WTI_CURSORS + cursor, CSR_SYSBTNMAP, &systemButtons)) + if (!fp_info_(WTI_CURSORS + cursor, CSR_BUTTONMAP, &logicalButtons) || + !fp_info_(WTI_CURSORS + cursor, CSR_SYSBTNMAP, &systemButtons)) { return GHOST_kButtonMaskNone; } @@ -506,13 +506,13 @@ void GHOST_Wintab::mapWintabToSysCoordinates(int x_in, int y_in, int &x_out, int return outPoint; }; - x_out = remap(x_in, m_tabletCoord.x, m_systemCoord.x); - y_out = remap(y_in, m_tabletCoord.y, m_systemCoord.y); + x_out = remap(x_in, tablet_coord_.x, system_coord_.x); + y_out = remap(y_in, tablet_coord_.y, system_coord_.y); } bool GHOST_Wintab::trustCoordinates() { - return m_coordTrusted; + return coord_trusted_; } bool GHOST_Wintab::testCoordinates(int sysX, int sysY, int wtX, int wtY) @@ -521,30 +521,30 @@ bool GHOST_Wintab::testCoordinates(int sysX, int sysY, int wtX, int wtY) /* Allow off by one pixel tolerance in case of rounding error. */ if (abs(sysX - wtX) <= 1 && abs(sysY - wtY) <= 1) { - m_coordTrusted = true; + coord_trusted_ = true; return true; } else { - m_coordTrusted = false; + coord_trusted_ = false; return false; } } -bool GHOST_Wintab::m_debug = false; +bool GHOST_Wintab::debug_ = false; void GHOST_Wintab::setDebug(bool debug) { - m_debug = debug; + debug_ = debug; } bool GHOST_Wintab::getDebug() { - return m_debug; + return debug_; } void GHOST_Wintab::printContextDebugInfo() { - if (!m_debug) { + if (!debug_) { return; } @@ -553,7 +553,7 @@ void GHOST_Wintab::printContextDebugInfo() BYTE systemButtons[32] = {0}; for (int i = 0; i < 3; i++) { printf("initializeWintab cursor %d buttons\n", i); - uint lbut = m_fpInfo(WTI_CURSORS + i, CSR_BUTTONMAP, &logicalButtons); + uint lbut = fp_info_(WTI_CURSORS + i, CSR_BUTTONMAP, &logicalButtons); if (lbut) { printf("%d", logicalButtons[0]); for (int j = 1; j < lbut; j++) { @@ -564,7 +564,7 @@ void GHOST_Wintab::printContextDebugInfo() else { printf("logical button error\n"); } - uint sbut = m_fpInfo(WTI_CURSORS + i, CSR_SYSBTNMAP, &systemButtons); + uint sbut = fp_info_(WTI_CURSORS + i, CSR_SYSBTNMAP, &systemButtons); if (sbut) { printf("%d", systemButtons[0]); for (int j = 1; j < sbut; j++) { @@ -581,8 +581,8 @@ void GHOST_Wintab::printContextDebugInfo() /* Print open context constraints. */ uint maxcontexts, opencontexts; - m_fpInfo(WTI_INTERFACE, IFC_NCONTEXTS, &maxcontexts); - m_fpInfo(WTI_STATUS, STA_CONTEXTS, &opencontexts); + fp_info_(WTI_INTERFACE, IFC_NCONTEXTS, &maxcontexts); + fp_info_(WTI_STATUS, STA_CONTEXTS, &opencontexts); printf("%u max contexts, %u open contexts\n", maxcontexts, opencontexts); /* Print system information. */ @@ -613,52 +613,52 @@ void GHOST_Wintab::printContextDebugInfo() LOGCONTEXT lc; /* Print system context. */ - m_fpInfo(WTI_DEFSYSCTX, 0, &lc); + fp_info_(WTI_DEFSYSCTX, 0, &lc); printf("WTI_DEFSYSCTX\n"); printContextRanges(lc); /* Print system context, manually populated. */ - m_fpInfo(WTI_DEFSYSCTX, CTX_INORGX, &lc.lcInOrgX); - m_fpInfo(WTI_DEFSYSCTX, CTX_INORGY, &lc.lcInOrgY); - m_fpInfo(WTI_DEFSYSCTX, CTX_INEXTX, &lc.lcInExtX); - m_fpInfo(WTI_DEFSYSCTX, CTX_INEXTY, &lc.lcInExtY); - m_fpInfo(WTI_DEFSYSCTX, CTX_OUTORGX, &lc.lcOutOrgX); - m_fpInfo(WTI_DEFSYSCTX, CTX_OUTORGY, &lc.lcOutOrgY); - m_fpInfo(WTI_DEFSYSCTX, CTX_OUTEXTX, &lc.lcOutExtX); - m_fpInfo(WTI_DEFSYSCTX, CTX_OUTEXTY, &lc.lcOutExtY); - m_fpInfo(WTI_DEFSYSCTX, CTX_SYSORGX, &lc.lcSysOrgX); - m_fpInfo(WTI_DEFSYSCTX, CTX_SYSORGY, &lc.lcSysOrgY); - m_fpInfo(WTI_DEFSYSCTX, CTX_SYSEXTX, &lc.lcSysExtX); - m_fpInfo(WTI_DEFSYSCTX, CTX_SYSEXTY, &lc.lcSysExtY); + fp_info_(WTI_DEFSYSCTX, CTX_INORGX, &lc.lcInOrgX); + fp_info_(WTI_DEFSYSCTX, CTX_INORGY, &lc.lcInOrgY); + fp_info_(WTI_DEFSYSCTX, CTX_INEXTX, &lc.lcInExtX); + fp_info_(WTI_DEFSYSCTX, CTX_INEXTY, &lc.lcInExtY); + fp_info_(WTI_DEFSYSCTX, CTX_OUTORGX, &lc.lcOutOrgX); + fp_info_(WTI_DEFSYSCTX, CTX_OUTORGY, &lc.lcOutOrgY); + fp_info_(WTI_DEFSYSCTX, CTX_OUTEXTX, &lc.lcOutExtX); + fp_info_(WTI_DEFSYSCTX, CTX_OUTEXTY, &lc.lcOutExtY); + fp_info_(WTI_DEFSYSCTX, CTX_SYSORGX, &lc.lcSysOrgX); + fp_info_(WTI_DEFSYSCTX, CTX_SYSORGY, &lc.lcSysOrgY); + fp_info_(WTI_DEFSYSCTX, CTX_SYSEXTX, &lc.lcSysExtX); + fp_info_(WTI_DEFSYSCTX, CTX_SYSEXTY, &lc.lcSysExtY); printf("WTI_DEFSYSCTX CTX_*\n"); printContextRanges(lc); - for (uint i = 0; i < m_numDevices; i++) { + for (uint i = 0; i < num_devices_; i++) { /* Print individual device system context. */ - m_fpInfo(WTI_DSCTXS + i, 0, &lc); + fp_info_(WTI_DSCTXS + i, 0, &lc); printf("WTI_DSCTXS %u\n", i); printContextRanges(lc); /* Print individual device system context, manually populated. */ - m_fpInfo(WTI_DSCTXS + i, CTX_INORGX, &lc.lcInOrgX); - m_fpInfo(WTI_DSCTXS + i, CTX_INORGY, &lc.lcInOrgY); - m_fpInfo(WTI_DSCTXS + i, CTX_INEXTX, &lc.lcInExtX); - m_fpInfo(WTI_DSCTXS + i, CTX_INEXTY, &lc.lcInExtY); - m_fpInfo(WTI_DSCTXS + i, CTX_OUTORGX, &lc.lcOutOrgX); - m_fpInfo(WTI_DSCTXS + i, CTX_OUTORGY, &lc.lcOutOrgY); - m_fpInfo(WTI_DSCTXS + i, CTX_OUTEXTX, &lc.lcOutExtX); - m_fpInfo(WTI_DSCTXS + i, CTX_OUTEXTY, &lc.lcOutExtY); - m_fpInfo(WTI_DSCTXS + i, CTX_SYSORGX, &lc.lcSysOrgX); - m_fpInfo(WTI_DSCTXS + i, CTX_SYSORGY, &lc.lcSysOrgY); - m_fpInfo(WTI_DSCTXS + i, CTX_SYSEXTX, &lc.lcSysExtX); - m_fpInfo(WTI_DSCTXS + i, CTX_SYSEXTY, &lc.lcSysExtY); + fp_info_(WTI_DSCTXS + i, CTX_INORGX, &lc.lcInOrgX); + fp_info_(WTI_DSCTXS + i, CTX_INORGY, &lc.lcInOrgY); + fp_info_(WTI_DSCTXS + i, CTX_INEXTX, &lc.lcInExtX); + fp_info_(WTI_DSCTXS + i, CTX_INEXTY, &lc.lcInExtY); + fp_info_(WTI_DSCTXS + i, CTX_OUTORGX, &lc.lcOutOrgX); + fp_info_(WTI_DSCTXS + i, CTX_OUTORGY, &lc.lcOutOrgY); + fp_info_(WTI_DSCTXS + i, CTX_OUTEXTX, &lc.lcOutExtX); + fp_info_(WTI_DSCTXS + i, CTX_OUTEXTY, &lc.lcOutExtY); + fp_info_(WTI_DSCTXS + i, CTX_SYSORGX, &lc.lcSysOrgX); + fp_info_(WTI_DSCTXS + i, CTX_SYSORGY, &lc.lcSysOrgY); + fp_info_(WTI_DSCTXS + i, CTX_SYSEXTX, &lc.lcSysExtX); + fp_info_(WTI_DSCTXS + i, CTX_SYSEXTY, &lc.lcSysExtY); printf("WTI_DSCTX %u CTX_*\n", i); printContextRanges(lc); /* Print device axis. */ AXIS axis_x, axis_y; - m_fpInfo(WTI_DEVICES + i, DVC_X, &axis_x); - m_fpInfo(WTI_DEVICES + i, DVC_Y, &axis_y); + fp_info_(WTI_DEVICES + i, DVC_X, &axis_x); + fp_info_(WTI_DEVICES + i, DVC_Y, &axis_y); printf("WTI_DEVICES %u axis_x org: %d, axis_y org: %d axis_x ext: %d, axis_y ext: %d\n", i, axis_x.axMin, diff --git a/intern/ghost/intern/GHOST_Wintab.hh b/intern/ghost/intern/GHOST_Wintab.hh index 5fdd5254704..05b9df3f588 100644 --- a/intern/ghost/intern/GHOST_Wintab.hh +++ b/intern/ghost/intern/GHOST_Wintab.hh @@ -183,24 +183,24 @@ class GHOST_Wintab { private: /** Wintab DLL handle. */ - unique_hmodule m_handle; + unique_hmodule handle_; /** Wintab API functions. */ - GHOST_WIN32_WTInfo m_fpInfo = nullptr; - GHOST_WIN32_WTGet m_fpGet = nullptr; - GHOST_WIN32_WTSet m_fpSet = nullptr; - GHOST_WIN32_WTPacketsGet m_fpPacketsGet = nullptr; - GHOST_WIN32_WTEnable m_fpEnable = nullptr; - GHOST_WIN32_WTOverlap m_fpOverlap = nullptr; + GHOST_WIN32_WTInfo fp_info_ = nullptr; + GHOST_WIN32_WTGet fp_get_ = nullptr; + GHOST_WIN32_WTSet fp_set_ = nullptr; + GHOST_WIN32_WTPacketsGet fp_packets_get_ = nullptr; + GHOST_WIN32_WTEnable fp_enable_ = nullptr; + GHOST_WIN32_WTOverlap fp_overlap_ = nullptr; /** Stores the Wintab tablet context. */ - unique_hctx m_context; + unique_hctx context_; /** Whether the context is enabled. */ - bool m_enabled = false; + bool enabled_ = false; /** Whether the context has focus and is at the top of overlap order. */ - bool m_focused = false; + bool focused_ = false; /** Pressed button map. */ - DWORD m_buttons = 0; + DWORD buttons_ = 0; /** Range of a coordinate space. */ struct Range { @@ -218,25 +218,25 @@ class GHOST_Wintab { Range y = {}; }; /** Whether Wintab coordinates are trusted. */ - bool m_coordTrusted = false; + bool coord_trusted_ = false; /** Tablet input range. */ - Coord m_tabletCoord = {}; + Coord tablet_coord_ = {}; /** System output range. */ - Coord m_systemCoord = {}; + Coord system_coord_ = {}; - int m_maxPressure = 0; - int m_maxAzimuth = 0; - int m_maxAltitude = 0; + int max_pressure_ = 0; + int max_azimuth_ = 0; + int max_altitude_ = 0; /** Number of connected Wintab devices. */ - UINT m_numDevices = 0; + UINT num_devices_ = 0; /** Reusable buffer to read in Wintab packets. */ - std::vector m_pkts; + std::vector pkts_; /** Most recently received tablet data, or none if pen is not in range. */ - GHOST_TabletData m_lastTabletData = GHOST_TABLET_DATA_NONE; + GHOST_TabletData last_tablet_data_ = GHOST_TABLET_DATA_NONE; /** Whether Wintab logging is enabled. */ - static bool m_debug; + static bool debug_; GHOST_Wintab(unique_hmodule handle, GHOST_WIN32_WTInfo info, diff --git a/intern/ghost/intern/GHOST_XrAction.cc b/intern/ghost/intern/GHOST_XrAction.cc index 6c44e97b6ee..b5f92dd9a7d 100644 --- a/intern/ghost/intern/GHOST_XrAction.cc +++ b/intern/ghost/intern/GHOST_XrAction.cc @@ -34,7 +34,7 @@ GHOST_XrActionSpace::GHOST_XrActionSpace(XrSession session, action_space_info.subactionPath = subaction_path; copy_ghost_pose_to_openxr_pose(pose, action_space_info.poseInActionSpace); - CHECK_XR(xrCreateActionSpace(session, &action_space_info, &m_space), + CHECK_XR(xrCreateActionSpace(session, &action_space_info, &space_), (std::string("Failed to create space \"") + subaction_path_str + "\" for action \"" + action_name + "\" and profile \"" + profile_path + "\".") .data()); @@ -42,14 +42,14 @@ GHOST_XrActionSpace::GHOST_XrActionSpace(XrSession session, GHOST_XrActionSpace::~GHOST_XrActionSpace() { - if (m_space != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySpace(m_space)); + if (space_ != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySpace(space_)); } } XrSpace GHOST_XrActionSpace::getSpace() const { - return m_space; + return space_; } /** \} */ @@ -65,7 +65,7 @@ GHOST_XrActionProfile::GHOST_XrActionProfile(XrInstance instance, GHOST_XrActionType type, const GHOST_XrActionProfileInfo &info) { - CHECK_XR(xrStringToPath(instance, info.profile_path, &m_profile), + CHECK_XR(xrStringToPath(instance, info.profile_path, &profile_), (std::string("Failed to get interaction profile path \"") + info.profile_path + "\".") .data()); @@ -77,7 +77,7 @@ GHOST_XrActionProfile::GHOST_XrActionProfile(XrInstance instance, /* Create bindings. */ XrInteractionProfileSuggestedBinding bindings_info{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; - bindings_info.interactionProfile = m_profile; + bindings_info.interactionProfile = profile_; bindings_info.countSuggestedBindings = 1; for (uint32_t subaction_idx = 0; subaction_idx < info.count_subaction_paths; ++subaction_idx) { @@ -86,7 +86,7 @@ GHOST_XrActionProfile::GHOST_XrActionProfile(XrInstance instance, const std::string interaction_path = std::string(subaction_path_str) + binding_info.component_path; - if (m_bindings.find(interaction_path) != m_bindings.end()) { + if (bindings_.find(interaction_path) != bindings_.end()) { continue; } @@ -104,11 +104,11 @@ GHOST_XrActionProfile::GHOST_XrActionProfile(XrInstance instance, "\". Are the action and profile paths correct?") .data()); - m_bindings.insert({interaction_path, sbinding.binding}); + bindings_.insert({interaction_path, sbinding.binding}); - if (m_subaction_data.find(subaction_path_str) == m_subaction_data.end()) { + if (subaction_data_.find(subaction_path_str) == subaction_data_.end()) { std::map::iterator it = - m_subaction_data + subaction_data_ .emplace( std::piecewise_construct, std::make_tuple(subaction_path_str), std::make_tuple()) .first; @@ -141,12 +141,12 @@ GHOST_XrActionProfile::GHOST_XrActionProfile(XrInstance instance, XrPath GHOST_XrActionProfile::getProfile() const { - return m_profile; + return profile_; } const GHOST_XrSubactionData *GHOST_XrActionProfile::getSubaction(XrPath subaction_path) const { - for (auto &[subaction_path_str, subaction] : m_subaction_data) { + for (auto &[subaction_path_str, subaction] : subaction_data_) { if (subaction.subaction_path == subaction_path) { return &subaction; } @@ -157,17 +157,15 @@ const GHOST_XrSubactionData *GHOST_XrActionProfile::getSubaction(XrPath subactio void GHOST_XrActionProfile::getBindings( XrAction action, std::map> &r_bindings) const { - std::map>::iterator it = r_bindings.find( - m_profile); + std::map>::iterator it = r_bindings.find(profile_); if (it == r_bindings.end()) { - it = r_bindings - .emplace(std::piecewise_construct, std::make_tuple(m_profile), std::make_tuple()) + it = r_bindings.emplace(std::piecewise_construct, std::make_tuple(profile_), std::make_tuple()) .first; } std::vector &sbindings = it->second; - for (auto &[path, binding] : m_bindings) { + for (auto &[path, binding] : bindings_) { XrActionSuggestedBinding sbinding; sbinding.action = action; sbinding.binding = binding; @@ -186,20 +184,20 @@ void GHOST_XrActionProfile::getBindings( GHOST_XrAction::GHOST_XrAction(XrInstance instance, XrActionSet action_set, const GHOST_XrActionInfo &info) - : m_type(info.type), - m_states(info.states), - m_float_thresholds(info.float_thresholds), - m_axis_flags(info.axis_flags), - m_custom_data_( + : type_(info.type), + states_(info.states), + float_thresholds_(info.float_thresholds), + axis_flags_(info.axis_flags), + custom_data_( std::make_unique(info.customdata, info.customdata_free_fn)) { - m_subaction_paths.resize(info.count_subaction_paths); + subaction_paths_.resize(info.count_subaction_paths); for (uint32_t i = 0; i < info.count_subaction_paths; ++i) { const char *subaction_path_str = info.subaction_paths[i]; - CHECK_XR(xrStringToPath(instance, subaction_path_str, &m_subaction_paths[i]), + CHECK_XR(xrStringToPath(instance, subaction_path_str, &subaction_paths_[i]), (std::string("Failed to get user path \"") + subaction_path_str + "\".").data()); - m_subaction_indices.insert({subaction_path_str, i}); + subaction_indices_.insert({subaction_path_str, i}); } XrActionCreateInfo action_info{XR_TYPE_ACTION_CREATE_INFO}; @@ -226,9 +224,9 @@ GHOST_XrAction::GHOST_XrAction(XrInstance instance, break; } action_info.countSubactionPaths = info.count_subaction_paths; - action_info.subactionPaths = m_subaction_paths.data(); + action_info.subactionPaths = subaction_paths_.data(); - CHECK_XR(xrCreateAction(action_set, &action_info, &m_action), + CHECK_XR(xrCreateAction(action_set, &action_info, &action_), (std::string("Failed to create action \"") + info.name + "\". Action name and/or paths are invalid. Name must not contain upper " "case letters or special characters other than '-', '_', or '.'.") @@ -237,8 +235,8 @@ GHOST_XrAction::GHOST_XrAction(XrInstance instance, GHOST_XrAction::~GHOST_XrAction() { - if (m_action != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroyAction(m_action)); + if (action_ != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroyAction(action_)); } } @@ -246,13 +244,13 @@ bool GHOST_XrAction::createBinding(XrInstance instance, XrSession session, const GHOST_XrActionProfileInfo &info) { - if (m_profiles.find(info.profile_path) != m_profiles.end()) { + if (profiles_.find(info.profile_path) != profiles_.end()) { return false; } - m_profiles.emplace(std::piecewise_construct, - std::make_tuple(info.profile_path), - std::make_tuple(instance, session, m_action, m_type, info)); + profiles_.emplace(std::piecewise_construct, + std::make_tuple(info.profile_path), + std::make_tuple(instance, session, action_, type_, info)); return true; } @@ -260,7 +258,7 @@ bool GHOST_XrAction::createBinding(XrInstance instance, void GHOST_XrAction::destroyBinding(const char *profile_path) { /* It's possible nothing is removed. */ - m_profiles.erase(profile_path); + profiles_.erase(profile_path); } void GHOST_XrAction::updateState(XrSession session, @@ -268,16 +266,16 @@ void GHOST_XrAction::updateState(XrSession session, XrSpace reference_space, const XrTime &predicted_display_time) { - const bool is_float_action = (m_type == GHOST_kXrActionTypeFloatInput || - m_type == GHOST_kXrActionTypeVector2fInput); - const bool is_button_action = (is_float_action || m_type == GHOST_kXrActionTypeBooleanInput); + const bool is_float_action = (type_ == GHOST_kXrActionTypeFloatInput || + type_ == GHOST_kXrActionTypeVector2fInput); + const bool is_button_action = (is_float_action || type_ == GHOST_kXrActionTypeBooleanInput); XrActionStateGetInfo state_info{XR_TYPE_ACTION_STATE_GET_INFO}; - state_info.action = m_action; + state_info.action = action_; - const size_t count_subaction_paths = m_subaction_paths.size(); + const size_t count_subaction_paths = subaction_paths_.size(); for (size_t subaction_idx = 0; subaction_idx < count_subaction_paths; ++subaction_idx) { - state_info.subactionPath = m_subaction_paths[subaction_idx]; + state_info.subactionPath = subaction_paths_[subaction_idx]; /* Set subaction data based on current interaction profile. */ XrInteractionProfileState profile_state{XR_TYPE_INTERACTION_PROFILE_STATE}; @@ -285,7 +283,7 @@ void GHOST_XrAction::updateState(XrSession session, "Failed to get current interaction profile."); const GHOST_XrSubactionData *subaction = nullptr; - for (auto &[profile_path, profile] : m_profiles) { + for (auto &[profile_path, profile] : profiles_) { if (profile.getProfile() == profile_state.interactionProfile) { subaction = profile.getSubaction(state_info.subactionPath); break; @@ -294,21 +292,21 @@ void GHOST_XrAction::updateState(XrSession session, if (subaction != nullptr) { if (is_float_action) { - m_float_thresholds[subaction_idx] = subaction->float_threshold; + float_thresholds_[subaction_idx] = subaction->float_threshold; } if (is_button_action) { - m_axis_flags[subaction_idx] = subaction->axis_flag; + axis_flags_[subaction_idx] = subaction->axis_flag; } } - switch (m_type) { + switch (type_) { case GHOST_kXrActionTypeBooleanInput: { XrActionStateBoolean state{XR_TYPE_ACTION_STATE_BOOLEAN}; CHECK_XR(xrGetActionStateBoolean(session, &state_info, &state), (std::string("Failed to get state for boolean action \"") + action_name + "\".") .data()); if (state.isActive) { - ((bool *)m_states)[subaction_idx] = state.currentState; + ((bool *)states_)[subaction_idx] = state.currentState; } break; } @@ -318,7 +316,7 @@ void GHOST_XrAction::updateState(XrSession session, xrGetActionStateFloat(session, &state_info, &state), (std::string("Failed to get state for float action \"") + action_name + "\".").data()); if (state.isActive) { - ((float *)m_states)[subaction_idx] = state.currentState; + ((float *)states_)[subaction_idx] = state.currentState; } break; } @@ -328,7 +326,7 @@ void GHOST_XrAction::updateState(XrSession session, (std::string("Failed to get state for vector2f action \"") + action_name + "\".") .data()); if (state.isActive) { - memcpy(((float(*)[2])m_states)[subaction_idx], &state.currentState, sizeof(float[2])); + memcpy(((float(*)[2])states_)[subaction_idx], &state.currentState, sizeof(float[2])); } break; } @@ -339,7 +337,7 @@ void GHOST_XrAction::updateState(XrSession session, CHECK_XR(xrGetActionStatePose(session, &state_info, &state), (std::string("Failed to get state for pose action \"") + action_name + "\".") .data()); - ((GHOST_XrPose *)m_states)[subaction_idx].is_active = state.isActive; + ((GHOST_XrPose *)states_)[subaction_idx].is_active = state.isActive; if (state.isActive) { XrSpace pose_space = ((subaction != nullptr) && (subaction->space != nullptr)) ? subaction->space->getSpace() : @@ -352,7 +350,7 @@ void GHOST_XrAction::updateState(XrSession session, (std::string("Failed to query pose space for action \"") + action_name + "\".") .data()); copy_openxr_pose_to_ghost_pose(space_location.pose, - ((GHOST_XrPose *)m_states)[subaction_idx]); + ((GHOST_XrPose *)states_)[subaction_idx]); } } } @@ -379,19 +377,19 @@ void GHOST_XrAction::applyHapticFeedback(XrSession session, vibration.amplitude = amplitude; XrHapticActionInfo haptic_info{XR_TYPE_HAPTIC_ACTION_INFO}; - haptic_info.action = m_action; + haptic_info.action = action_; if (subaction_path_str != nullptr) { - SubactionIndexMap::iterator it = m_subaction_indices.find(subaction_path_str); - if (it != m_subaction_indices.end()) { - haptic_info.subactionPath = m_subaction_paths[it->second]; + SubactionIndexMap::iterator it = subaction_indices_.find(subaction_path_str); + if (it != subaction_indices_.end()) { + haptic_info.subactionPath = subaction_paths_[it->second]; CHECK_XR( xrApplyHapticFeedback(session, &haptic_info, (const XrHapticBaseHeader *)&vibration), (std::string("Failed to apply haptic action \"") + action_name + "\".").data()); } } else { - for (const XrPath &subaction_path : m_subaction_paths) { + for (const XrPath &subaction_path : subaction_paths_) { haptic_info.subactionPath = subaction_path; CHECK_XR( xrApplyHapticFeedback(session, &haptic_info, (const XrHapticBaseHeader *)&vibration), @@ -405,18 +403,18 @@ void GHOST_XrAction::stopHapticFeedback(XrSession session, const char *subaction_path_str) { XrHapticActionInfo haptic_info{XR_TYPE_HAPTIC_ACTION_INFO}; - haptic_info.action = m_action; + haptic_info.action = action_; if (subaction_path_str != nullptr) { - SubactionIndexMap::iterator it = m_subaction_indices.find(subaction_path_str); - if (it != m_subaction_indices.end()) { - haptic_info.subactionPath = m_subaction_paths[it->second]; + SubactionIndexMap::iterator it = subaction_indices_.find(subaction_path_str); + if (it != subaction_indices_.end()) { + haptic_info.subactionPath = subaction_paths_[it->second]; CHECK_XR(xrStopHapticFeedback(session, &haptic_info), (std::string("Failed to stop haptic action \"") + action_name + "\".").data()); } } else { - for (const XrPath &subaction_path : m_subaction_paths) { + for (const XrPath &subaction_path : subaction_paths_) { haptic_info.subactionPath = subaction_path; CHECK_XR(xrStopHapticFeedback(session, &haptic_info), (std::string("Failed to stop haptic action \"") + action_name + "\".").data()); @@ -426,17 +424,17 @@ void GHOST_XrAction::stopHapticFeedback(XrSession session, void *GHOST_XrAction::getCustomdata() { - if (m_custom_data_ == nullptr) { + if (custom_data_ == nullptr) { return nullptr; } - return m_custom_data_->custom_data_; + return custom_data_->custom_data_; } void GHOST_XrAction::getBindings( std::map> &r_bindings) const { - for (auto &[path, profile] : m_profiles) { - profile.getBindings(m_action, r_bindings); + for (auto &[path, profile] : profiles_) { + profile.getBindings(action_, r_bindings); } } @@ -448,7 +446,7 @@ void GHOST_XrAction::getBindings( * \{ */ GHOST_XrActionSet::GHOST_XrActionSet(XrInstance instance, const GHOST_XrActionSetInfo &info) - : m_custom_data_( + : custom_data_( std::make_unique(info.customdata, info.customdata_free_fn)) { XrActionSetCreateInfo action_set_info{XR_TYPE_ACTION_SET_CREATE_INFO}; @@ -459,7 +457,7 @@ GHOST_XrActionSet::GHOST_XrActionSet(XrInstance instance, const GHOST_XrActionSe action_set_info.priority = 0; /* Use same (default) priority for all action sets. */ - CHECK_XR(xrCreateActionSet(instance, &action_set_info, &m_action_set), + CHECK_XR(xrCreateActionSet(instance, &action_set_info, &action_set_), (std::string("Failed to create action set \"") + info.name + "\". Name must not contain upper case letters or special characters " "other than '-', '_', or '.'.") @@ -470,22 +468,22 @@ GHOST_XrActionSet::~GHOST_XrActionSet() { /* This needs to be done before xrDestroyActionSet() to avoid an assertion in the GHOST_XrAction * destructor (which calls xrDestroyAction()). */ - m_actions.clear(); + actions_.clear(); - if (m_action_set != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroyActionSet(m_action_set)); + if (action_set_ != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroyActionSet(action_set_)); } } bool GHOST_XrActionSet::createAction(XrInstance instance, const GHOST_XrActionInfo &info) { - if (m_actions.find(info.name) != m_actions.end()) { + if (actions_.find(info.name) != actions_.end()) { return false; } - m_actions.emplace(std::piecewise_construct, - std::make_tuple(info.name), - std::make_tuple(instance, m_action_set, info)); + actions_.emplace(std::piecewise_construct, + std::make_tuple(info.name), + std::make_tuple(instance, action_set_, info)); return true; } @@ -493,13 +491,13 @@ bool GHOST_XrActionSet::createAction(XrInstance instance, const GHOST_XrActionIn void GHOST_XrActionSet::destroyAction(const char *action_name) { /* It's possible nothing is removed. */ - m_actions.erase(action_name); + actions_.erase(action_name); } GHOST_XrAction *GHOST_XrActionSet::findAction(const char *action_name) { - std::map::iterator it = m_actions.find(action_name); - if (it == m_actions.end()) { + std::map::iterator it = actions_.find(action_name); + if (it == actions_.end()) { return nullptr; } return &it->second; @@ -509,33 +507,33 @@ void GHOST_XrActionSet::updateStates(XrSession session, XrSpace reference_space, const XrTime &predicted_display_time) { - for (auto &[name, action] : m_actions) { + for (auto &[name, action] : actions_) { action.updateState(session, name.data(), reference_space, predicted_display_time); } } XrActionSet GHOST_XrActionSet::getActionSet() const { - return m_action_set; + return action_set_; } void *GHOST_XrActionSet::getCustomdata() { - if (m_custom_data_ == nullptr) { + if (custom_data_ == nullptr) { return nullptr; } - return m_custom_data_->custom_data_; + return custom_data_->custom_data_; } uint32_t GHOST_XrActionSet::getActionCount() const { - return uint32_t(m_actions.size()); + return uint32_t(actions_.size()); } void GHOST_XrActionSet::getActionCustomdataArray(void **r_customdata_array) { uint32_t i = 0; - for (auto &[name, action] : m_actions) { + for (auto &[name, action] : actions_) { r_customdata_array[i++] = action.getCustomdata(); } } @@ -543,7 +541,7 @@ void GHOST_XrActionSet::getActionCustomdataArray(void **r_customdata_array) void GHOST_XrActionSet::getBindings( std::map> &r_bindings) const { - for (auto &[name, action] : m_actions) { + for (auto &[name, action] : actions_) { action.getBindings(r_bindings); } } diff --git a/intern/ghost/intern/GHOST_XrAction.hh b/intern/ghost/intern/GHOST_XrAction.hh index e1759db1c3e..dd7baa9d456 100644 --- a/intern/ghost/intern/GHOST_XrAction.hh +++ b/intern/ghost/intern/GHOST_XrAction.hh @@ -34,7 +34,7 @@ class GHOST_XrActionSpace { XrSpace getSpace() const; private: - XrSpace m_space = XR_NULL_HANDLE; + XrSpace space_ = XR_NULL_HANDLE; }; /* -------------------------------------------------------------------- */ @@ -64,12 +64,12 @@ class GHOST_XrActionProfile { std::map> &r_bindings) const; private: - XrPath m_profile = XR_NULL_PATH; + XrPath profile_ = XR_NULL_PATH; /** Sub-action data identified by user `subaction` path. */ - std::map m_subaction_data; + std::map subaction_data_; /** Bindings identified by interaction (user `subaction` + component) path. */ - std::map m_bindings; + std::map bindings_; }; /* -------------------------------------------------------------------- */ @@ -105,20 +105,20 @@ class GHOST_XrAction { private: using SubactionIndexMap = std::map; - XrAction m_action = XR_NULL_HANDLE; - GHOST_XrActionType m_type; - SubactionIndexMap m_subaction_indices; - std::vector m_subaction_paths; + XrAction action_ = XR_NULL_HANDLE; + GHOST_XrActionType type_; + SubactionIndexMap subaction_indices_; + std::vector subaction_paths_; /** States for each subaction path. */ - void *m_states; + void *states_; /** Input thresholds/regions for each subaction path. */ - float *m_float_thresholds; - int16_t *m_axis_flags; + float *float_thresholds_; + int16_t *axis_flags_; - std::unique_ptr m_custom_data_ = nullptr; /* wmXrAction */ + std::unique_ptr custom_data_ = nullptr; /* wmXrAction */ /** Profiles identified by interaction profile path. */ - std::map m_profiles; + std::map profiles_; }; /* -------------------------------------------------------------------- */ @@ -144,11 +144,11 @@ class GHOST_XrActionSet { void getBindings(std::map> &r_bindings) const; private: - XrActionSet m_action_set = XR_NULL_HANDLE; + XrActionSet action_set_ = XR_NULL_HANDLE; - std::unique_ptr m_custom_data_ = nullptr; /* wmXrActionSet */ + std::unique_ptr custom_data_ = nullptr; /* wmXrActionSet */ - std::map m_actions; + std::map actions_; }; /* -------------------------------------------------------------------- */ diff --git a/intern/ghost/intern/GHOST_XrContext.cc b/intern/ghost/intern/GHOST_XrContext.cc index 50c9632f75c..7e0fe6a7693 100644 --- a/intern/ghost/intern/GHOST_XrContext.cc +++ b/intern/ghost/intern/GHOST_XrContext.cc @@ -47,9 +47,9 @@ void *GHOST_XrContext::s_error_handler_customdata = nullptr; * \{ */ GHOST_XrContext::GHOST_XrContext(const GHOST_XrContextCreateInfo *create_info) - : m_oxr(std::make_unique()), - m_debug(create_info->context_flag & GHOST_kXrContextDebug), - m_debug_time(create_info->context_flag & GHOST_kXrContextDebugTime) + : oxr_(std::make_unique()), + debug_(create_info->context_flag & GHOST_kXrContextDebug), + debug_time_(create_info->context_flag & GHOST_kXrContextDebugTime) { } @@ -57,15 +57,15 @@ GHOST_XrContext::~GHOST_XrContext() { /* Destroy session data first. Otherwise xrDestroyInstance will implicitly do it, before the * session had a chance to do so explicitly. */ - m_session = nullptr; + session_ = nullptr; - if (m_oxr->debug_messenger != XR_NULL_HANDLE) { - assert(m_oxr->s_xrDestroyDebugUtilsMessengerEXT_fn != nullptr); - m_oxr->s_xrDestroyDebugUtilsMessengerEXT_fn(m_oxr->debug_messenger); + if (oxr_->debug_messenger != XR_NULL_HANDLE) { + assert(oxr_->s_xrDestroyDebugUtilsMessengerEXT_fn != nullptr); + oxr_->s_xrDestroyDebugUtilsMessengerEXT_fn(oxr_->debug_messenger); } - if (m_oxr->instance != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroyInstance(m_oxr->instance)); - m_oxr->instance = XR_NULL_HANDLE; + if (oxr_->instance != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroyInstance(oxr_->instance)); + oxr_->instance = XR_NULL_HANDLE; } } @@ -83,12 +83,12 @@ void GHOST_XrContext::initialize(const GHOST_XrContextCreateInfo *create_info) const std::vector graphics_binding_types = determineGraphicsBindingTypesToEnable(create_info); - assert(m_oxr->instance == XR_NULL_HANDLE); + assert(oxr_->instance == XR_NULL_HANDLE); createOpenXRInstance(graphics_binding_types); storeInstanceProperties(); /* Multiple bindings may be enabled. Now that we know the runtime in use, settle for one. */ - m_gpu_binding_type = determineGraphicsBindingTypeToUse(graphics_binding_types, create_info); + gpu_binding_type_ = determineGraphicsBindingTypeToUse(graphics_binding_types, create_info); printInstanceInfo(); if (isDebugMode()) { @@ -105,17 +105,17 @@ void GHOST_XrContext::createOpenXRInstance( XR_MAX_APPLICATION_NAME_SIZE); create_info.applicationInfo.apiVersion = XR_CURRENT_API_VERSION; - getAPILayersToEnable(m_enabled_layers); - getExtensionsToEnable(graphics_binding_types, m_enabled_extensions); - create_info.enabledApiLayerCount = m_enabled_layers.size(); - create_info.enabledApiLayerNames = m_enabled_layers.data(); - create_info.enabledExtensionCount = m_enabled_extensions.size(); - create_info.enabledExtensionNames = m_enabled_extensions.data(); + getAPILayersToEnable(enabled_layers_); + getExtensionsToEnable(graphics_binding_types, enabled_extensions_); + create_info.enabledApiLayerCount = enabled_layers_.size(); + create_info.enabledApiLayerNames = enabled_layers_.data(); + create_info.enabledExtensionCount = enabled_extensions_.size(); + create_info.enabledExtensionNames = enabled_extensions_.data(); if (isDebugMode()) { printExtensionsAndAPILayersToEnable(); } - CHECK_XR(xrCreateInstance(&create_info, &m_oxr->instance), + CHECK_XR(xrCreateInstance(&create_info, &oxr_->instance), "Failed to connect to an OpenXR runtime."); } @@ -129,13 +129,13 @@ void GHOST_XrContext::storeInstanceProperties() {"Varjo OpenXR Runtime", OPENXR_RUNTIME_VARJO}}; decltype(runtime_map)::const_iterator runtime_map_iter; - m_oxr->instance_properties.type = XR_TYPE_INSTANCE_PROPERTIES; - CHECK_XR(xrGetInstanceProperties(m_oxr->instance, &m_oxr->instance_properties), + oxr_->instance_properties.type = XR_TYPE_INSTANCE_PROPERTIES; + CHECK_XR(xrGetInstanceProperties(oxr_->instance, &oxr_->instance_properties), "Failed to get OpenXR runtime information. Do you have an active runtime set up?"); - runtime_map_iter = runtime_map.find(m_oxr->instance_properties.runtimeName); + runtime_map_iter = runtime_map.find(oxr_->instance_properties.runtimeName); if (runtime_map_iter != runtime_map.end()) { - m_runtime_id = runtime_map_iter->second; + runtime_id_ = runtime_map_iter->second; } } @@ -157,32 +157,32 @@ void GHOST_XrContext::printSDKVersion() void GHOST_XrContext::printInstanceInfo() { - assert(m_oxr->instance != XR_NULL_HANDLE); + assert(oxr_->instance != XR_NULL_HANDLE); printf("Connected to OpenXR runtime: %s (Version %u.%u.%u)\n", - m_oxr->instance_properties.runtimeName, - XR_VERSION_MAJOR(m_oxr->instance_properties.runtimeVersion), - XR_VERSION_MINOR(m_oxr->instance_properties.runtimeVersion), - XR_VERSION_PATCH(m_oxr->instance_properties.runtimeVersion)); + oxr_->instance_properties.runtimeName, + XR_VERSION_MAJOR(oxr_->instance_properties.runtimeVersion), + XR_VERSION_MINOR(oxr_->instance_properties.runtimeVersion), + XR_VERSION_PATCH(oxr_->instance_properties.runtimeVersion)); } void GHOST_XrContext::printAvailableAPILayersAndExtensionsInfo() { puts("Available OpenXR API-layers/extensions:"); - for (const XrApiLayerProperties &layer_info : m_oxr->layers) { + for (const XrApiLayerProperties &layer_info : oxr_->layers) { printf("Layer: %s\n", layer_info.layerName); } - for (const XrExtensionProperties &ext_info : m_oxr->extensions) { + for (const XrExtensionProperties &ext_info : oxr_->extensions) { printf("Extension: %s\n", ext_info.extensionName); } } void GHOST_XrContext::printExtensionsAndAPILayersToEnable() { - for (const char *layer_name : m_enabled_layers) { + for (const char *layer_name : enabled_layers_) { printf("Enabling OpenXR API-Layer: %s\n", layer_name); } - for (const char *ext_name : m_enabled_extensions) { + for (const char *ext_name : enabled_extensions_) { printf("Enabling OpenXR Extension: %s\n", ext_name); } } @@ -190,7 +190,7 @@ void GHOST_XrContext::printExtensionsAndAPILayersToEnable() static XrBool32 debug_messenger_func(XrDebugUtilsMessageSeverityFlagsEXT /*messageSeverity*/, XrDebugUtilsMessageTypeFlagsEXT /*messageTypes*/, const XrDebugUtilsMessengerCallbackDataEXT *callbackData, - void * /*userData*/) + void * /*user_data*/) { puts("OpenXR Debug Message:"); puts(callbackData->message); @@ -203,16 +203,16 @@ void GHOST_XrContext::initDebugMessenger() /* Extension functions need to be obtained through xrGetInstanceProcAddr(). */ if (XR_FAILED(xrGetInstanceProcAddr( - m_oxr->instance, + oxr_->instance, "xrCreateDebugUtilsMessengerEXT", - (PFN_xrVoidFunction *)&m_oxr->s_xrCreateDebugUtilsMessengerEXT_fn)) || + (PFN_xrVoidFunction *)&oxr_->s_xrCreateDebugUtilsMessengerEXT_fn)) || XR_FAILED(xrGetInstanceProcAddr( - m_oxr->instance, + oxr_->instance, "xrDestroyDebugUtilsMessengerEXT", - (PFN_xrVoidFunction *)&m_oxr->s_xrDestroyDebugUtilsMessengerEXT_fn))) + (PFN_xrVoidFunction *)&oxr_->s_xrDestroyDebugUtilsMessengerEXT_fn))) { - m_oxr->s_xrCreateDebugUtilsMessengerEXT_fn = nullptr; - m_oxr->s_xrDestroyDebugUtilsMessengerEXT_fn = nullptr; + oxr_->s_xrCreateDebugUtilsMessengerEXT_fn = nullptr; + oxr_->s_xrDestroyDebugUtilsMessengerEXT_fn = nullptr; fprintf(stderr, "Could not use XR_EXT_debug_utils to enable debug prints. Not a fatal error, " @@ -229,8 +229,8 @@ void GHOST_XrContext::initDebugMessenger() XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; create_info.userCallback = debug_messenger_func; - if (XR_FAILED(m_oxr->s_xrCreateDebugUtilsMessengerEXT_fn( - m_oxr->instance, &create_info, &m_oxr->debug_messenger))) + if (XR_FAILED(oxr_->s_xrCreateDebugUtilsMessengerEXT_fn( + oxr_->instance, &create_info, &oxr_->debug_messenger))) { fprintf(stderr, "Failed to create OpenXR debug messenger. Not a fatal error, continuing without the " @@ -249,14 +249,12 @@ void GHOST_XrContext::dispatchErrorMessage(const GHOST_XrException *exception) c { GHOST_XrError error; - error.user_message = exception->m_msg.data(); + error.user_message = exception->msg_.data(); error.customdata = s_error_handler_customdata; if (isDebugMode()) { - fprintf(stderr, - "Error: \t%s\n\tOpenXR error value: %i\n", - error.user_message, - exception->m_result); + fprintf( + stderr, "Error: \t%s\n\tOpenXR error value: %i\n", error.user_message, exception->result_); } /* Potentially destroys GHOST_XrContext */ @@ -305,7 +303,7 @@ void GHOST_XrContext::initExtensionsEx(std::vector &exten void GHOST_XrContext::initExtensions() { - initExtensionsEx(m_oxr->extensions, nullptr); + initExtensionsEx(oxr_->extensions, nullptr); } void GHOST_XrContext::initApiLayers() @@ -321,17 +319,17 @@ void GHOST_XrContext::initApiLayers() return; } - m_oxr->layers = std::vector(layer_count); - for (XrApiLayerProperties &layer : m_oxr->layers) { + oxr_->layers = std::vector(layer_count); + for (XrApiLayerProperties &layer : oxr_->layers) { layer.type = XR_TYPE_API_LAYER_PROPERTIES; } /* Actually get the layers. */ - CHECK_XR(xrEnumerateApiLayerProperties(layer_count, &layer_count, m_oxr->layers.data()), + CHECK_XR(xrEnumerateApiLayerProperties(layer_count, &layer_count, oxr_->layers.data()), "Failed to query OpenXR runtime information. Do you have an active runtime set up?"); - for (const XrApiLayerProperties &layer : m_oxr->layers) { + for (const XrApiLayerProperties &layer : oxr_->layers) { /* Each layer may have own extensions. */ - initExtensionsEx(m_oxr->extensions, layer.layerName); + initExtensionsEx(oxr_->extensions, layer.layerName); } } @@ -376,7 +374,7 @@ void GHOST_XrContext::getAPILayersToEnable(std::vector &r_ext_name r_ext_names.reserve(try_layers.size()); for (const std::string &layer : try_layers) { - if (openxr_layer_is_available(m_oxr->layers, layer)) { + if (openxr_layer_is_available(oxr_->layers, layer)) { r_ext_names.push_back(layer.data()); } } @@ -456,19 +454,19 @@ void GHOST_XrContext::getExtensionsToEnable( * we have more info about the runtime). */ for (GHOST_TXrGraphicsBinding type : graphics_binding_types) { const char *gpu_binding = openxr_ext_name_from_wm_gpu_binding(type); - assert(openxr_extension_is_available(m_oxr->extensions, gpu_binding)); + assert(openxr_extension_is_available(oxr_->extensions, gpu_binding)); r_ext_names.push_back(gpu_binding); } #if defined(WITH_GHOST_X11) - if (openxr_extension_is_available(m_oxr->extensions, XR_MNDX_EGL_ENABLE_EXTENSION_NAME)) { + if (openxr_extension_is_available(oxr_->extensions, XR_MNDX_EGL_ENABLE_EXTENSION_NAME)) { /* Use EGL if that backend is available. */ r_ext_names.push_back(XR_MNDX_EGL_ENABLE_EXTENSION_NAME); } #endif for (const std::string_view &ext : try_ext) { - if (openxr_extension_is_available(m_oxr->extensions, ext)) { + if (openxr_extension_is_available(oxr_->extensions, ext)) { r_ext_names.push_back(ext.data()); } } @@ -489,7 +487,7 @@ std::vector GHOST_XrContext::determineGraphicsBindingT assert(create_info->gpu_binding_candidates[i] != GHOST_kXrGraphicsUnknown); const char *ext_name = openxr_ext_name_from_wm_gpu_binding( create_info->gpu_binding_candidates[i]); - if (openxr_extension_is_available(m_oxr->extensions, ext_name)) { + if (openxr_extension_is_available(oxr_->extensions, ext_name)) { result.push_back(create_info->gpu_binding_candidates[i]); } } @@ -510,7 +508,7 @@ GHOST_TXrGraphicsBinding GHOST_XrContext::determineGraphicsBindingTypeToUse( #ifdef WIN32 /* The SteamVR OpenGL backend currently fails for NVIDIA GPU's. Disable it and allow falling * back to the DirectX one. */ - if ((m_runtime_id == OPENXR_RUNTIME_STEAMVR) && (type == GHOST_kXrGraphicsOpenGL) && + if ((runtime_id_ == OPENXR_RUNTIME_STEAMVR) && (type == GHOST_kXrGraphicsOpenGL) && ((create_info->context_flag & GHOST_kXrContextGpuNVIDIA) != 0)) { continue; @@ -536,36 +534,36 @@ GHOST_TXrGraphicsBinding GHOST_XrContext::determineGraphicsBindingTypeToUse( void GHOST_XrContext::startSession(const GHOST_XrSessionBeginInfo *begin_info) { - m_custom_funcs.session_create_fn = begin_info->create_fn; - m_custom_funcs.session_exit_fn = begin_info->exit_fn; - m_custom_funcs.session_exit_customdata = begin_info->exit_customdata; + custom_funcs_.session_create_fn = begin_info->create_fn; + custom_funcs_.session_exit_fn = begin_info->exit_fn; + custom_funcs_.session_exit_customdata = begin_info->exit_customdata; - if (m_session == nullptr) { - m_session = std::make_unique(*this); + if (session_ == nullptr) { + session_ = std::make_unique(*this); } - m_session->start(begin_info); + session_->start(begin_info); } void GHOST_XrContext::endSession() { - if (m_session) { - if (m_session->isRunning()) { - m_session->requestEnd(); + if (session_) { + if (session_->isRunning()) { + session_->requestEnd(); } else { - m_session = nullptr; + session_ = nullptr; } } } bool GHOST_XrContext::isSessionRunning() const { - return m_session && m_session->isRunning(); + return session_ && session_->isRunning(); } void GHOST_XrContext::drawSessionViews(void *draw_customdata) { - m_session->draw(draw_customdata); + session_->draw(draw_customdata); } /** @@ -573,10 +571,9 @@ void GHOST_XrContext::drawSessionViews(void *draw_customdata) */ void GHOST_XrContext::handleSessionStateChange(const XrEventDataSessionStateChanged &lifecycle) { - if (m_session && - m_session->handleStateChangeEvent(lifecycle) == GHOST_XrSession::SESSION_DESTROY) + if (session_ && session_->handleStateChangeEvent(lifecycle) == GHOST_XrSession::SESSION_DESTROY) { - m_session = nullptr; + session_ = nullptr; } } @@ -590,46 +587,46 @@ void GHOST_XrContext::handleSessionStateChange(const XrEventDataSessionStateChan GHOST_XrSession *GHOST_XrContext::getSession() { - return m_session.get(); + return session_.get(); } const GHOST_XrSession *GHOST_XrContext::getSession() const { - return m_session.get(); + return session_.get(); } void GHOST_XrContext::setGraphicsContextBindFuncs(GHOST_XrGraphicsContextBindFn bind_fn, GHOST_XrGraphicsContextUnbindFn unbind_fn) { - if (m_session) { - m_session->unbindGraphicsContext(); + if (session_) { + session_->unbindGraphicsContext(); } - m_custom_funcs.gpu_ctx_bind_fn = bind_fn; - m_custom_funcs.gpu_ctx_unbind_fn = unbind_fn; + custom_funcs_.gpu_ctx_bind_fn = bind_fn; + custom_funcs_.gpu_ctx_unbind_fn = unbind_fn; } void GHOST_XrContext::setDrawViewFunc(GHOST_XrDrawViewFn draw_view_fn) { - m_custom_funcs.draw_view_fn = draw_view_fn; + custom_funcs_.draw_view_fn = draw_view_fn; } void GHOST_XrContext::setPassthroughEnabledFunc( GHOST_XrPassthroughEnabledFn passthrough_enabled_fn) { - m_custom_funcs.passthrough_enabled_fn = passthrough_enabled_fn; + custom_funcs_.passthrough_enabled_fn = passthrough_enabled_fn; } void GHOST_XrContext::setDisablePassthroughFunc( GHOST_XrDisablePassthroughFn disable_passthrough_fn) { - m_custom_funcs.disable_passthrough_fn = disable_passthrough_fn; + custom_funcs_.disable_passthrough_fn = disable_passthrough_fn; } bool GHOST_XrContext::needsUpsideDownDrawing() const { /* Must only be called after the session was started */ - assert(m_session); - return m_session->needsUpsideDownDrawing(); + assert(session_); + return session_->needsUpsideDownDrawing(); } /** \} */ /* Public Accessors and Mutators */ @@ -640,38 +637,38 @@ bool GHOST_XrContext::needsUpsideDownDrawing() const GHOST_TXrOpenXRRuntimeID GHOST_XrContext::getOpenXRRuntimeID() const { - return m_runtime_id; + return runtime_id_; } const GHOST_XrCustomFuncs &GHOST_XrContext::getCustomFuncs() const { - return m_custom_funcs; + return custom_funcs_; } GHOST_TXrGraphicsBinding GHOST_XrContext::getGraphicsBindingType() const { - return m_gpu_binding_type; + return gpu_binding_type_; } XrInstance GHOST_XrContext::getInstance() const { - return m_oxr->instance; + return oxr_->instance; } bool GHOST_XrContext::isDebugMode() const { - return m_debug; + return debug_; } bool GHOST_XrContext::isDebugTimeMode() const { - return m_debug_time; + return debug_time_; } bool GHOST_XrContext::isExtensionEnabled(const char *ext) const { - bool contains = std::find(m_enabled_extensions.begin(), m_enabled_extensions.end(), ext) != - m_enabled_extensions.end(); + bool contains = std::find(enabled_extensions_.begin(), enabled_extensions_.end(), ext) != + enabled_extensions_.end(); return contains; } diff --git a/intern/ghost/intern/GHOST_XrContext.hh b/intern/ghost/intern/GHOST_XrContext.hh index ecdeb2ae14c..10e2a756b41 100644 --- a/intern/ghost/intern/GHOST_XrContext.hh +++ b/intern/ghost/intern/GHOST_XrContext.hh @@ -97,26 +97,26 @@ class GHOST_XrContext : public GHOST_IXrContext { static GHOST_XrErrorHandlerFn s_error_handler; static void *s_error_handler_customdata; - std::unique_ptr m_oxr; + std::unique_ptr oxr_; - GHOST_TXrOpenXRRuntimeID m_runtime_id = OPENXR_RUNTIME_UNKNOWN; + GHOST_TXrOpenXRRuntimeID runtime_id_ = OPENXR_RUNTIME_UNKNOWN; /* The active GHOST XR Session. Null while no session runs. */ - std::unique_ptr m_session; + std::unique_ptr session_; /** Active graphics binding type. */ - GHOST_TXrGraphicsBinding m_gpu_binding_type = GHOST_kXrGraphicsUnknown; + GHOST_TXrGraphicsBinding gpu_binding_type_ = GHOST_kXrGraphicsUnknown; /** Names of enabled extensions. */ - std::vector m_enabled_extensions; + std::vector enabled_extensions_; /** Names of enabled API-layers. */ - std::vector m_enabled_layers; + std::vector enabled_layers_; - GHOST_XrCustomFuncs m_custom_funcs; + GHOST_XrCustomFuncs custom_funcs_; /** Enable debug message prints and OpenXR API validation layers. */ - bool m_debug = false; - bool m_debug_time = false; + bool debug_ = false; + bool debug_time_ = false; void createOpenXRInstance(const std::vector &graphics_binding_types); void storeInstanceProperties(); diff --git a/intern/ghost/intern/GHOST_XrControllerModel.cc b/intern/ghost/intern/GHOST_XrControllerModel.cc index c3f90d9e67c..e7af0ba42ce 100644 --- a/intern/ghost/intern/GHOST_XrControllerModel.cc +++ b/intern/ghost/intern/GHOST_XrControllerModel.cc @@ -411,33 +411,33 @@ GHOST_XrControllerModel::GHOST_XrControllerModel(XrInstance instance, { init_controller_model_extension_functions(instance); - CHECK_XR(xrStringToPath(instance, subaction_path_str, &m_subaction_path), + CHECK_XR(xrStringToPath(instance, subaction_path_str, &subaction_path_), (std::string("Failed to get user path \"") + subaction_path_str + "\".").data()); } GHOST_XrControllerModel::~GHOST_XrControllerModel() { - if (m_load_task.valid()) { - m_load_task.wait(); + if (load_task_.valid()) { + load_task_.wait(); } } void GHOST_XrControllerModel::load(XrSession session) { - if (m_data_loaded || m_load_task.valid()) { + if (data_loaded_ || load_task_.valid()) { return; } /* Get model key. */ XrControllerModelKeyStateMSFT key_state{XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT}; - CHECK_XR(g_xrGetControllerModelKeyMSFT(session, m_subaction_path, &key_state), + CHECK_XR(g_xrGetControllerModelKeyMSFT(session, subaction_path_, &key_state), "Failed to get controller model key state."); if (key_state.modelKey != XR_NULL_CONTROLLER_MODEL_KEY_MSFT) { - m_model_key = key_state.modelKey; + model_key_ = key_state.modelKey; /* Load asynchronously. */ - m_load_task = std::async(std::launch::async, - [&, session = session]() { return loadControllerModel(session); }); + load_task_ = std::async(std::launch::async, + [&, session = session]() { return loadControllerModel(session); }); } } @@ -445,11 +445,11 @@ void GHOST_XrControllerModel::loadControllerModel(XrSession session) { /* Load binary buffers. */ uint32_t buf_size = 0; - CHECK_XR(g_xrLoadControllerModelMSFT(session, m_model_key, 0, &buf_size, nullptr), + CHECK_XR(g_xrLoadControllerModelMSFT(session, model_key_, 0, &buf_size, nullptr), "Failed to get controller model buffer size."); std::vector buf((size_t(buf_size))); - CHECK_XR(g_xrLoadControllerModelMSFT(session, m_model_key, buf_size, &buf_size, buf.data()), + CHECK_XR(g_xrLoadControllerModelMSFT(session, model_key_, buf_size, &buf_size, buf.data()), "Failed to load controller model binary buffers."); /* Convert to glTF model. */ @@ -489,17 +489,17 @@ void GHOST_XrControllerModel::loadControllerModel(XrSession session) /* Get node properties. */ XrControllerModelPropertiesMSFT model_properties{XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT}; model_properties.nodeCapacityInput = 0; - CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, m_model_key, &model_properties), + CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, model_key_, &model_properties), "Failed to get controller model node properties count."); std::vector node_properties( model_properties.nodeCountOutput, {XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT}); model_properties.nodeCapacityInput = uint32_t(node_properties.size()); model_properties.nodeProperties = node_properties.data(); - CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, m_model_key, &model_properties), + CHECK_XR(g_xrGetControllerModelPropertiesMSFT(session, model_key_, &model_properties), "Failed to get controller model node properties."); - m_node_state_indices.resize(node_properties.size(), -1); + node_state_indices_.resize(node_properties.size(), -1); /* Get mesh vertex data. */ const tinygltf::Scene &default_scene = gltf_model.scenes.at( @@ -516,26 +516,26 @@ void GHOST_XrControllerModel::loadControllerModel(XrSession session) root_transform, root_name, node_properties, - m_vertices, - m_indices, - m_components, - m_nodes, - m_node_state_indices); + vertices_, + indices_, + components_, + nodes_, + node_state_indices_); } - m_data_loaded = true; + data_loaded_ = true; } void GHOST_XrControllerModel::updateComponents(XrSession session) { - if (!m_data_loaded) { + if (!data_loaded_) { return; } /* Get node states. */ XrControllerModelStateMSFT model_state{XR_TYPE_CONTROLLER_MODEL_STATE_MSFT}; model_state.nodeCapacityInput = 0; - CHECK_XR(g_xrGetControllerModelStateMSFT(session, m_model_key, &model_state), + CHECK_XR(g_xrGetControllerModelStateMSFT(session, model_key_, &model_state), "Failed to get controller model node state count."); const uint32_t count = model_state.nodeCountOutput; @@ -543,17 +543,17 @@ void GHOST_XrControllerModel::updateComponents(XrSession session) count, {XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT}); model_state.nodeCapacityInput = count; model_state.nodeStates = node_states.data(); - CHECK_XR(g_xrGetControllerModelStateMSFT(session, m_model_key, &model_state), + CHECK_XR(g_xrGetControllerModelStateMSFT(session, model_key_, &model_state), "Failed to get controller model node states."); /* Update node local transforms. */ - assert(m_node_state_indices.size() == count); + assert(node_state_indices_.size() == count); for (uint32_t state_idx = 0; state_idx < count; ++state_idx) { - const int32_t &node_idx = m_node_state_indices[state_idx]; + const int32_t &node_idx = node_state_indices_[state_idx]; if (node_idx >= 0) { const XrPosef &pose = node_states[state_idx].nodePose; - Eigen::Matrix4f &m = *(Eigen::Matrix4f *)m_nodes[node_idx].local_transform; + Eigen::Matrix4f &m = *(Eigen::Matrix4f *)nodes_[node_idx].local_transform; Eigen::Quaternionf q( pose.orientation.w, pose.orientation.x, pose.orientation.y, pose.orientation.z); m.setIdentity(); @@ -563,16 +563,16 @@ void GHOST_XrControllerModel::updateComponents(XrSession session) } /* Calculate component transforms (in world space). */ - std::vector world_transforms(m_nodes.size()); + std::vector world_transforms(nodes_.size()); uint32_t i = 0; - for (const GHOST_XrControllerModelNode &node : m_nodes) { + for (const GHOST_XrControllerModelNode &node : nodes_) { world_transforms[i] = (node.parent_idx >= 0) ? world_transforms[node.parent_idx] * *(Eigen::Matrix4f *)node.local_transform : *(Eigen::Matrix4f *)node.local_transform; if (node.component_idx >= 0) { - memcpy(m_components[node.component_idx].transform, + memcpy(components_[node.component_idx].transform, world_transforms[i].data(), - sizeof(m_components[node.component_idx].transform)); + sizeof(components_[node.component_idx].transform)); } ++i; } @@ -580,13 +580,13 @@ void GHOST_XrControllerModel::updateComponents(XrSession session) void GHOST_XrControllerModel::getData(GHOST_XrControllerModelData &r_data) { - if (m_data_loaded) { - r_data.count_vertices = uint32_t(m_vertices.size()); - r_data.vertices = m_vertices.data(); - r_data.count_indices = uint32_t(m_indices.size()); - r_data.indices = m_indices.data(); - r_data.count_components = uint32_t(m_components.size()); - r_data.components = m_components.data(); + if (data_loaded_) { + r_data.count_vertices = uint32_t(vertices_.size()); + r_data.vertices = vertices_.data(); + r_data.count_indices = uint32_t(indices_.size()); + r_data.indices = indices_.data(); + r_data.count_components = uint32_t(components_.size()); + r_data.components = components_.data(); } else { r_data.count_vertices = 0; diff --git a/intern/ghost/intern/GHOST_XrControllerModel.hh b/intern/ghost/intern/GHOST_XrControllerModel.hh index 27b691adff9..4a7d356d774 100644 --- a/intern/ghost/intern/GHOST_XrControllerModel.hh +++ b/intern/ghost/intern/GHOST_XrControllerModel.hh @@ -30,18 +30,18 @@ class GHOST_XrControllerModel { void getData(GHOST_XrControllerModelData &r_data); private: - XrPath m_subaction_path = XR_NULL_PATH; - XrControllerModelKeyMSFT m_model_key = XR_NULL_CONTROLLER_MODEL_KEY_MSFT; + XrPath subaction_path_ = XR_NULL_PATH; + XrControllerModelKeyMSFT model_key_ = XR_NULL_CONTROLLER_MODEL_KEY_MSFT; - std::future m_load_task; - std::atomic m_data_loaded = false; + std::future load_task_; + std::atomic data_loaded_ = false; - std::vector m_vertices; - std::vector m_indices; - std::vector m_components; - std::vector m_nodes; + std::vector vertices_; + std::vector indices_; + std::vector components_; + std::vector nodes_; /** Maps node states to nodes. */ - std::vector m_node_state_indices; + std::vector node_state_indices_; void loadControllerModel(XrSession session); }; diff --git a/intern/ghost/intern/GHOST_XrException.hh b/intern/ghost/intern/GHOST_XrException.hh index 429d9bd1582..d2e589b94ef 100644 --- a/intern/ghost/intern/GHOST_XrException.hh +++ b/intern/ghost/intern/GHOST_XrException.hh @@ -15,17 +15,16 @@ class GHOST_XrException : public std::exception { friend class GHOST_XrContext; public: - GHOST_XrException(const char *msg, int result = 0) - : std::exception(), m_msg(msg), m_result(result) + GHOST_XrException(const char *msg, int result = 0) : std::exception(), msg_(msg), result_(result) { } const char *what() const noexcept override { - return m_msg.data(); + return msg_.data(); } private: - std::string m_msg; - int m_result; + std::string msg_; + int result_; }; diff --git a/intern/ghost/intern/GHOST_XrGraphicsBinding.cc b/intern/ghost/intern/GHOST_XrGraphicsBinding.cc index 00c3eb064f0..59846345b08 100644 --- a/intern/ghost/intern/GHOST_XrGraphicsBinding.cc +++ b/intern/ghost/intern/GHOST_XrGraphicsBinding.cc @@ -62,8 +62,8 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { public: ~GHOST_XrGraphicsBindingOpenGL() { - if (m_fbo != 0) { - glDeleteFramebuffers(1, &m_fbo); + if (fbo_ != 0) { + glDeleteFramebuffers(1, &fbo_); } } @@ -75,19 +75,19 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { int gl_major_version, gl_minor_version; # if defined(WIN32) GHOST_ContextWGL &ctx_gl = static_cast(ghost_ctx); - gl_major_version = ctx_gl.m_contextMajorVersion; - gl_minor_version = ctx_gl.m_contextMinorVersion; + gl_major_version = ctx_gl.context_major_version_; + gl_minor_version = ctx_gl.context_minor_version_; # elif defined(WITH_GHOST_X11) || defined(WITH_GHOST_WAYLAND) if (dynamic_cast(&ghost_ctx)) { GHOST_ContextEGL &ctx_gl = static_cast(ghost_ctx); - gl_major_version = ctx_gl.m_contextMajorVersion; - gl_minor_version = ctx_gl.m_contextMinorVersion; + gl_major_version = ctx_gl.context_major_version_; + gl_minor_version = ctx_gl.context_minor_version_; } # if defined(WITH_GHOST_X11) else { GHOST_ContextGLX &ctx_gl = static_cast(ghost_ctx); - gl_major_version = ctx_gl.m_contextMajorVersion; - gl_minor_version = ctx_gl.m_contextMinorVersion; + gl_major_version = ctx_gl.context_major_version_; + gl_minor_version = ctx_gl.context_minor_version_; } # endif # endif @@ -146,7 +146,7 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { GHOST_ContextEGL &ctx_egl = static_cast(ghost_ctx); const bool is_wayland = ( # if defined(WITH_GHOST_WAYLAND) - dynamic_cast(ctx_egl.m_system) != nullptr + dynamic_cast(ctx_egl.system_) != nullptr # else false # endif @@ -156,7 +156,7 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { # if defined(WITH_GHOST_WAYLAND) /* #GHOST_SystemWayland */ oxr_binding.wl.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR; - oxr_binding.wl.display = (wl_display *)ctx_egl.m_nativeDisplay; + oxr_binding.wl.display = (wl_display *)ctx_egl.native_display_; # else GHOST_ASSERT(false, "Unexpected State: logical error, unreachable!"); # endif /* !WITH_GHOST_WAYLAND */ @@ -183,13 +183,13 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { else { /* `!is_ctx_egl` */ # if defined(WITH_GHOST_X11) GHOST_ContextGLX &ctx_glx = static_cast(ghost_ctx); - XVisualInfo *visual_info = glXGetVisualFromFBConfig(ctx_glx.m_display, ctx_glx.m_fbconfig); + XVisualInfo *visual_info = glXGetVisualFromFBConfig(ctx_glx.display_, ctx_glx.fbconfig_); oxr_binding.glx.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR; - oxr_binding.glx.xDisplay = ctx_glx.m_display; - oxr_binding.glx.glxFBConfig = ctx_glx.m_fbconfig; - oxr_binding.glx.glxDrawable = ctx_glx.m_window; - oxr_binding.glx.glxContext = ctx_glx.m_context; + oxr_binding.glx.xDisplay = ctx_glx.display_; + oxr_binding.glx.glxFBConfig = ctx_glx.fbconfig_; + oxr_binding.glx.glxDrawable = ctx_glx.window_; + oxr_binding.glx.glxContext = ctx_glx.context_; oxr_binding.glx.visualid = visual_info->visualid; XFree(visual_info); @@ -201,12 +201,12 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { GHOST_ContextWGL &ctx_wgl = static_cast(ghost_ctx); oxr_binding.wgl.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR; - oxr_binding.wgl.hDC = ctx_wgl.m_hDC; - oxr_binding.wgl.hGLRC = ctx_wgl.m_hGLRC; + oxr_binding.wgl.hDC = ctx_wgl.h_DC_; + oxr_binding.wgl.hGLRC = ctx_wgl.h_GLRC_; # endif /* WIN32 */ /* Generate a frame-buffer to use for blitting into the texture. */ - glGenFramebuffers(1, &m_fbo); + glGenFramebuffers(1, &fbo_); } std::optional chooseSwapchainFormat(const std::vector &runtime_formats, @@ -269,7 +269,7 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { } /* Keep alive. */ - m_image_cache.push_back(std::move(ogl_images)); + image_cache_.push_back(std::move(ogl_images)); return base_images; } @@ -281,7 +281,7 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { XrSwapchainImageOpenGLKHR &ogl_swapchain_image = reinterpret_cast( swapchain_image); - glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_); glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ogl_swapchain_image.image, 0); @@ -307,8 +307,8 @@ class GHOST_XrGraphicsBindingOpenGL : public GHOST_IXrGraphicsBinding { } private: - std::list> m_image_cache; - GLuint m_fbo = 0; + std::list> image_cache_; + GLuint fbo_ = 0; }; #endif diff --git a/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.cc b/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.cc index f1512c49c69..a965f19569d 100644 --- a/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.cc +++ b/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.cc @@ -68,12 +68,12 @@ static std::optional choose_swapchain_format_from_candidates( GHOST_XrGraphicsBindingD3D::GHOST_XrGraphicsBindingD3D() : GHOST_IXrGraphicsBinding() { - m_ghost_d3d_ctx = GHOST_SystemWin32::createOffscreenContextD3D(); + ghost_d3d_ctx_ = GHOST_SystemWin32::createOffscreenContextD3D(); } GHOST_XrGraphicsBindingD3D::~GHOST_XrGraphicsBindingD3D() { - if (m_ghost_d3d_ctx) { - GHOST_SystemWin32::disposeContextD3D(m_ghost_d3d_ctx); + if (ghost_d3d_ctx_) { + GHOST_SystemWin32::disposeContextD3D(ghost_d3d_ctx_); } } @@ -115,7 +115,7 @@ bool GHOST_XrGraphicsBindingD3D::checkVersionRequirements( *r_requirement_info = strstream.str(); } - return m_ghost_d3d_ctx->m_device->GetFeatureLevel() >= gpu_requirements.minFeatureLevel; + return ghost_d3d_ctx_->device_->GetFeatureLevel() >= gpu_requirements.minFeatureLevel; } void GHOST_XrGraphicsBindingD3D::initFromGhostContext( @@ -125,7 +125,7 @@ void GHOST_XrGraphicsBindingD3D::initFromGhostContext( ) { oxr_binding.d3d11.type = XR_TYPE_GRAPHICS_BINDING_D3D11_KHR; - oxr_binding.d3d11.device = m_ghost_d3d_ctx->m_device; + oxr_binding.d3d11.device = ghost_d3d_ctx_->device_; } std::optional GHOST_XrGraphicsBindingD3D::chooseSwapchainFormat( @@ -190,14 +190,14 @@ std::vector GHOST_XrGraphicsBindingD3D::createSwap } /* Keep alive. */ - m_image_cache.push_back(std::move(d3d_images)); + image_cache_.push_back(std::move(d3d_images)); return base_images; } bool GHOST_XrGraphicsBindingD3D::needsUpsideDownDrawing(GHOST_Context &) const { - return m_ghost_d3d_ctx->isUpsideDown(); + return ghost_d3d_ctx_->isUpsideDown(); } /* \} */ @@ -208,15 +208,15 @@ bool GHOST_XrGraphicsBindingD3D::needsUpsideDownDrawing(GHOST_Context &) const GHOST_XrGraphicsBindingOpenGLD3D::GHOST_XrGraphicsBindingOpenGLD3D(GHOST_Context &ghost_ctx) - : GHOST_XrGraphicsBindingD3D(), m_ghost_wgl_ctx(static_cast(ghost_ctx)) + : GHOST_XrGraphicsBindingD3D(), ghost_wgl_ctx_(static_cast(ghost_ctx)) { } GHOST_XrGraphicsBindingOpenGLD3D::~GHOST_XrGraphicsBindingOpenGLD3D() { - if (m_shared_resource) { - m_ghost_d3d_ctx->disposeSharedOpenGLResource(m_shared_resource); - m_shared_resource = nullptr; + if (shared_resource_) { + ghost_d3d_ctx_->disposeSharedOpenGLResource(shared_resource_); + shared_resource_ = nullptr; } } @@ -237,26 +237,26 @@ void GHOST_XrGraphicsBindingOpenGLD3D::submitToSwapchainImage( CD3D11_RENDER_TARGET_VIEW_DESC rtv_desc(D3D11_RTV_DIMENSION_TEXTURE2D, DXGI_FORMAT_R8G8B8A8_UNORM); - m_ghost_ctx->m_device->CreateRenderTargetView(d3d_swapchain_image.texture, &rtv_desc, &rtv); - if (!m_shared_resource) { + ghost_ctx_->device_->CreateRenderTargetView(d3d_swapchain_image.texture, &rtv_desc, &rtv); + if (!shared_resource_) { DXGI_FORMAT format; ghost_format_to_dx_format(draw_info.swapchain_format, draw_info.expects_srgb_buffer, format); - m_shared_resource = m_ghost_ctx->createSharedOpenGLResource( + shared_resource_ = ghost_ctx_->createSharedOpenGLResource( draw_info.width, draw_info.height, format, rtv); } - m_ghost_ctx->blitFromOpenGLContext(m_shared_resource, draw_info.width, draw_info.height); + ghost_ctx_->blitFromOpenGLContext(shared_resource_, draw_info.width, draw_info.height); #else - if (!m_shared_resource) { + if (!shared_resource_) { DXGI_FORMAT format; ghost_format_to_dx_format(draw_info.swapchain_format, draw_info.expects_srgb_buffer, format); - m_shared_resource = m_ghost_d3d_ctx->createSharedOpenGLResource( + shared_resource_ = ghost_d3d_ctx_->createSharedOpenGLResource( draw_info.width, draw_info.height, format); } - m_ghost_d3d_ctx->blitFromOpenGLContext(m_shared_resource, draw_info.width, draw_info.height); + ghost_d3d_ctx_->blitFromOpenGLContext(shared_resource_, draw_info.width, draw_info.height); - m_ghost_d3d_ctx->m_device_ctx->OMSetRenderTargets(0, nullptr, nullptr); - m_ghost_d3d_ctx->m_device_ctx->CopyResource( - d3d_swapchain_image.texture, m_ghost_d3d_ctx->getSharedTexture2D(m_shared_resource)); + ghost_d3d_ctx_->device_ctx_->OMSetRenderTargets(0, nullptr, nullptr); + ghost_d3d_ctx_->device_ctx_->CopyResource(d3d_swapchain_image.texture, + ghost_d3d_ctx_->getSharedTexture2D(shared_resource_)); #endif } @@ -270,7 +270,7 @@ void GHOST_XrGraphicsBindingOpenGLD3D::submitToSwapchainImage( GHOST_XrGraphicsBindingVulkanD3D::GHOST_XrGraphicsBindingVulkanD3D(GHOST_Context &ghost_ctx) - : GHOST_XrGraphicsBindingD3D(), m_ghost_ctx(static_cast(ghost_ctx)) + : GHOST_XrGraphicsBindingD3D(), ghost_ctx_(static_cast(ghost_ctx)) { } @@ -289,14 +289,14 @@ void GHOST_XrGraphicsBindingVulkanD3D::submitToSwapchainImage( component_size = 4 * sizeof(uint16_t); } - ID3D11Device *d3d_device = m_ghost_d3d_ctx->m_device; - ID3D11DeviceContext *d3d_device_ctx = m_ghost_d3d_ctx->m_device_ctx; + ID3D11Device *d3d_device = ghost_d3d_ctx_->device_; + ID3D11DeviceContext *d3d_device_ctx = ghost_d3d_ctx_->device_ctx_; DXGI_FORMAT format; ghost_format_to_dx_format(draw_info.swapchain_format, draw_info.expects_srgb_buffer, format); /* Acquire frame buffer image. */ GHOST_VulkanOpenXRData openxr_data = {GHOST_kVulkanXRModeCPU}; - m_ghost_ctx.openxr_acquire_framebuffer_image_callback_(&openxr_data); + ghost_ctx_.openxr_acquire_framebuffer_image_callback_(&openxr_data); /* Upload the data to a D3D Texture */ D3D11_TEXTURE2D_DESC desc; @@ -328,7 +328,7 @@ void GHOST_XrGraphicsBindingVulkanD3D::submitToSwapchainImage( texture->Release(); /* Release frame buffer image. */ - m_ghost_ctx.openxr_release_framebuffer_image_callback_(&openxr_data); + ghost_ctx_.openxr_release_framebuffer_image_callback_(&openxr_data); } /* \} */ diff --git a/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.hh b/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.hh index f9ffbe376f5..bba475e97d7 100644 --- a/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.hh +++ b/intern/ghost/intern/GHOST_XrGraphicsBindingD3D.hh @@ -51,9 +51,9 @@ class GHOST_XrGraphicsBindingD3D : public GHOST_IXrGraphicsBinding { protected: /** Secondary DirectX 11 context used by OpenXR. */ - GHOST_ContextD3D *m_ghost_d3d_ctx = nullptr; + GHOST_ContextD3D *ghost_d3d_ctx_ = nullptr; - std::list> m_image_cache; + std::list> image_cache_; }; /** @@ -71,9 +71,9 @@ class GHOST_XrGraphicsBindingOpenGLD3D : public GHOST_XrGraphicsBindingD3D { private: /** Primary OpenGL context for Blender to use for drawing. */ - GHOST_ContextWGL &m_ghost_wgl_ctx; + GHOST_ContextWGL &ghost_wgl_ctx_; /** Handle to shared resource object. */ - GHOST_SharedOpenGLResource *m_shared_resource = nullptr; + GHOST_SharedOpenGLResource *shared_resource_ = nullptr; }; #ifdef WITH_VULKAN_BACKEND @@ -90,6 +90,6 @@ class GHOST_XrGraphicsBindingVulkanD3D : public GHOST_XrGraphicsBindingD3D { private: /** Primary Vulkan context for Blender to use for drawing. */ - GHOST_ContextVK &m_ghost_ctx; + GHOST_ContextVK &ghost_ctx_; }; #endif diff --git a/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.cc b/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.cc index 350c0f14cee..b4b85eac451 100644 --- a/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.cc +++ b/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.cc @@ -33,7 +33,7 @@ PFN_xrCreateVulkanDeviceKHR GHOST_XrGraphicsBindingVulkan::s_xrCreateVulkanDevic * \{ */ GHOST_XrGraphicsBindingVulkan::GHOST_XrGraphicsBindingVulkan(GHOST_Context &ghost_ctx) - : GHOST_IXrGraphicsBinding(), m_ghost_ctx(static_cast(ghost_ctx)) + : GHOST_IXrGraphicsBinding(), ghost_ctx_(static_cast(ghost_ctx)) { } @@ -46,49 +46,49 @@ GHOST_XrGraphicsBindingVulkan::GHOST_XrGraphicsBindingVulkan(GHOST_Context &ghos GHOST_XrGraphicsBindingVulkan::~GHOST_XrGraphicsBindingVulkan() { /* Destroy buffer */ - if (m_vk_buffer != VK_NULL_HANDLE) { - vmaUnmapMemory(m_vma_allocator, m_vk_buffer_allocation); - vmaDestroyBuffer(m_vma_allocator, m_vk_buffer, m_vk_buffer_allocation); - m_vk_buffer = VK_NULL_HANDLE; - m_vk_buffer_allocation = VK_NULL_HANDLE; + if (vk_buffer_ != VK_NULL_HANDLE) { + vmaUnmapMemory(vma_allocator_, vk_buffer_allocation_); + vmaDestroyBuffer(vma_allocator_, vk_buffer_, vk_buffer_allocation_); + vk_buffer_ = VK_NULL_HANDLE; + vk_buffer_allocation_ = VK_NULL_HANDLE; } - for (ImportedMemory &imported_memory : m_imported_memory) { - vkDestroyImage(m_vk_device, imported_memory.vk_image_xr, nullptr); - vkFreeMemory(m_vk_device, imported_memory.vk_device_memory_xr, nullptr); + for (ImportedMemory &imported_memory : imported_memory_) { + vkDestroyImage(vk_device_, imported_memory.vk_image_xr, nullptr); + vkFreeMemory(vk_device_, imported_memory.vk_device_memory_xr, nullptr); } - m_imported_memory.clear(); + imported_memory_.clear(); /* Destroy VMA */ - if (m_vma_allocator != VK_NULL_HANDLE) { - vmaDestroyAllocator(m_vma_allocator); - m_vma_allocator = VK_NULL_HANDLE; + if (vma_allocator_ != VK_NULL_HANDLE) { + vmaDestroyAllocator(vma_allocator_); + vma_allocator_ = VK_NULL_HANDLE; } /* Destroy command buffer */ - if (m_vk_command_buffer != VK_NULL_HANDLE) { - vkFreeCommandBuffers(m_vk_device, m_vk_command_pool, 1, &m_vk_command_buffer); - m_vk_command_buffer = VK_NULL_HANDLE; + if (vk_command_buffer_ != VK_NULL_HANDLE) { + vkFreeCommandBuffers(vk_device_, vk_command_pool_, 1, &vk_command_buffer_); + vk_command_buffer_ = VK_NULL_HANDLE; } /* Destroy command pool */ - if (m_vk_command_pool != VK_NULL_HANDLE) { - vkDestroyCommandPool(m_vk_device, m_vk_command_pool, nullptr); - m_vk_command_pool = VK_NULL_HANDLE; + if (vk_command_pool_ != VK_NULL_HANDLE) { + vkDestroyCommandPool(vk_device_, vk_command_pool_, nullptr); + vk_command_pool_ = VK_NULL_HANDLE; } - m_vk_queue = VK_NULL_HANDLE; + vk_queue_ = VK_NULL_HANDLE; /* Destroy device */ - if (m_vk_device != VK_NULL_HANDLE) { - vkDestroyDevice(m_vk_device, nullptr); - m_vk_device = VK_NULL_HANDLE; + if (vk_device_ != VK_NULL_HANDLE) { + vkDestroyDevice(vk_device_, nullptr); + vk_device_ = VK_NULL_HANDLE; } /* Destroy instance */ - if (m_vk_instance != VK_NULL_HANDLE) { - vkDestroyInstance(m_vk_instance, nullptr); - m_vk_instance = VK_NULL_HANDLE; + if (vk_instance_ != VK_NULL_HANDLE) { + vkDestroyInstance(vk_instance_, nullptr); + vk_instance_ = VK_NULL_HANDLE; } s_xrGetVulkanGraphicsRequirements2KHR_fn = nullptr; @@ -133,7 +133,7 @@ bool GHOST_XrGraphicsBindingVulkan::checkVersionRequirements(GHOST_Context &ghos /* Check if the Vulkan API instance version is supported. */ GHOST_ContextVK &context_vk = static_cast(ghost_ctx); const XrVersion vk_version = XR_MAKE_VERSION( - context_vk.m_context_major_version, context_vk.m_context_minor_version, 0); + context_vk.context_major_version_, context_vk.context_minor_version_, 0); if (vk_version < xr_graphics_requirements.minApiVersionSupported || vk_version > xr_graphics_requirements.maxApiVersionSupported) { @@ -181,28 +181,27 @@ void GHOST_XrGraphicsBindingVulkan::initFromGhostContext(GHOST_Context & /*ghost nullptr}; VkResult vk_result; CHECK_XR(s_xrCreateVulkanInstanceKHR_fn( - instance, &xr_instance_create_info, &m_vk_instance, &vk_result), + instance, &xr_instance_create_info, &vk_instance_, &vk_result), "Unable to create an OpenXR compatible Vulkan instance."); /* Physical device selection */ XrVulkanGraphicsDeviceGetInfoKHR xr_device_get_info = { - XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR, nullptr, system_id, m_vk_instance}; - CHECK_XR( - s_xrGetVulkanGraphicsDevice2KHR_fn(instance, &xr_device_get_info, &m_vk_physical_device), - "Unable to create an OpenXR compatible Vulkan physical device."); + XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR, nullptr, system_id, vk_instance_}; + CHECK_XR(s_xrGetVulkanGraphicsDevice2KHR_fn(instance, &xr_device_get_info, &vk_physical_device_), + "Unable to create an OpenXR compatible Vulkan physical device."); /* Queue family */ uint32_t vk_queue_family_count = 0; - vkGetPhysicalDeviceQueueFamilyProperties(m_vk_physical_device, &vk_queue_family_count, nullptr); + vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device_, &vk_queue_family_count, nullptr); std::vector vk_queue_families(vk_queue_family_count); - m_graphics_queue_family = 0; + graphics_queue_family_ = 0; vkGetPhysicalDeviceQueueFamilyProperties( - m_vk_physical_device, &vk_queue_family_count, vk_queue_families.data()); + vk_physical_device_, &vk_queue_family_count, vk_queue_families.data()); for (uint32_t i = 0; i < vk_queue_family_count; i++) { if (vk_queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT && vk_queue_families[i].queueFlags & VK_QUEUE_TRANSFER_BIT) { - m_graphics_queue_family = i; + graphics_queue_family_ = i; break; } } @@ -212,7 +211,7 @@ void GHOST_XrGraphicsBindingVulkan::initFromGhostContext(GHOST_Context & /*ghost VkDeviceQueueCreateInfo vk_queue_create_info = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, - m_graphics_queue_family, + graphics_queue_family_, 1, &queue_priority}; VkDeviceCreateInfo vk_device_create_info = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, @@ -229,60 +228,59 @@ void GHOST_XrGraphicsBindingVulkan::initFromGhostContext(GHOST_Context & /*ghost system_id, 0, vkGetInstanceProcAddr, - m_vk_physical_device, + vk_physical_device_, &vk_device_create_info, nullptr}; - CHECK_XR( - s_xrCreateVulkanDeviceKHR_fn(instance, &xr_device_create_info, &m_vk_device, &vk_result), - "Unable to create an OpenXR compatible Vulkan logical device."); + CHECK_XR(s_xrCreateVulkanDeviceKHR_fn(instance, &xr_device_create_info, &vk_device_, &vk_result), + "Unable to create an OpenXR compatible Vulkan logical device."); - vkGetDeviceQueue(m_vk_device, m_graphics_queue_family, 0, &m_vk_queue); + vkGetDeviceQueue(vk_device_, graphics_queue_family_, 0, &vk_queue_); /* Command buffer pool */ VkCommandPoolCreateInfo vk_command_pool_create_info = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, - m_graphics_queue_family}; - vkCreateCommandPool(m_vk_device, &vk_command_pool_create_info, nullptr, &m_vk_command_pool); + graphics_queue_family_}; + vkCreateCommandPool(vk_device_, &vk_command_pool_create_info, nullptr, &vk_command_pool_); /* Command buffer */ VkCommandBufferAllocateInfo vk_command_buffer_allocate_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, nullptr, - m_vk_command_pool, + vk_command_pool_, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1}; - vkAllocateCommandBuffers(m_vk_device, &vk_command_buffer_allocate_info, &m_vk_command_buffer); + vkAllocateCommandBuffers(vk_device_, &vk_command_buffer_allocate_info, &vk_command_buffer_); /* Select the best data transfer mode based on the OpenXR device and ContextVK. */ - m_data_transfer_mode = choseDataTransferMode(); + data_transfer_mode_ = choseDataTransferMode(); - if (m_data_transfer_mode == GHOST_kVulkanXRModeCPU) { + if (data_transfer_mode_ == GHOST_kVulkanXRModeCPU) { /* VMA */ VmaAllocatorCreateInfo allocator_create_info = {}; allocator_create_info.flags = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT; allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_2; - allocator_create_info.physicalDevice = m_vk_physical_device; - allocator_create_info.device = m_vk_device; - allocator_create_info.instance = m_vk_instance; - vmaCreateAllocator(&allocator_create_info, &m_vma_allocator); + allocator_create_info.physicalDevice = vk_physical_device_; + allocator_create_info.device = vk_device_; + allocator_create_info.instance = vk_instance_; + vmaCreateAllocator(&allocator_create_info, &vma_allocator_); } /* Update the binding struct */ oxr_binding.vk.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR; oxr_binding.vk.next = nullptr; - oxr_binding.vk.instance = m_vk_instance; - oxr_binding.vk.physicalDevice = m_vk_physical_device; - oxr_binding.vk.device = m_vk_device; - oxr_binding.vk.queueFamilyIndex = m_graphics_queue_family; + oxr_binding.vk.instance = vk_instance_; + oxr_binding.vk.physicalDevice = vk_physical_device_; + oxr_binding.vk.device = vk_device_; + oxr_binding.vk.queueFamilyIndex = graphics_queue_family_; oxr_binding.vk.queueIndex = 0; } GHOST_TVulkanXRModes GHOST_XrGraphicsBindingVulkan::choseDataTransferMode() { GHOST_VulkanHandles vulkan_handles; - m_ghost_ctx.getVulkanHandles(vulkan_handles); + ghost_ctx_.getVulkanHandles(vulkan_handles); /* Retrieve the Context physical device properties. */ VkPhysicalDeviceVulkan11Properties vk_physical_device_vulkan11_properties = { @@ -296,7 +294,7 @@ GHOST_TVulkanXRModes GHOST_XrGraphicsBindingVulkan::choseDataTransferMode() VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES}; VkPhysicalDeviceProperties2 xr_physical_device_properties = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &xr_physical_device_vulkan11_properties}; - vkGetPhysicalDeviceProperties2(m_vk_physical_device, &xr_physical_device_properties); + vkGetPhysicalDeviceProperties2(vk_physical_device_, &xr_physical_device_properties); /* When the physical device properties match between the Vulkan device and the Xr devices we * assume that they are the same physical device in the machine and we can use shared memory. @@ -418,7 +416,7 @@ std::vector GHOST_XrGraphicsBindingVulkan::createS for (XrSwapchainImageVulkan2KHR &image : vulkan_images) { base_images.push_back(reinterpret_cast(&image)); } - m_image_cache.push_back(std::move(vulkan_images)); + image_cache_.push_back(std::move(vulkan_images)); return base_images; } @@ -430,7 +428,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImage( XrSwapchainImageVulkan2KHR &vulkan_image = *reinterpret_cast( &swapchain_image); - switch (m_data_transfer_mode) { + switch (data_transfer_mode_) { case GHOST_kVulkanXRModeFD: case GHOST_kVulkanXRModeWin32: submitToSwapchainImageGpu(vulkan_image, draw_info); @@ -452,7 +450,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu( { /* Acquire frame buffer image. */ GHOST_VulkanOpenXRData openxr_data = {GHOST_kVulkanXRModeCPU}; - m_ghost_ctx.openxr_acquire_framebuffer_image_callback_(&openxr_data); + ghost_ctx_.openxr_acquire_framebuffer_image_callback_(&openxr_data); /* Import render result. */ VkDeviceSize component_size = 4 * sizeof(uint8_t); @@ -464,14 +462,14 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu( VkDeviceSize image_data_size = openxr_data.extent.width * openxr_data.extent.height * component_size; - if (m_vk_buffer != VK_NULL_HANDLE && m_vk_buffer_allocation_info.size < image_data_size) { - vmaUnmapMemory(m_vma_allocator, m_vk_buffer_allocation); - vmaDestroyBuffer(m_vma_allocator, m_vk_buffer, m_vk_buffer_allocation); - m_vk_buffer = VK_NULL_HANDLE; - m_vk_buffer_allocation = VK_NULL_HANDLE; + if (vk_buffer_ != VK_NULL_HANDLE && vk_buffer_allocation_info_.size < image_data_size) { + vmaUnmapMemory(vma_allocator_, vk_buffer_allocation_); + vmaDestroyBuffer(vma_allocator_, vk_buffer_, vk_buffer_allocation_); + vk_buffer_ = VK_NULL_HANDLE; + vk_buffer_allocation_ = VK_NULL_HANDLE; } - if (m_vk_buffer == VK_NULL_HANDLE) { + if (vk_buffer_ == VK_NULL_HANDLE) { VkBufferCreateInfo vk_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, nullptr, 0, @@ -484,20 +482,18 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu( allocation_create_info.usage = VMA_MEMORY_USAGE_AUTO; allocation_create_info.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT; allocation_create_info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; - vmaCreateBuffer(m_vma_allocator, + vmaCreateBuffer(vma_allocator_, &vk_buffer_create_info, &allocation_create_info, - &m_vk_buffer, - &m_vk_buffer_allocation, - &m_vk_buffer_allocation_info); - vmaMapMemory( - m_vma_allocator, m_vk_buffer_allocation, &m_vk_buffer_allocation_info.pMappedData); + &vk_buffer_, + &vk_buffer_allocation_, + &vk_buffer_allocation_info_); + vmaMapMemory(vma_allocator_, vk_buffer_allocation_, &vk_buffer_allocation_info_.pMappedData); } - std::memcpy( - m_vk_buffer_allocation_info.pMappedData, openxr_data.cpu.image_data, image_data_size); + std::memcpy(vk_buffer_allocation_info_.pMappedData, openxr_data.cpu.image_data, image_data_size); /* Copy frame buffer image to swapchain image. */ - VkCommandBuffer vk_command_buffer = m_vk_command_buffer; + VkCommandBuffer vk_command_buffer = vk_command_buffer_; /* - Begin command recording */ VkCommandBufferBeginInfo vk_command_buffer_begin_info = { @@ -538,7 +534,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu( {draw_info.ofsx, draw_info.ofsy, 0}, {openxr_data.extent.width, openxr_data.extent.height, 1}}; vkCmdCopyBufferToImage(vk_command_buffer, - m_vk_buffer, + vk_buffer_, swapchain_image.image, VK_IMAGE_LAYOUT_GENERAL, 1, @@ -549,16 +545,16 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu( /* - Submit command buffer to queue. */ VkSubmitInfo vk_submit_info = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &vk_command_buffer}; - vkQueueSubmit(m_vk_queue, 1, &vk_submit_info, VK_NULL_HANDLE); + vkQueueSubmit(vk_queue_, 1, &vk_submit_info, VK_NULL_HANDLE); /* - Wait until device is idle. */ - vkQueueWaitIdle(m_vk_queue); + vkQueueWaitIdle(vk_queue_); /* - Reset command buffer for next eye/frame */ vkResetCommandBuffer(vk_command_buffer, 0); /* Release frame buffer image. */ - m_ghost_ctx.openxr_release_framebuffer_image_callback_(&openxr_data); + ghost_ctx_.openxr_release_framebuffer_image_callback_(&openxr_data); } /* \} */ @@ -572,28 +568,28 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( { /* Check for previous imported memory. */ ImportedMemory *imported_memory = nullptr; - for (ImportedMemory &item : m_imported_memory) { + for (ImportedMemory &item : imported_memory_) { if (item.view_idx == draw_info.view_idx) { imported_memory = &item; } } /* No previous imported memory found, creating a new. */ if (imported_memory == nullptr) { - m_imported_memory.push_back( + imported_memory_.push_back( {draw_info.view_idx, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE}); - imported_memory = &m_imported_memory.back(); + imported_memory = &imported_memory_.back(); } - GHOST_VulkanOpenXRData openxr_data = {m_data_transfer_mode}; + GHOST_VulkanOpenXRData openxr_data = {data_transfer_mode_}; openxr_data.gpu.vk_image_blender = imported_memory->vk_image_blender; - m_ghost_ctx.openxr_acquire_framebuffer_image_callback_(&openxr_data); + ghost_ctx_.openxr_acquire_framebuffer_image_callback_(&openxr_data); imported_memory->vk_image_blender = openxr_data.gpu.vk_image_blender; /* Create an image handle */ if (openxr_data.gpu.new_handle) { if (imported_memory->vk_image_xr) { - vkDestroyImage(m_vk_device, imported_memory->vk_image_xr, nullptr); - vkFreeMemory(m_vk_device, imported_memory->vk_device_memory_xr, nullptr); + vkDestroyImage(vk_device_, imported_memory->vk_image_xr, nullptr); + vkFreeMemory(vk_device_, imported_memory->vk_device_memory_xr, nullptr); imported_memory->vk_device_memory_xr = VK_NULL_HANDLE; imported_memory->vk_image_xr = VK_NULL_HANDLE; } @@ -601,7 +597,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( VkExternalMemoryImageCreateInfo vk_external_memory_image_info = { VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, nullptr, 0}; - switch (m_data_transfer_mode) { + switch (data_transfer_mode_) { case GHOST_kVulkanXRModeFD: vk_external_memory_image_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT; break; @@ -629,12 +625,12 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; - vkCreateImage(m_vk_device, &vk_image_info, nullptr, &imported_memory->vk_image_xr); + vkCreateImage(vk_device_, &vk_image_info, nullptr, &imported_memory->vk_image_xr); /* Get the memory requirements */ VkMemoryRequirements vk_memory_requirements = {}; vkGetImageMemoryRequirements( - m_vk_device, imported_memory->vk_image_xr, &vk_memory_requirements); + vk_device_, imported_memory->vk_image_xr, &vk_memory_requirements); /* Import the memory */ VkMemoryDedicatedAllocateInfo vk_memory_dedicated_allocation_info = { @@ -642,7 +638,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( nullptr, imported_memory->vk_image_xr, VK_NULL_HANDLE}; - switch (m_data_transfer_mode) { + switch (data_transfer_mode_) { case GHOST_kVulkanXRModeFD: { VkImportMemoryFdInfoKHR import_memory_info = {VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, &vk_memory_dedicated_allocation_info, @@ -652,7 +648,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( &import_memory_info, vk_memory_requirements.size}; vkAllocateMemory( - m_vk_device, &allocate_info, nullptr, &imported_memory->vk_device_memory_xr); + vk_device_, &allocate_info, nullptr, &imported_memory->vk_device_memory_xr); break; } @@ -667,7 +663,7 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( &import_memory_info, vk_memory_requirements.size}; vkAllocateMemory( - m_vk_device, &allocate_info, nullptr, &imported_memory->vk_device_memory_xr); + vk_device_, &allocate_info, nullptr, &imported_memory->vk_device_memory_xr); #endif break; } @@ -677,14 +673,14 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( } /* Bind the imported memory to the image. */ - vkBindImageMemory(m_vk_device, + vkBindImageMemory(vk_device_, imported_memory->vk_image_xr, imported_memory->vk_device_memory_xr, openxr_data.gpu.memory_offset); } /* Copy frame buffer image to swapchain image. */ - VkCommandBuffer vk_command_buffer = m_vk_command_buffer; + VkCommandBuffer vk_command_buffer = vk_command_buffer_; /* Begin command recording */ VkCommandBufferBeginInfo vk_command_buffer_begin_info = { @@ -767,10 +763,10 @@ void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu( /* Submit command buffer to queue. */ VkSubmitInfo vk_submit_info = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr, 0, nullptr, nullptr, 1, &vk_command_buffer}; - vkQueueSubmit(m_vk_queue, 1, &vk_submit_info, VK_NULL_HANDLE); + vkQueueSubmit(vk_queue_, 1, &vk_submit_info, VK_NULL_HANDLE); /* Wait until device is idle. */ - vkQueueWaitIdle(m_vk_queue); + vkQueueWaitIdle(vk_queue_); /* Reset command buffer for next eye/frame. */ vkResetCommandBuffer(vk_command_buffer, 0); diff --git a/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.hh b/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.hh index 32e915b7a87..ed99584bec5 100644 --- a/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.hh +++ b/intern/ghost/intern/GHOST_XrGraphicsBindingVulkan.hh @@ -50,21 +50,21 @@ class GHOST_XrGraphicsBindingVulkan : public GHOST_IXrGraphicsBinding { bool needsUpsideDownDrawing(GHOST_Context &ghost_ctx) const override; private: - GHOST_ContextVK &m_ghost_ctx; + GHOST_ContextVK &ghost_ctx_; - VkInstance m_vk_instance = VK_NULL_HANDLE; - VkPhysicalDevice m_vk_physical_device = VK_NULL_HANDLE; - uint32_t m_graphics_queue_family = 0; - VkQueue m_vk_queue = VK_NULL_HANDLE; - VkDevice m_vk_device = VK_NULL_HANDLE; - VmaAllocator m_vma_allocator = VK_NULL_HANDLE; - VmaAllocation m_vk_buffer_allocation = VK_NULL_HANDLE; - VkBuffer m_vk_buffer = VK_NULL_HANDLE; - VmaAllocationInfo m_vk_buffer_allocation_info = {}; - GHOST_TVulkanXRModes m_data_transfer_mode = GHOST_kVulkanXRModeCPU; + VkInstance vk_instance_ = VK_NULL_HANDLE; + VkPhysicalDevice vk_physical_device_ = VK_NULL_HANDLE; + uint32_t graphics_queue_family_ = 0; + VkQueue vk_queue_ = VK_NULL_HANDLE; + VkDevice vk_device_ = VK_NULL_HANDLE; + VmaAllocator vma_allocator_ = VK_NULL_HANDLE; + VmaAllocation vk_buffer_allocation_ = VK_NULL_HANDLE; + VkBuffer vk_buffer_ = VK_NULL_HANDLE; + VmaAllocationInfo vk_buffer_allocation_info_ = {}; + GHOST_TVulkanXRModes data_transfer_mode_ = GHOST_kVulkanXRModeCPU; - std::list> m_image_cache; - VkCommandPool m_vk_command_pool = VK_NULL_HANDLE; + std::list> image_cache_; + VkCommandPool vk_command_pool_ = VK_NULL_HANDLE; struct ImportedMemory { char view_idx; @@ -72,7 +72,7 @@ class GHOST_XrGraphicsBindingVulkan : public GHOST_IXrGraphicsBinding { VkImage vk_image_xr; VkDeviceMemory vk_device_memory_xr; }; - std::vector m_imported_memory; + std::vector imported_memory_; GHOST_TVulkanXRModes choseDataTransferMode(); void submitToSwapchainImageCpu(XrSwapchainImageVulkan2KHR &swapchain_image, @@ -85,7 +85,7 @@ class GHOST_XrGraphicsBindingVulkan : public GHOST_IXrGraphicsBinding { * * This can be improved by having a single command buffer per swap-chain image. */ - VkCommandBuffer m_vk_command_buffer = VK_NULL_HANDLE; + VkCommandBuffer vk_command_buffer_ = VK_NULL_HANDLE; static PFN_xrGetVulkanGraphicsRequirements2KHR s_xrGetVulkanGraphicsRequirements2KHR_fn; static PFN_xrGetVulkanGraphicsDevice2KHR s_xrGetVulkanGraphicsDevice2KHR_fn; diff --git a/intern/ghost/intern/GHOST_XrSession.cc b/intern/ghost/intern/GHOST_XrSession.cc index 0d7de276c23..0b70d146523 100644 --- a/intern/ghost/intern/GHOST_XrSession.cc +++ b/intern/ghost/intern/GHOST_XrSession.cc @@ -66,7 +66,7 @@ struct GHOST_XrDrawInfo { * \{ */ GHOST_XrSession::GHOST_XrSession(GHOST_XrContext &xr_context) - : m_context(&xr_context), m_oxr(std::make_unique()) + : context_(&xr_context), oxr_(std::make_unique()) { } @@ -74,29 +74,29 @@ GHOST_XrSession::~GHOST_XrSession() { unbindGraphicsContext(); - m_oxr->swapchains.clear(); - m_oxr->action_sets.clear(); + oxr_->swapchains.clear(); + oxr_->action_sets.clear(); - if (m_oxr->reference_space != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySpace(m_oxr->reference_space)); + if (oxr_->reference_space != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySpace(oxr_->reference_space)); } - if (m_oxr->view_space != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySpace(m_oxr->view_space)); + if (oxr_->view_space != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySpace(oxr_->view_space)); } - if (m_oxr->combined_eye_space != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySpace(m_oxr->combined_eye_space)); + if (oxr_->combined_eye_space != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySpace(oxr_->combined_eye_space)); } - if (m_oxr->session != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySession(m_oxr->session)); + if (oxr_->session != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySession(oxr_->session)); } - m_oxr->session = XR_NULL_HANDLE; - m_oxr->session_state = XR_SESSION_STATE_UNKNOWN; + oxr_->session = XR_NULL_HANDLE; + oxr_->session_state = XR_SESSION_STATE_UNKNOWN; - m_oxr->passthrough_supported = false; - m_oxr->passthrough_layer.layerHandle = XR_NULL_HANDLE; + oxr_->passthrough_supported = false; + oxr_->passthrough_layer.layerHandle = XR_NULL_HANDLE; - m_context->getCustomFuncs().session_exit_fn(m_context->getCustomFuncs().session_exit_customdata); + context_->getCustomFuncs().session_exit_fn(context_->getCustomFuncs().session_exit_customdata); } /** @@ -105,14 +105,14 @@ GHOST_XrSession::~GHOST_XrSession() */ void GHOST_XrSession::initSystem() { - assert(m_context->getInstance() != XR_NULL_HANDLE); - assert(m_oxr->system_id == XR_NULL_SYSTEM_ID); + assert(context_->getInstance() != XR_NULL_HANDLE); + assert(oxr_->system_id == XR_NULL_SYSTEM_ID); XrSystemGetInfo system_info = {}; system_info.type = XR_TYPE_SYSTEM_GET_INFO; system_info.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; - CHECK_XR(xrGetSystem(m_context->getInstance(), &system_info, &m_oxr->system_id), + CHECK_XR(xrGetSystem(context_->getInstance(), &system_info, &oxr_->system_id), "Failed to get device information. Is a device plugged in?"); } @@ -211,9 +211,9 @@ static void create_reference_spaces(OpenXRSessionData &oxr, void GHOST_XrSession::start(const GHOST_XrSessionBeginInfo *begin_info) { - assert(m_context->getInstance() != XR_NULL_HANDLE); - assert(m_oxr->session == XR_NULL_HANDLE); - if (m_context->getCustomFuncs().gpu_ctx_bind_fn == nullptr) { + assert(context_->getInstance() != XR_NULL_HANDLE); + assert(oxr_->session == XR_NULL_HANDLE); + if (context_->getCustomFuncs().gpu_ctx_bind_fn == nullptr) { throw GHOST_XrException( "Invalid API usage: No way to bind graphics context to the XR session. Call " "GHOST_XrGraphicsContextBindFuncs() with valid parameters before starting the " @@ -223,7 +223,7 @@ void GHOST_XrSession::start(const GHOST_XrSessionBeginInfo *begin_info) initSystem(); bindGraphicsContext(); - if (m_gpu_ctx == nullptr) { + if (gpu_ctx_ == nullptr) { throw GHOST_XrException( "Invalid API usage: No graphics context returned through the callback set with " "GHOST_XrGraphicsContextBindFuncs(). This is required for session starting (through " @@ -231,62 +231,62 @@ void GHOST_XrSession::start(const GHOST_XrSessionBeginInfo *begin_info) } std::string requirement_str; - m_gpu_binding = GHOST_XrGraphicsBindingCreateFromType(m_context->getGraphicsBindingType(), - *m_gpu_ctx); - if (!m_gpu_binding->checkVersionRequirements( - *m_gpu_ctx, m_context->getInstance(), m_oxr->system_id, &requirement_str)) + gpu_binding_ = GHOST_XrGraphicsBindingCreateFromType(context_->getGraphicsBindingType(), + *gpu_ctx_); + if (!gpu_binding_->checkVersionRequirements( + *gpu_ctx_, context_->getInstance(), oxr_->system_id, &requirement_str)) { std::ostringstream strstream; strstream << "Available graphics context version does not meet the following requirements: " << requirement_str; throw GHOST_XrException(strstream.str().data()); } - m_gpu_binding->initFromGhostContext(*m_gpu_ctx, m_context->getInstance(), m_oxr->system_id); + gpu_binding_->initFromGhostContext(*gpu_ctx_, context_->getInstance(), oxr_->system_id); XrSessionCreateInfo create_info = {}; create_info.type = XR_TYPE_SESSION_CREATE_INFO; - create_info.systemId = m_oxr->system_id; - create_info.next = &m_gpu_binding->oxr_binding; + create_info.systemId = oxr_->system_id; + create_info.next = &gpu_binding_->oxr_binding; - CHECK_XR(xrCreateSession(m_context->getInstance(), &create_info, &m_oxr->session), + CHECK_XR(xrCreateSession(context_->getInstance(), &create_info, &oxr_->session), "Failed to create VR session. The OpenXR runtime may have additional requirements for " "the graphics driver that are not met. Other causes are possible too however.\nTip: " "The --debug-xr command line option for Blender might allow the runtime to output " "detailed error information to the command line."); prepareDrawing(); - create_reference_spaces(*m_oxr, begin_info->base_pose, m_context->isDebugMode()); + create_reference_spaces(*oxr_, begin_info->base_pose, context_->isDebugMode()); /* Create and bind actions here. */ - m_context->getCustomFuncs().session_create_fn(); + context_->getCustomFuncs().session_create_fn(); } void GHOST_XrSession::requestEnd() { - xrRequestExitSession(m_oxr->session); + xrRequestExitSession(oxr_->session); } void GHOST_XrSession::beginSession() { XrSessionBeginInfo begin_info = {XR_TYPE_SESSION_BEGIN_INFO}; - begin_info.primaryViewConfigurationType = m_oxr->view_type; - CHECK_XR(xrBeginSession(m_oxr->session, &begin_info), "Failed to cleanly begin the VR session."); + begin_info.primaryViewConfigurationType = oxr_->view_type; + CHECK_XR(xrBeginSession(oxr_->session, &begin_info), "Failed to cleanly begin the VR session."); } void GHOST_XrSession::endSession() { - assert(m_oxr->session != XR_NULL_HANDLE); - CHECK_XR(xrEndSession(m_oxr->session), "Failed to cleanly end the VR session."); + assert(oxr_->session != XR_NULL_HANDLE); + CHECK_XR(xrEndSession(oxr_->session), "Failed to cleanly end the VR session."); } GHOST_XrSession::LifeExpectancy GHOST_XrSession::handleStateChangeEvent( const XrEventDataSessionStateChanged &lifecycle) { - m_oxr->session_state = lifecycle.state; + oxr_->session_state = lifecycle.state; /* Runtime may send events for apparently destroyed session. Our handle should be nullptr then. */ - assert(m_oxr->session == XR_NULL_HANDLE || m_oxr->session == lifecycle.session); + assert(oxr_->session == XR_NULL_HANDLE || oxr_->session == lifecycle.session); switch (lifecycle.state) { case XR_SESSION_STATE_READY: @@ -313,34 +313,33 @@ GHOST_XrSession::LifeExpectancy GHOST_XrSession::handleStateChangeEvent( void GHOST_XrSession::prepareDrawing() { - assert(m_context->getInstance() != XR_NULL_HANDLE); + assert(context_->getInstance() != XR_NULL_HANDLE); std::vector view_configs; uint32_t view_count; /* Attempt to use quad view if supported. */ - if (m_context->isExtensionEnabled(XR_VARJO_QUAD_VIEWS_EXTENSION_NAME)) { - m_oxr->view_type = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO; + if (context_->isExtensionEnabled(XR_VARJO_QUAD_VIEWS_EXTENSION_NAME)) { + oxr_->view_type = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO; } - m_oxr->foveation_supported = m_context->isExtensionEnabled( + oxr_->foveation_supported = context_->isExtensionEnabled( XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME); - CHECK_XR( - xrEnumerateViewConfigurationViews( - m_context->getInstance(), m_oxr->system_id, m_oxr->view_type, 0, &view_count, nullptr), - "Failed to get count of view configurations."); + CHECK_XR(xrEnumerateViewConfigurationViews( + context_->getInstance(), oxr_->system_id, oxr_->view_type, 0, &view_count, nullptr), + "Failed to get count of view configurations."); view_configs.resize(view_count, {XR_TYPE_VIEW_CONFIGURATION_VIEW}); - CHECK_XR(xrEnumerateViewConfigurationViews(m_context->getInstance(), - m_oxr->system_id, - m_oxr->view_type, + CHECK_XR(xrEnumerateViewConfigurationViews(context_->getInstance(), + oxr_->system_id, + oxr_->view_type, view_configs.size(), &view_count, view_configs.data()), "Failed to get view configurations."); /* If foveated rendering is used, query the foveated views. */ - if (m_oxr->foveation_supported) { + if (oxr_->foveation_supported) { std::vector request_foveated_config{ view_count, {XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO, nullptr, XR_TRUE}}; @@ -350,9 +349,9 @@ void GHOST_XrSession::prepareDrawing() for (uint32_t i = 0; i < view_count; i++) { foveated_views[i].next = &request_foveated_config[i]; } - CHECK_XR(xrEnumerateViewConfigurationViews(m_context->getInstance(), - m_oxr->system_id, - m_oxr->view_type, + CHECK_XR(xrEnumerateViewConfigurationViews(context_->getInstance(), + oxr_->system_id, + oxr_->view_type, view_configs.size(), &view_count, foveated_views.data()), @@ -369,12 +368,12 @@ void GHOST_XrSession::prepareDrawing() } for (const XrViewConfigurationView &view_config : view_configs) { - m_oxr->swapchains.emplace_back(*m_gpu_binding, m_oxr->session, view_config); + oxr_->swapchains.emplace_back(*gpu_binding_, oxr_->session, view_config); } - m_oxr->views.resize(view_count, {XR_TYPE_VIEW}); + oxr_->views.resize(view_count, {XR_TYPE_VIEW}); - m_draw_info = std::make_unique(); + draw_info_ = std::make_unique(); } void GHOST_XrSession::beginFrameDrawing() @@ -384,30 +383,30 @@ void GHOST_XrSession::beginFrameDrawing() XrFrameState frame_state = {XR_TYPE_FRAME_STATE}; /* TODO Blocking call. Drawing should run on a separate thread to avoid interferences. */ - CHECK_XR(xrWaitFrame(m_oxr->session, &wait_info, &frame_state), + CHECK_XR(xrWaitFrame(oxr_->session, &wait_info, &frame_state), "Failed to synchronize frame rates between Blender and the device."); /* Check if we have foveation available for the current frame. */ - m_draw_info->foveation_active = false; - if (m_oxr->foveation_supported) { + draw_info_->foveation_active = false; + if (oxr_->foveation_supported) { XrSpaceLocation render_gaze_location{XR_TYPE_SPACE_LOCATION}; - CHECK_XR(xrLocateSpace(m_oxr->combined_eye_space, - m_oxr->view_space, + CHECK_XR(xrLocateSpace(oxr_->combined_eye_space, + oxr_->view_space, frame_state.predictedDisplayTime, &render_gaze_location), "Failed to locate combined eye space."); - m_draw_info->foveation_active = (render_gaze_location.locationFlags & - XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT) != 0; + draw_info_->foveation_active = (render_gaze_location.locationFlags & + XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT) != 0; } - CHECK_XR(xrBeginFrame(m_oxr->session, &begin_info), + CHECK_XR(xrBeginFrame(oxr_->session, &begin_info), "Failed to submit frame rendering start state."); - m_draw_info->frame_state = frame_state; + draw_info_->frame_state = frame_state; - if (m_context->isDebugTimeMode()) { - m_draw_info->frame_begin_time = std::chrono::high_resolution_clock::now(); + if (context_->isDebugTimeMode()) { + draw_info_->frame_begin_time = std::chrono::high_resolution_clock::now(); } } @@ -439,15 +438,15 @@ void GHOST_XrSession::endFrameDrawing(std::vectorframe_state.predictedDisplayTime; + end_info.displayTime = draw_info_->frame_state.predictedDisplayTime; end_info.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE; end_info.layerCount = layers.size(); end_info.layers = layers.data(); - CHECK_XR(xrEndFrame(m_oxr->session, &end_info), "Failed to submit rendered frame."); + CHECK_XR(xrEndFrame(oxr_->session, &end_info), "Failed to submit rendered frame."); - if (m_context->isDebugTimeMode()) { - print_debug_timings(*m_draw_info); + if (context_->isDebugTimeMode()) { + print_debug_timings(*draw_info_); } } @@ -460,17 +459,17 @@ void GHOST_XrSession::draw(void *draw_customdata) beginFrameDrawing(); - if (m_context->getCustomFuncs().passthrough_enabled_fn(draw_customdata)) { + if (context_->getCustomFuncs().passthrough_enabled_fn(draw_customdata)) { enablePassthrough(); - if (m_oxr->passthrough_supported) { - layers.push_back((XrCompositionLayerBaseHeader *)&m_oxr->passthrough_layer); + if (oxr_->passthrough_supported) { + layers.push_back((XrCompositionLayerBaseHeader *)&oxr_->passthrough_layer); } else { - m_context->getCustomFuncs().disable_passthrough_fn(draw_customdata); + context_->getCustomFuncs().disable_passthrough_fn(draw_customdata); } } - if (m_draw_info->frame_state.shouldRender) { + if (draw_info_->frame_state.shouldRender) { proj_layer = drawLayer(projection_layer_views, draw_customdata); if (layers.size() > 0) { proj_layer.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT; @@ -518,8 +517,8 @@ void GHOST_XrSession::drawView(GHOST_XrSwapchain &swapchain, ghost_xr_draw_view_info_from_view(view, draw_view_info); /* Draw! */ - m_context->getCustomFuncs().draw_view_fn(&draw_view_info, draw_customdata); - m_gpu_binding->submitToSwapchainImage(swapchain_image, draw_view_info); + context_->getCustomFuncs().draw_view_fn(&draw_view_info, draw_customdata); + gpu_binding_->submitToSwapchainImage(swapchain_image, draw_view_info); } XrCompositionLayerProjection GHOST_XrSession::drawLayer( @@ -533,59 +532,58 @@ XrCompositionLayerProjection GHOST_XrSession::drawLayer( XrSpaceLocation view_location{XR_TYPE_SPACE_LOCATION}; uint32_t view_count; - viewloc_info.viewConfigurationType = m_oxr->view_type; - viewloc_info.displayTime = m_draw_info->frame_state.predictedDisplayTime; - viewloc_info.space = m_oxr->reference_space; + viewloc_info.viewConfigurationType = oxr_->view_type; + viewloc_info.displayTime = draw_info_->frame_state.predictedDisplayTime; + viewloc_info.space = oxr_->reference_space; - if (m_draw_info->foveation_active) { + if (draw_info_->foveation_active) { viewloc_info.next = &foveated_info; } - CHECK_XR(xrLocateViews(m_oxr->session, + CHECK_XR(xrLocateViews(oxr_->session, &viewloc_info, &view_state, - m_oxr->views.size(), + oxr_->views.size(), &view_count, - m_oxr->views.data()), + oxr_->views.data()), "Failed to query frame view and projection state."); - assert(m_oxr->swapchains.size() == view_count); + assert(oxr_->swapchains.size() == view_count); - CHECK_XR( - xrLocateSpace( - m_oxr->view_space, m_oxr->reference_space, viewloc_info.displayTime, &view_location), - "Failed to query frame view space"); + CHECK_XR(xrLocateSpace( + oxr_->view_space, oxr_->reference_space, viewloc_info.displayTime, &view_location), + "Failed to query frame view space"); r_proj_layer_views.resize(view_count); std::vector swapchain_images; swapchain_images.resize(view_count); for (uint32_t view_idx = 0; view_idx < view_count; view_idx++) { - GHOST_XrSwapchain &swapchain = m_oxr->swapchains[view_idx]; + GHOST_XrSwapchain &swapchain = oxr_->swapchains[view_idx]; swapchain_images[view_idx] = swapchain.acquireDrawableSwapchainImage(); } - m_gpu_binding->submitToSwapchainBegin(); + gpu_binding_->submitToSwapchainBegin(); for (uint32_t view_idx = 0; view_idx < view_count; view_idx++) { - GHOST_XrSwapchain &swapchain = m_oxr->swapchains[view_idx]; + GHOST_XrSwapchain &swapchain = oxr_->swapchains[view_idx]; XrSwapchainImageBaseHeader &swapchain_image = *swapchain_images[view_idx]; drawView(swapchain, swapchain_image, r_proj_layer_views[view_idx], view_location, - m_oxr->views[view_idx], + oxr_->views[view_idx], view_idx, draw_customdata); } - m_gpu_binding->submitToSwapchainEnd(); + gpu_binding_->submitToSwapchainEnd(); for (uint32_t view_idx = 0; view_idx < view_count; view_idx++) { - GHOST_XrSwapchain &swapchain = m_oxr->swapchains[view_idx]; + GHOST_XrSwapchain &swapchain = oxr_->swapchains[view_idx]; swapchain.releaseImage(); swapchain_images[view_idx] = nullptr; } - layer.space = m_oxr->reference_space; + layer.space = oxr_->reference_space; layer.viewCount = r_proj_layer_views.size(); layer.views = r_proj_layer_views.data(); @@ -594,7 +592,7 @@ XrCompositionLayerProjection GHOST_XrSession::drawLayer( bool GHOST_XrSession::needsUpsideDownDrawing() const { - return m_gpu_binding && m_gpu_binding->needsUpsideDownDrawing(*m_gpu_ctx); + return gpu_binding_ && gpu_binding_->needsUpsideDownDrawing(*gpu_ctx_); } /** \} */ /* Drawing */ @@ -605,10 +603,10 @@ bool GHOST_XrSession::needsUpsideDownDrawing() const bool GHOST_XrSession::isRunning() const { - if (m_oxr->session == XR_NULL_HANDLE) { + if (oxr_->session == XR_NULL_HANDLE) { return false; } - switch (m_oxr->session_state) { + switch (oxr_->session_state) { case XR_SESSION_STATE_READY: case XR_SESSION_STATE_SYNCHRONIZED: case XR_SESSION_STATE_VISIBLE: @@ -633,18 +631,18 @@ bool GHOST_XrSession::isRunning() const void GHOST_XrSession::bindGraphicsContext() { - const GHOST_XrCustomFuncs &custom_funcs = m_context->getCustomFuncs(); + const GHOST_XrCustomFuncs &custom_funcs = context_->getCustomFuncs(); assert(custom_funcs.gpu_ctx_bind_fn); - m_gpu_ctx = static_cast(custom_funcs.gpu_ctx_bind_fn()); + gpu_ctx_ = static_cast(custom_funcs.gpu_ctx_bind_fn()); } void GHOST_XrSession::unbindGraphicsContext() { - const GHOST_XrCustomFuncs &custom_funcs = m_context->getCustomFuncs(); + const GHOST_XrCustomFuncs &custom_funcs = context_->getCustomFuncs(); if (custom_funcs.gpu_ctx_unbind_fn) { - custom_funcs.gpu_ctx_unbind_fn((GHOST_ContextHandle)m_gpu_ctx); + custom_funcs.gpu_ctx_unbind_fn((GHOST_ContextHandle)gpu_ctx_); } - m_gpu_ctx = nullptr; + gpu_ctx_ = nullptr; } /** \} */ /* Graphics Context Injection */ @@ -665,12 +663,12 @@ static GHOST_XrActionSet *find_action_set(OpenXRSessionData *oxr, const char *ac bool GHOST_XrSession::createActionSet(const GHOST_XrActionSetInfo &info) { - std::map &action_sets = m_oxr->action_sets; + std::map &action_sets = oxr_->action_sets; if (action_sets.find(info.name) != action_sets.end()) { return false; } - XrInstance instance = m_context->getInstance(); + XrInstance instance = context_->getInstance(); action_sets.emplace( std::piecewise_construct, std::make_tuple(info.name), std::make_tuple(instance, info)); @@ -680,7 +678,7 @@ bool GHOST_XrSession::createActionSet(const GHOST_XrActionSetInfo &info) void GHOST_XrSession::destroyActionSet(const char *action_set_name) { - std::map &action_sets = m_oxr->action_sets; + std::map &action_sets = oxr_->action_sets; /* It's possible nothing is removed. */ action_sets.erase(action_set_name); } @@ -689,12 +687,12 @@ bool GHOST_XrSession::createActions(const char *action_set_name, uint32_t count, const GHOST_XrActionInfo *infos) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return false; } - XrInstance instance = m_context->getInstance(); + XrInstance instance = context_->getInstance(); for (uint32_t i = 0; i < count; ++i) { if (!action_set->createAction(instance, infos[i])) { @@ -709,7 +707,7 @@ void GHOST_XrSession::destroyActions(const char *action_set_name, uint32_t count, const char *const *action_names) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return; } @@ -723,13 +721,13 @@ bool GHOST_XrSession::createActionBindings(const char *action_set_name, uint32_t count, const GHOST_XrActionProfileInfo *infos) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return false; } - XrInstance instance = m_context->getInstance(); - XrSession session = m_oxr->session; + XrInstance instance = context_->getInstance(); + XrSession session = oxr_->session; for (uint32_t profile_idx = 0; profile_idx < count; ++profile_idx) { const GHOST_XrActionProfileInfo &info = infos[profile_idx]; @@ -750,7 +748,7 @@ void GHOST_XrSession::destroyActionBindings(const char *action_set_name, const char *const *action_names, const char *const *profile_paths) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return; } @@ -769,7 +767,7 @@ bool GHOST_XrSession::attachActionSets() { /* Suggest action bindings for all action sets. */ std::map> profile_bindings; - for (auto &[name, action_set] : m_oxr->action_sets) { + for (auto &[name, action_set] : oxr_->action_sets) { action_set.getBindings(profile_bindings); } @@ -779,7 +777,7 @@ bool GHOST_XrSession::attachActionSets() XrInteractionProfileSuggestedBinding bindings_info{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; - XrInstance instance = m_context->getInstance(); + XrInstance instance = context_->getInstance(); for (auto &[profile, bindings] : profile_bindings) { bindings_info.interactionProfile = profile; @@ -792,17 +790,17 @@ bool GHOST_XrSession::attachActionSets() /* Attach action sets. */ XrSessionActionSetsAttachInfo attach_info{XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO}; - attach_info.countActionSets = uint32_t(m_oxr->action_sets.size()); + attach_info.countActionSets = uint32_t(oxr_->action_sets.size()); /* Create an aligned copy of the action sets to pass to xrAttachSessionActionSets(). */ std::vector action_sets(attach_info.countActionSets); uint32_t i = 0; - for (auto &[name, action_set] : m_oxr->action_sets) { + for (auto &[name, action_set] : oxr_->action_sets) { action_sets[i++] = action_set.getActionSet(); } attach_info.actionSets = action_sets.data(); - CHECK_XR(xrAttachSessionActionSets(m_oxr->session, &attach_info), + CHECK_XR(xrAttachSessionActionSets(oxr_->session, &attach_info), "Failed to attach XR action sets."); return true; @@ -810,7 +808,7 @@ bool GHOST_XrSession::attachActionSets() bool GHOST_XrSession::syncActions(const char *action_set_name) { - std::map &action_sets = m_oxr->action_sets; + std::map &action_sets = oxr_->action_sets; XrActionsSyncInfo sync_info{XR_TYPE_ACTIONS_SYNC_INFO}; sync_info.countActiveActionSets = (action_set_name != nullptr) ? 1 : @@ -823,7 +821,7 @@ bool GHOST_XrSession::syncActions(const char *action_set_name) GHOST_XrActionSet *action_set = nullptr; if (action_set_name != nullptr) { - action_set = find_action_set(m_oxr.get(), action_set_name); + action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return false; } @@ -842,12 +840,12 @@ bool GHOST_XrSession::syncActions(const char *action_set_name) } sync_info.activeActionSets = active_action_sets.data(); - CHECK_XR(xrSyncActions(m_oxr->session, &sync_info), "Failed to synchronize XR actions."); + CHECK_XR(xrSyncActions(oxr_->session, &sync_info), "Failed to synchronize XR actions."); /* Update action states (i.e. Blender custom data). */ - XrSession session = m_oxr->session; - XrSpace reference_space = m_oxr->reference_space; - const XrTime &predicted_display_time = m_draw_info->frame_state.predictedDisplayTime; + XrSession session = oxr_->session; + XrSpace reference_space = oxr_->reference_space; + const XrTime &predicted_display_time = draw_info_->frame_state.predictedDisplayTime; if (action_set != nullptr) { action_set->updateStates(session, reference_space, predicted_display_time); @@ -868,7 +866,7 @@ bool GHOST_XrSession::applyHapticAction(const char *action_set_name, const float &frequency, const float &litude) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return false; } @@ -879,7 +877,7 @@ bool GHOST_XrSession::applyHapticAction(const char *action_set_name, } action->applyHapticFeedback( - m_oxr->session, action_name, subaction_path, duration, frequency, amplitude); + oxr_->session, action_name, subaction_path, duration, frequency, amplitude); return true; } @@ -888,7 +886,7 @@ void GHOST_XrSession::stopHapticAction(const char *action_set_name, const char *action_name, const char *subaction_path) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return; } @@ -898,12 +896,12 @@ void GHOST_XrSession::stopHapticAction(const char *action_set_name, return; } - action->stopHapticFeedback(m_oxr->session, action_name, subaction_path); + action->stopHapticFeedback(oxr_->session, action_name, subaction_path); } void *GHOST_XrSession::getActionSetCustomdata(const char *action_set_name) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return nullptr; } @@ -913,7 +911,7 @@ void *GHOST_XrSession::getActionSetCustomdata(const char *action_set_name) void *GHOST_XrSession::getActionCustomdata(const char *action_set_name, const char *action_name) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return nullptr; } @@ -928,7 +926,7 @@ void *GHOST_XrSession::getActionCustomdata(const char *action_set_name, const ch uint32_t GHOST_XrSession::getActionCount(const char *action_set_name) { - const GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + const GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return 0; } @@ -939,7 +937,7 @@ uint32_t GHOST_XrSession::getActionCount(const char *action_set_name) void GHOST_XrSession::getActionCustomdataArray(const char *action_set_name, void **r_customdata_array) { - GHOST_XrActionSet *action_set = find_action_set(m_oxr.get(), action_set_name); + GHOST_XrActionSet *action_set = find_action_set(oxr_.get(), action_set_name); if (action_set == nullptr) { return; } @@ -956,17 +954,17 @@ void GHOST_XrSession::getActionCustomdataArray(const char *action_set_name, bool GHOST_XrSession::loadControllerModel(const char *subaction_path) { - if (!m_context->isExtensionEnabled(XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME)) { + if (!context_->isExtensionEnabled(XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME)) { return false; } - XrSession session = m_oxr->session; - std::map &controller_models = m_oxr->controller_models; + XrSession session = oxr_->session; + std::map &controller_models = oxr_->controller_models; std::map::iterator it = controller_models.find( subaction_path); if (it == controller_models.end()) { - XrInstance instance = m_context->getInstance(); + XrInstance instance = context_->getInstance(); it = controller_models .emplace(std::piecewise_construct, std::make_tuple(subaction_path), @@ -981,17 +979,17 @@ bool GHOST_XrSession::loadControllerModel(const char *subaction_path) void GHOST_XrSession::unloadControllerModel(const char *subaction_path) { - std::map &controller_models = m_oxr->controller_models; + std::map &controller_models = oxr_->controller_models; /* It's possible nothing is removed. */ controller_models.erase(subaction_path); } bool GHOST_XrSession::updateControllerModelComponents(const char *subaction_path) { - XrSession session = m_oxr->session; - std::map::iterator it = m_oxr->controller_models.find( + XrSession session = oxr_->session; + std::map::iterator it = oxr_->controller_models.find( subaction_path); - if (it == m_oxr->controller_models.end()) { + if (it == oxr_->controller_models.end()) { return false; } @@ -1003,9 +1001,9 @@ bool GHOST_XrSession::updateControllerModelComponents(const char *subaction_path bool GHOST_XrSession::getControllerModelData(const char *subaction_path, GHOST_XrControllerModelData &r_data) { - std::map::iterator it = m_oxr->controller_models.find( + std::map::iterator it = oxr_->controller_models.find( subaction_path); - if (it == m_oxr->controller_models.end()) { + if (it == oxr_->controller_models.end()) { return false; } @@ -1044,16 +1042,16 @@ static void init_passthrough_extension_functions(XrInstance instance) void GHOST_XrSession::enablePassthrough() { - if (!m_context->isExtensionEnabled(XR_FB_PASSTHROUGH_EXTENSION_NAME)) { - m_oxr->passthrough_supported = false; + if (!context_->isExtensionEnabled(XR_FB_PASSTHROUGH_EXTENSION_NAME)) { + oxr_->passthrough_supported = false; return; } - if (m_oxr->passthrough_layer.layerHandle != XR_NULL_HANDLE) { + if (oxr_->passthrough_layer.layerHandle != XR_NULL_HANDLE) { return; /* Already initialized */ } - init_passthrough_extension_functions(m_context->getInstance()); + init_passthrough_extension_functions(context_->getInstance()); XrResult result; @@ -1063,7 +1061,7 @@ void GHOST_XrSession::enablePassthrough() passthrough_create_info.flags |= XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB; XrPassthroughFB passthrough_handle; - result = g_xrCreatePassthroughFB(m_oxr->session, &passthrough_create_info, &passthrough_handle); + result = g_xrCreatePassthroughFB(oxr_->session, &passthrough_create_info, &passthrough_handle); XrPassthroughLayerCreateInfoFB passthrough_layer_create_info; passthrough_layer_create_info.type = XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB; @@ -1074,18 +1072,18 @@ void GHOST_XrSession::enablePassthrough() XrPassthroughLayerFB passthrough_layer_handle; result = g_xrCreatePassthroughLayerFB( - m_oxr->session, &passthrough_layer_create_info, &passthrough_layer_handle); + oxr_->session, &passthrough_layer_create_info, &passthrough_layer_handle); g_xrPassthroughStartFB(passthrough_handle); g_xrPassthroughLayerResumeFB(passthrough_layer_handle); - m_oxr->passthrough_layer.type = XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB; - m_oxr->passthrough_layer.next = nullptr; - m_oxr->passthrough_layer.flags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT; - m_oxr->passthrough_layer.space = nullptr; - m_oxr->passthrough_layer.layerHandle = passthrough_layer_handle; + oxr_->passthrough_layer.type = XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB; + oxr_->passthrough_layer.next = nullptr; + oxr_->passthrough_layer.flags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT; + oxr_->passthrough_layer.space = nullptr; + oxr_->passthrough_layer.layerHandle = passthrough_layer_handle; - m_oxr->passthrough_supported = (result == XR_SUCCESS); + oxr_->passthrough_supported = (result == XR_SUCCESS); } /** \} */ /* Meta Quest Passthrough */ diff --git a/intern/ghost/intern/GHOST_XrSession.hh b/intern/ghost/intern/GHOST_XrSession.hh index c6fcaafe7b9..590444139f5 100644 --- a/intern/ghost/intern/GHOST_XrSession.hh +++ b/intern/ghost/intern/GHOST_XrSession.hh @@ -87,16 +87,16 @@ class GHOST_XrSession { private: /** Pointer back to context managing this session. Would be nice to avoid, but needed to access * custom callbacks set before session start. */ - class GHOST_XrContext *m_context; + class GHOST_XrContext *context_; - std::unique_ptr m_oxr; /* Could use stack, but PImpl is preferable. */ + std::unique_ptr oxr_; /* Could use stack, but PImpl is preferable. */ /** Active Ghost graphic context. Owned by Blender, not GHOST. */ - class GHOST_Context *m_gpu_ctx = nullptr; - std::unique_ptr m_gpu_binding; + class GHOST_Context *gpu_ctx_ = nullptr; + std::unique_ptr gpu_binding_; /** Rendering information. Set when drawing starts. */ - std::unique_ptr m_draw_info; + std::unique_ptr draw_info_; void initSystem(); void beginSession(); diff --git a/intern/ghost/intern/GHOST_XrSwapchain.cc b/intern/ghost/intern/GHOST_XrSwapchain.cc index c10a0ba1863..54e27575fb9 100644 --- a/intern/ghost/intern/GHOST_XrSwapchain.cc +++ b/intern/ghost/intern/GHOST_XrSwapchain.cc @@ -42,7 +42,7 @@ static OpenXRSwapchainData::ImageVec swapchain_images_create(XrSwapchain swapcha GHOST_XrSwapchain::GHOST_XrSwapchain(GHOST_IXrGraphicsBinding &gpu_binding, const XrSession &session, const XrViewConfigurationView &view_config) - : m_oxr(std::make_unique()) + : oxr_(std::make_unique()) { XrSwapchainCreateInfo create_info = {XR_TYPE_SWAPCHAIN_CREATE_INFO}; uint32_t format_count = 0; @@ -56,7 +56,7 @@ GHOST_XrSwapchain::GHOST_XrSwapchain(GHOST_IXrGraphicsBinding &gpu_binding, assert(swapchain_formats.size() == format_count); std::optional chosen_format = gpu_binding.chooseSwapchainFormat( - swapchain_formats, m_format, m_is_srgb_buffer); + swapchain_formats, format_, is_srgb_buffer_); if (!chosen_format) { throw GHOST_XrException( "Error: No format matching OpenXR runtime supported swapchain formats found."); @@ -72,31 +72,31 @@ GHOST_XrSwapchain::GHOST_XrSwapchain(GHOST_IXrGraphicsBinding &gpu_binding, create_info.arraySize = 1; create_info.mipCount = 1; - CHECK_XR(xrCreateSwapchain(session, &create_info, &m_oxr->swapchain), + CHECK_XR(xrCreateSwapchain(session, &create_info, &oxr_->swapchain), "Failed to create OpenXR swapchain."); - m_image_width = create_info.width; - m_image_height = create_info.height; + image_width_ = create_info.width; + image_height_ = create_info.height; - m_oxr->swapchain_images = swapchain_images_create(m_oxr->swapchain, gpu_binding); + oxr_->swapchain_images = swapchain_images_create(oxr_->swapchain, gpu_binding); } GHOST_XrSwapchain::GHOST_XrSwapchain(GHOST_XrSwapchain &&other) - : m_oxr(std::move(other.m_oxr)), - m_image_width(other.m_image_width), - m_image_height(other.m_image_height), - m_format(other.m_format), - m_is_srgb_buffer(other.m_is_srgb_buffer) + : oxr_(std::move(other.oxr_)), + image_width_(other.image_width_), + image_height_(other.image_height_), + format_(other.format_), + is_srgb_buffer_(other.is_srgb_buffer_) { /* Prevent xrDestroySwapchain call for the moved out item. */ - other.m_oxr = nullptr; + other.oxr_ = nullptr; } GHOST_XrSwapchain::~GHOST_XrSwapchain() { - /* m_oxr may be nullptr after move. */ - if (m_oxr && m_oxr->swapchain != XR_NULL_HANDLE) { - CHECK_XR_ASSERT(xrDestroySwapchain(m_oxr->swapchain)); + /* oxr_ may be nullptr after move. */ + if (oxr_ && oxr_->swapchain != XR_NULL_HANDLE) { + CHECK_XR_ASSERT(xrDestroySwapchain(oxr_->swapchain)); } } @@ -107,36 +107,36 @@ XrSwapchainImageBaseHeader *GHOST_XrSwapchain::acquireDrawableSwapchainImage() XrSwapchainImageWaitInfo wait_info = {XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; uint32_t image_idx; - CHECK_XR(xrAcquireSwapchainImage(m_oxr->swapchain, &acquire_info, &image_idx), + CHECK_XR(xrAcquireSwapchainImage(oxr_->swapchain, &acquire_info, &image_idx), "Failed to acquire swapchain image for the VR session."); wait_info.timeout = XR_INFINITE_DURATION; - CHECK_XR(xrWaitSwapchainImage(m_oxr->swapchain, &wait_info), + CHECK_XR(xrWaitSwapchainImage(oxr_->swapchain, &wait_info), "Failed to acquire swapchain image for the VR session."); - return m_oxr->swapchain_images[image_idx]; + return oxr_->swapchain_images[image_idx]; } void GHOST_XrSwapchain::updateCompositionLayerProjectViewSubImage(XrSwapchainSubImage &r_sub_image) { - r_sub_image.swapchain = m_oxr->swapchain; + r_sub_image.swapchain = oxr_->swapchain; r_sub_image.imageRect.offset = {0, 0}; - r_sub_image.imageRect.extent = {m_image_width, m_image_height}; + r_sub_image.imageRect.extent = {image_width_, image_height_}; } GHOST_TXrSwapchainFormat GHOST_XrSwapchain::getFormat() const { - return m_format; + return format_; } bool GHOST_XrSwapchain::isBufferSRGB() const { - return m_is_srgb_buffer; + return is_srgb_buffer_; } void GHOST_XrSwapchain::releaseImage() { XrSwapchainImageReleaseInfo release_info = {XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; - CHECK_XR(xrReleaseSwapchainImage(m_oxr->swapchain, &release_info), + CHECK_XR(xrReleaseSwapchainImage(oxr_->swapchain, &release_info), "Failed to release swapchain image used to submit VR session frame."); } diff --git a/intern/ghost/intern/GHOST_XrSwapchain.hh b/intern/ghost/intern/GHOST_XrSwapchain.hh index 600e6327b24..ecf827bef60 100644 --- a/intern/ghost/intern/GHOST_XrSwapchain.hh +++ b/intern/ghost/intern/GHOST_XrSwapchain.hh @@ -29,8 +29,8 @@ class GHOST_XrSwapchain { bool isBufferSRGB() const; private: - std::unique_ptr m_oxr; /* Could use stack, but PImpl is preferable. */ - int32_t m_image_width, m_image_height; - GHOST_TXrSwapchainFormat m_format; - bool m_is_srgb_buffer = false; + std::unique_ptr oxr_; /* Could use stack, but PImpl is preferable. */ + int32_t image_width_, image_height_; + GHOST_TXrSwapchainFormat format_; + bool is_srgb_buffer_ = false; }; diff --git a/intern/ghost/test/gears/GHOST_C-Test.c b/intern/ghost/test/gears/GHOST_C-Test.c index eefd1d65f96..703165ed6a4 100644 --- a/intern/ghost/test/gears/GHOST_C-Test.c +++ b/intern/ghost/test/gears/GHOST_C-Test.c @@ -32,7 +32,7 @@ #endif /* defined(WIN32) || defined(__APPLE__) */ static void gearsTimerProc(GHOST_TimerTaskHandle task, uint64_t time); -bool processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData); +bool processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr user_data); static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0; static GLfloat fAngle = 0.0; @@ -269,7 +269,7 @@ static void setViewPortGL(GHOST_WindowHandle hWindow) GHOST_DisposeRectangle(hRect); } -bool processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData) +bool processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr user_data) { bool handled = true; int cursor; @@ -389,7 +389,7 @@ bool processEvent(GHOST_EventHandle hEvent, GHOST_TUserDataPtr userData) int main(int argc, char **argv) { - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; char *title1 = "gears - main window"; char *title2 = "gears - secondary window"; GHOST_EventConsumerHandle consumer = GHOST_CreateEventConsumer(processEvent, NULL); @@ -410,7 +410,7 @@ int main(int argc, char **argv) GHOST_kWindowStateNormal, false, GHOST_kDrawingContextTypeOpenGL, - gpuSettings); + gpu_settings); if (!sMainWindow) { printf("could not create main window\n"); exit(-1); @@ -427,7 +427,7 @@ int main(int argc, char **argv) GHOST_kWindowStateNormal, false, GHOST_kDrawingContextTypeOpenGL, - gpuSettings); + gpu_settings); if (!sSecondaryWindow) { printf("could not create secondary window\n"); exit(-1); diff --git a/intern/ghost/test/gears/GHOST_Test.cpp b/intern/ghost/test/gears/GHOST_Test.cpp index 905be6065e2..7d8bfec7531 100644 --- a/intern/ghost/test/gears/GHOST_Test.cpp +++ b/intern/ghost/test/gears/GHOST_Test.cpp @@ -385,59 +385,59 @@ class Application : public GHOST_IEventConsumer { ~Application(); virtual bool processEvent(GHOST_IEvent *event); - GHOST_ISystem *m_system; - GHOST_IWindow *m_mainWindow; - GHOST_IWindow *m_secondaryWindow; - GHOST_ITimerTask *m_gearsTimer, *m_testTimer; - GHOST_TStandardCursor m_cursor; - bool m_exitRequested; + GHOST_ISystem *system_; + GHOST_IWindow *main_window_; + GHOST_IWindow *secondary_window_; + GHOST_ITimerTask *gears_timer_, *test_timer_; + GHOST_TStandardCursor cursor_; + bool exit_requested_; bool stereo; }; Application::Application(GHOST_ISystem *system) - : m_system(system), - m_mainWindow(0), - m_secondaryWindow(0), - m_gearsTimer(0), - m_testTimer(0), - m_cursor(GHOST_kStandardCursorFirstCursor), - m_exitRequested(false), + : system_(system), + main_window_(0), + secondary_window_(0), + gears_timer_(0), + test_timer_(0), + cursor_(GHOST_kStandardCursorFirstCursor), + exit_requested_(false), stereo(false) { - GHOST_GPUSettings gpuSettings = {0}; - gpuSettings.context_type = GHOST_kDrawingContextTypeOpenGL; + GHOST_GPUSettings gpu_settings = {0}; + gpu_settings.context_type = GHOST_kDrawingContextTypeOpenGL; fApp = this; // Create the main window - m_mainWindow = system->createWindow( - "gears - main window", 10, 64, 320, 200, GHOST_kWindowStateNormal, gpuSettings); + main_window_ = system->createWindow( + "gears - main window", 10, 64, 320, 200, GHOST_kWindowStateNormal, gpu_settings); - if (!m_mainWindow) { + if (!main_window_) { std::cout << "could not create main window\n"; exit(-1); } // Create a secondary window - m_secondaryWindow = system->createWindow( - "gears - secondary window", 340, 64, 320, 200, GHOST_kWindowStateNormal, gpuSettings); - if (!m_secondaryWindow) { + secondary_window_ = system->createWindow( + "gears - secondary window", 340, 64, 320, 200, GHOST_kWindowStateNormal, gpu_settings); + if (!secondary_window_) { std::cout << "could not create secondary window\n"; exit(-1); } // Install a timer to have the gears running - m_gearsTimer = system->installTimer(0 /*delay*/, 20 /*interval*/, gearsTimerProc, m_mainWindow); + gears_timer_ = system->installTimer(0 /*delay*/, 20 /*interval*/, gearsTimerProc, main_window_); } Application::~Application() { // Dispose windows - if (m_system->validWindow(m_mainWindow)) { - m_system->disposeWindow(m_mainWindow); + if (system_->validWindow(main_window_)) { + system_->disposeWindow(main_window_); } - if (m_system->validWindow(m_secondaryWindow)) { - m_system->disposeWindow(m_secondaryWindow); + if (system_->validWindow(secondary_window_)) { + system_->disposeWindow(secondary_window_); } } @@ -474,19 +474,19 @@ bool Application::processEvent(const GHOST_IEvent *event) GHOST_TEventKeyData *keyData = (GHOST_TEventKeyData *)event->getData(); switch (keyData->key) { case GHOST_kKeyC: { - int cursor = m_cursor; + int cursor = cursor_; cursor++; if (cursor >= GHOST_kStandardCursorNumCursors) { cursor = GHOST_kStandardCursorFirstCursor; } - m_cursor = (GHOST_TStandardCursor)cursor; - window->setCursorShape(m_cursor); + cursor_ = (GHOST_TStandardCursor)cursor; + window->setCursorShape(cursor_); break; } case GHOST_kKeyE: { int x = 200, y = 200; - m_system->setCursorPosition(x, y); + system_->setCursorPosition(x, y); break; } @@ -496,27 +496,27 @@ bool Application::processEvent(const GHOST_IEvent *event) case GHOST_kKeyM: { bool down = false; - m_system->getModifierKeyState(GHOST_kModifierKeyLeftShift, down); + system_->getModifierKeyState(GHOST_kModifierKeyLeftShift, down); if (down) { std::cout << "left shift down\n"; } - m_system->getModifierKeyState(GHOST_kModifierKeyRightShift, down); + system_->getModifierKeyState(GHOST_kModifierKeyRightShift, down); if (down) { std::cout << "right shift down\n"; } - m_system->getModifierKeyState(GHOST_kModifierKeyLeftAlt, down); + system_->getModifierKeyState(GHOST_kModifierKeyLeftAlt, down); if (down) { std::cout << "left Alt down\n"; } - m_system->getModifierKeyState(GHOST_kModifierKeyRightAlt, down); + system_->getModifierKeyState(GHOST_kModifierKeyRightAlt, down); if (down) { std::cout << "right Alt down\n"; } - m_system->getModifierKeyState(GHOST_kModifierKeyLeftControl, down); + system_->getModifierKeyState(GHOST_kModifierKeyLeftControl, down); if (down) { std::cout << "left control down\n"; } - m_system->getModifierKeyState(GHOST_kModifierKeyRightControl, down); + system_->getModifierKeyState(GHOST_kModifierKeyRightControl, down); if (down) { std::cout << "right control down\n"; } @@ -524,7 +524,7 @@ bool Application::processEvent(const GHOST_IEvent *event) } case GHOST_kKeyQ: - m_exitRequested = true; + exit_requested_ = true; break; case GHOST_kKeyS: // toggle mono and stereo @@ -537,22 +537,22 @@ bool Application::processEvent(const GHOST_IEvent *event) break; case GHOST_kKeyT: - if (!m_testTimer) { - m_testTimer = m_system->installTimer(0, 1000, testTimerProc); + if (!test_timer_) { + test_timer_ = system_->installTimer(0, 1000, testTimerProc); } else { - m_system->removeTimer(m_testTimer); - m_testTimer = 0; + system_->removeTimer(test_timer_); + test_timer_ = 0; } break; case GHOST_kKeyW: - if (m_mainWindow) { - std::string title = m_mainWindow->getTitle(); + if (main_window_) { + std::string title = main_window_->getTitle(); title += "-"; - m_mainWindow->setTitle(title); + main_window_->setTitle(title); } break; @@ -564,11 +564,11 @@ bool Application::processEvent(const GHOST_IEvent *event) case GHOST_kEventWindowClose: { GHOST_IWindow *window2 = event->getWindow(); - if (window2 == m_mainWindow) { - m_exitRequested = true; + if (window2 == main_window_) { + exit_requested_ = true; } else { - m_system->disposeWindow(window2); + system_->disposeWindow(window2); } break; } @@ -583,7 +583,7 @@ bool Application::processEvent(const GHOST_IEvent *event) case GHOST_kEventWindowUpdate: { GHOST_IWindow *window2 = event->getWindow(); - if (!m_system->validWindow(window2)) { + if (!system_->validWindow(window2)) { break; } @@ -677,7 +677,7 @@ int main(int /*argc*/, char ** /*argv*/) fSystem->addEventConsumer(&app); // Enter main loop - while (!app.m_exitRequested) { + while (!app.exit_requested_) { // printf("main: loop\n"); fSystem->processEvents(true); fSystem->dispatchEvents(); diff --git a/intern/ghost/test/multitest/MultiTest.c b/intern/ghost/test/multitest/MultiTest.c index 24065cd9ee9..50a3cb8602f 100644 --- a/intern/ghost/test/multitest/MultiTest.c +++ b/intern/ghost/test/multitest/MultiTest.c @@ -309,7 +309,7 @@ MainWindow *mainwindow_new(MultiTestApp *app) { GHOST_SystemHandle sys = multitestapp_get_system(app); GHOST_WindowHandle win; - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; win = GHOST_CreateWindow(sys, NULL, @@ -321,7 +321,7 @@ MainWindow *mainwindow_new(MultiTestApp *app) GHOST_kWindowStateNormal, false, GHOST_kDrawingContextTypeOpenGL, - gpuSettings); + gpu_settings); if (win) { MainWindow *mw = MEM_callocN(sizeof(*mw), "mainwindow_new"); @@ -561,7 +561,7 @@ static void loggerwindow_handle(void *priv, GHOST_EventHandle evt) LoggerWindow *loggerwindow_new(MultiTestApp *app) { - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; GHOST_SystemHandle sys = multitestapp_get_system(app); uint32_t screensize[2]; GHOST_WindowHandle win; @@ -582,7 +582,7 @@ LoggerWindow *loggerwindow_new(MultiTestApp *app) GHOST_kWindowStateNormal, false, GHOST_kDrawingContextTypeOpenGL, - gpuSettings); + gpu_settings); if (win) { LoggerWindow *lw = MEM_callocN(sizeof(*lw), "loggerwindow_new"); @@ -774,7 +774,7 @@ static void extrawindow_handle(void *priv, GHOST_EventHandle evt) ExtraWindow *extrawindow_new(MultiTestApp *app) { - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; GHOST_SystemHandle sys = multitestapp_get_system(app); GHOST_WindowHandle win; @@ -788,7 +788,7 @@ ExtraWindow *extrawindow_new(MultiTestApp *app) GHOST_kWindowStateNormal, false, GHOST_kDrawingContextTypeOpenGL, - gpuSettings); + gpu_settings); if (win) { ExtraWindow *ew = MEM_callocN(sizeof(*ew), "mainwindow_new"); diff --git a/source/blender/gpu/tests/gpu_testing.cc b/source/blender/gpu/tests/gpu_testing.cc index e1e0cbca37c..c8657672a83 100644 --- a/source/blender/gpu/tests/gpu_testing.cc +++ b/source/blender/gpu/tests/gpu_testing.cc @@ -39,12 +39,12 @@ void GPUTest::SetUpTestSuite(GHOST_TDrawingContextType draw_context_type, if (!GPU_backend_supported()) { GTEST_SKIP() << "GPU backend not supported"; } - GHOST_GPUSettings gpuSettings = {}; - gpuSettings.context_type = draw_context_type; - gpuSettings.flags = GHOST_gpuDebugContext; + GHOST_GPUSettings gpu_settings = {}; + gpu_settings.context_type = draw_context_type; + gpu_settings.flags = GHOST_gpuDebugContext; ghost_system_ = GHOST_CreateSystemBackground(); GPU_backend_ghost_system_set(ghost_system_); - ghost_context_ = GHOST_CreateGPUContext(ghost_system_, gpuSettings); + ghost_context_ = GHOST_CreateGPUContext(ghost_system_, gpu_settings); GHOST_ActivateGPUContext(ghost_context_); context_ = GPU_context_create(nullptr, ghost_context_); GPU_init(); diff --git a/source/blender/windowmanager/intern/wm_playanim.cc b/source/blender/windowmanager/intern/wm_playanim.cc index e601b7321c7..a6b7b68fafd 100644 --- a/source/blender/windowmanager/intern/wm_playanim.cc +++ b/source/blender/windowmanager/intern/wm_playanim.cc @@ -1590,15 +1590,15 @@ static bool ghost_event_proc(GHOST_EventHandle ghost_event, GHOST_TUserDataPtr p static GHOST_WindowHandle playanim_window_open( GHOST_SystemHandle ghost_system, const char *title, int posx, int posy, int sizex, int sizey) { - GHOST_GPUSettings gpusettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; const eGPUBackendType gpu_backend = GPU_backend_type_selection_get(); - gpusettings.context_type = wm_ghost_drawing_context_type(gpu_backend); - gpusettings.preferred_device.index = U.gpu_preferred_index; - gpusettings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; - gpusettings.preferred_device.device_id = U.gpu_preferred_device_id; + gpu_settings.context_type = wm_ghost_drawing_context_type(gpu_backend); + gpu_settings.preferred_device.index = U.gpu_preferred_index; + gpu_settings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; + gpu_settings.preferred_device.device_id = U.gpu_preferred_device_id; if (GPU_backend_vsync_is_overridden()) { - gpusettings.flags |= GHOST_gpuVSyncIsOverridden; - gpusettings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); + gpu_settings.flags |= GHOST_gpuVSyncIsOverridden; + gpu_settings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); } { @@ -1654,7 +1654,7 @@ static GHOST_WindowHandle playanim_window_open( /* Could optionally start full-screen. */ GHOST_kWindowStateNormal, false, - gpusettings); + gpu_settings); } static void playanim_window_zoom(PlayState &ps, const float zoom_offset) diff --git a/source/blender/windowmanager/intern/wm_window.cc b/source/blender/windowmanager/intern/wm_window.cc index d24c0e4f666..e177bb2d32f 100644 --- a/source/blender/windowmanager/intern/wm_window.cc +++ b/source/blender/windowmanager/intern/wm_window.cc @@ -866,23 +866,23 @@ static void wm_window_ghostwindow_add(wmWindowManager *wm, bool is_dialog) { /* A new window is created when page-flip mode is required for a window. */ - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; if (win->stereo3d_format->display_mode == S3D_DISPLAY_PAGEFLIP) { - gpuSettings.flags |= GHOST_gpuStereoVisual; + gpu_settings.flags |= GHOST_gpuStereoVisual; } if (G.debug & G_DEBUG_GPU) { - gpuSettings.flags |= GHOST_gpuDebugContext; + gpu_settings.flags |= GHOST_gpuDebugContext; } eGPUBackendType gpu_backend = GPU_backend_type_selection_get(); - gpuSettings.context_type = wm_ghost_drawing_context_type(gpu_backend); - gpuSettings.preferred_device.index = U.gpu_preferred_index; - gpuSettings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; - gpuSettings.preferred_device.device_id = U.gpu_preferred_device_id; + gpu_settings.context_type = wm_ghost_drawing_context_type(gpu_backend); + gpu_settings.preferred_device.index = U.gpu_preferred_index; + gpu_settings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; + gpu_settings.preferred_device.device_id = U.gpu_preferred_device_id; if (GPU_backend_vsync_is_overridden()) { - gpuSettings.flags |= GHOST_gpuVSyncIsOverridden; - gpuSettings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); + gpu_settings.flags |= GHOST_gpuVSyncIsOverridden; + gpu_settings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); } int posx = 0; @@ -910,7 +910,7 @@ static void wm_window_ghostwindow_add(wmWindowManager *wm, win->sizey, (GHOST_TWindowState)win->windowstate, is_dialog, - gpuSettings); + gpu_settings); if (ghostwin) { win->gpuctx = GPU_context_create(ghostwin, nullptr); @@ -3155,21 +3155,21 @@ void *WM_system_gpu_context_create() BLI_assert(BLI_thread_is_main()); BLI_assert(GPU_framebuffer_active_get() == GPU_framebuffer_back_get()); - GHOST_GPUSettings gpuSettings = {0}; + GHOST_GPUSettings gpu_settings = {0}; const eGPUBackendType gpu_backend = GPU_backend_type_selection_get(); - gpuSettings.context_type = wm_ghost_drawing_context_type(gpu_backend); + gpu_settings.context_type = wm_ghost_drawing_context_type(gpu_backend); if (G.debug & G_DEBUG_GPU) { - gpuSettings.flags |= GHOST_gpuDebugContext; + gpu_settings.flags |= GHOST_gpuDebugContext; } - gpuSettings.preferred_device.index = U.gpu_preferred_index; - gpuSettings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; - gpuSettings.preferred_device.device_id = U.gpu_preferred_device_id; + gpu_settings.preferred_device.index = U.gpu_preferred_index; + gpu_settings.preferred_device.vendor_id = U.gpu_preferred_vendor_id; + gpu_settings.preferred_device.device_id = U.gpu_preferred_device_id; if (GPU_backend_vsync_is_overridden()) { - gpuSettings.flags |= GHOST_gpuVSyncIsOverridden; - gpuSettings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); + gpu_settings.flags |= GHOST_gpuVSyncIsOverridden; + gpu_settings.vsync = GHOST_TVSyncModes(GPU_backend_vsync_get()); } - return GHOST_CreateGPUContext(g_system, gpuSettings); + return GHOST_CreateGPUContext(g_system, gpu_settings); } void WM_system_gpu_context_dispose(void *context)