OpenVRBackend: Handle new focus events from SteamVR

Overhaul all this so we can have working keyboard/mouse focus logic across the entire SteamVR stack.

This also allows us to forward keyboard stuff to arbitrary SteamVR fake overlay windows.

In virtual connector modes (eg. VR) we also always have a dummy 0th global focus, for when we are only forwarding to handle those.

Some stuff isn't in OpenVR headers yet, so define those.

Author: misyltoad

src/Backends/OpenVRBackend.cpp

@@ -77,12 +77,50 @@ gamescope::ConVar<bool> cv_vr_nudge_to_visible_per_connector( "vr_nudge_to_visib
 // Maximum interval between polling for VR events (normally paced by frame sync)
 gamescope::ConVar<uint32_t> cv_vr_poll_rate( "vr_poll_rate", 50ul, "Max time between input polls. In milliseconds." );
 
+extern std::atomic<uint64_t> g_FocusedVROverlayMouse;
+extern std::atomic<uint64_t> g_FocusedVROverlayKeyboard;
+
 // Not in public headers yet.
 namespace vr
 {
     const EVRButtonId k_EButton_Steam = (EVRButtonId)(50);
     const EVRButtonId k_EButton_QAM = (EVRButtonId)(51);
+
+    constexpr EVREventType VREvent_OverlayInputFocusChanged = ( EVREventType )(564); // data is overlayInputFocus
+
+
+    /** Used in VREvent_OverlayInputFocus_t */
+    enum EVRInputFocusEventFlags
+    {
+        // Indicates the overlay should actively have keyboard focus.
+        k_EVRInputFocusEventFlags_OverlayShouldShowAffordanceForKeyboardInput = 1 << 0,
+        // Indicates the overlay should actively have gamepad focus.
+        k_EVRInputFocusEventFlags_OverlayShouldShowAffordanceForGamepadInput = 1 << 1,
+    };
+    /** Used for a few events about overlay input focus */
+    struct VREvent_OverlayInputFocus_t
+    {
+        // Overlay that has keyboard and/or gamepad focus. If this is your overlay and its contents is a desktop or a desktop window,
+        // this event is a great oppportunity to move that window to the foreground so it receives input.
+        uint64_t overlayHandle; // VROverlayHandle_t
+        uint32_t flags; // EVRInputFocusEventFlags
+    };
+
+    typedef union
+    {
+        VREvent_OverlayInputFocus_t overlayInputFocus;
+    } VREvent_Data_Gamescope_t;
+
+    static inline const VREvent_Data_Gamescope_t &CastToGamescopeEventData( const VREvent_Data_t &eventData )
+    {
+        return reinterpret_cast< const vr::VREvent_Data_Gamescope_t & >( eventData );
+    }
+    static inline VREvent_Data_Gamescope_t &CastToGamescopeEventData( VREvent_Data_t &eventData )
+    {
+        return reinterpret_cast< vr::VREvent_Data_Gamescope_t & >( eventData );
+    }
 }
+//
 
 extern std::atomic<uint32_t> g_unCurrentVRSceneAppId;
 
@@ -740,8 +778,12 @@ namespace gamescope
 
 		virtual IBackendConnector *GetCurrentConnector() override
 		{
-			return m_pFocusConnector;
+			return m_pKeyboardFocusConnector;
 		}
+        virtual IBackendConnector *GetCurrentMouseConnector()
+        {
+            return m_pMouseFocusConnector;
+        }
 		virtual IBackendConnector *GetConnector( GamescopeScreenType eScreenType ) override
 		{
 			if ( eScreenType == GAMESCOPE_SCREEN_TYPE_INTERNAL )
@@ -832,20 +874,23 @@ namespace gamescope
                 return TouchClickModes::Trackpad;
             }
 
-            if ( pConnector->IsTouchForbidden() )
+            if ( pConnector )
             {
-                return TouchClickModes::Left;
-            }
+                if ( pConnector->IsTouchForbidden() )
+                {
+                    return TouchClickModes::Left;
+                }
 
-            if ( VirtualConnectorKeyIsNonSteamWindow( pConnector->GetVirtualConnectorKey() ) )
-            {
-                return TouchClickModes::Passthrough;
-            }
+                if ( VirtualConnectorKeyIsNonSteamWindow( pConnector->GetVirtualConnectorKey() ) )
+                {
+                    return TouchClickModes::Passthrough;
+                }
 
-            if ( VirtualConnectorInSteamPerAppState() )
-            {
-                if ( !VirtualConnectorKeyIsSteam( pConnector->GetVirtualConnectorKey() ) )
-                    return TouchClickModes::Left;
+                if ( VirtualConnectorInSteamPerAppState() )
+                {
+                    if ( !VirtualConnectorKeyIsSteam( pConnector->GetVirtualConnectorKey() ) )
+                        return TouchClickModes::Left;
+                }
             }
 
             return CBaseBackend::GetTouchClickMode();
@@ -859,22 +904,23 @@ namespace gamescope
         {
             std::shared_ptr<COpenVRConnector> pConnector = std::make_shared<COpenVRConnector>( this, ulVirtualConnectorKey );
 
-            bool bSetCurrentConnector = false;
+            if ( !pConnector->Init() )
             {
-                if ( !m_pFocusConnector )
-                {
-                    SetFocus( pConnector.get() );
-                    bSetCurrentConnector = true;
-                }
+                return nullptr;
+            }
+
+            {
+                COpenVRConnector *pExpected = nullptr;
+                m_pMouseFocusConnector.compare_exchange_strong( pExpected, pConnector.get() );
             }
 
-            if ( !pConnector->Init() )
             {
-                if ( bSetCurrentConnector )
+                COpenVRConnector *pExpected = nullptr;
+                if ( m_pKeyboardFocusConnector.compare_exchange_strong( pExpected, pConnector.get() ) )
                 {
-                    SetFocus( nullptr );
+                    openvr_log.debugf( "Changed keyboard focus connector to %p ", pConnector.get() );
+                    update_connector_display_info_wl( NULL );
                 }
-                return nullptr;
             }
 
             std::scoped_lock lock{ m_mutActiveConnectors };
@@ -998,16 +1044,6 @@ namespace gamescope
             m_nOverlaysVisible.wait( 0 );
         }
 
-        void SetFocus( COpenVRConnector *pFocus )
-        {
-            COpenVRConnector *pPreviousFocus = m_pFocusConnector.exchange( pFocus );
-            if ( pPreviousFocus != pFocus )
-            {
-                MakeFocusDirty();
-                update_connector_display_info_wl( NULL );
-            }
-        }
-
         COpenVRPlane *GetPlaneByOverlayHandle( vr::VROverlayHandle_t hOverlay )
         {
             COpenVRPlane *pPlane = nullptr;
@@ -1020,6 +1056,75 @@ namespace gamescope
             return pPlane;
         }
 
+        void SetMouseFocus( uint64_t ulFocusOverlay )
+        {
+            uint64_t oldOverlayHandle = g_FocusedVROverlayMouse.exchange( ulFocusOverlay );
+
+            if ( oldOverlayHandle == ulFocusOverlay )
+                return;
+
+            openvr_log.debugf( "Changing mouse focus from %lx to %lx", oldOverlayHandle, ulFocusOverlay );
+
+            COpenVRConnector *pInputConnector = nullptr;
+            if ( ulFocusOverlay != vr::k_ulOverlayHandleInvalid )
+            {
+                COpenVRPlane *pInputPlane = GetPlaneByOverlayHandle( ulFocusOverlay );
+                if ( pInputPlane )
+                {
+                    pInputConnector = pInputPlane->GetConnector();
+                }
+            }
+
+            if ( pInputConnector )
+            {
+                pInputConnector->m_bUsingVRMouse = true;
+
+                COpenVRConnector *pOldConnector = m_pMouseFocusConnector.exchange( pInputConnector );
+
+                if ( pOldConnector != pInputConnector )
+                {
+                    openvr_log.debugf( "Changing mouse focus connector to %p", pInputConnector );
+
+                    // We don't do anything with mouse focus that isn't local,
+                    // so only dirty focus if the focus connector changed.
+                    //
+                    // Unlike with Keyboard where we need to focus for forwarders too!
+
+                    MakeFocusDirty();
+                    nudge_steamcompmgr();
+                }
+            }
+        }
+
+        void SetKeyboardFocus( uint64_t ulFocusOverlay )
+        {
+            uint64_t oldOverlayHandle = g_FocusedVROverlayKeyboard.exchange( ulFocusOverlay );
+
+            if ( oldOverlayHandle == ulFocusOverlay )
+                return;
+
+            openvr_log.debugf( "Changing keyboard focus from %lx to %lx", oldOverlayHandle, ulFocusOverlay );
+
+            COpenVRConnector *pInputConnector = nullptr;
+            if ( ulFocusOverlay != vr::k_ulOverlayHandleInvalid )
+            {
+                COpenVRPlane *pInputPlane = GetPlaneByOverlayHandle( ulFocusOverlay );
+                if ( pInputPlane )
+                {
+                    pInputConnector = pInputPlane->GetConnector();
+                }
+            }
+
+            if ( pInputConnector )
+            {
+                openvr_log.debugf( "Changing keyboard focus connector to %p", pInputConnector );
+                m_pKeyboardFocusConnector.exchange( pInputConnector );
+            }
+
+            MakeFocusDirty();
+            nudge_steamcompmgr();
+        }
+
         void ProcessVRInput()
         {
             std::scoped_lock lock{m_mutActiveConnectors};
@@ -1161,7 +1266,8 @@ namespace gamescope
                 {
                     if (pConnector && pConnector->m_bUsingVRMouse)
                     {
-                        SetFocus(pConnector);
+                        SetMouseFocus( hOverlay );
+
                         float flX = vrEvent.data.mouse.x / float(g_nOutputWidth);
                         float flY = (g_nOutputHeight - vrEvent.data.mouse.y) / float(g_nOutputHeight);
 
@@ -1197,17 +1303,31 @@ namespace gamescope
                     break;
                 }
                 case vr::VREvent_FocusEnter:
-                    if (pConnector)
                     {
-                        pConnector->m_bUsingVRMouse = true;
-                        SetFocus(pConnector);
+                        if (pConnector)
+                        {
+                            pConnector->m_bUsingVRMouse = true;
+                            SetMouseFocus( hOverlay );
+                        }
+                    }
+                    break;
+
+                case vr::VREvent_OverlayFocusChanged:
+                    {
+                        SetMouseFocus( vrEvent.data.overlay.overlayHandle );
+                    }
+                    break;
+                case vr::VREvent_OverlayInputFocusChanged:
+                    {
+                        const vr::VREvent_Data_Gamescope_t &data = CastToGamescopeEventData( vrEvent.data );
+                        SetKeyboardFocus( data.overlayInputFocus.overlayHandle );
                     }
                     break;
                 case vr::VREvent_MouseButtonUp:
                 case vr::VREvent_MouseButtonDown:
                     if (pConnector)
                     {
-                        SetFocus(pConnector);
+                        SetMouseFocus( hOverlay );
 
                         if (!pConnector->m_bUsingVRMouse)
                         {
@@ -1289,7 +1409,8 @@ namespace gamescope
                 case vr::VREvent_ScrollSmooth:
                     if (pConnector)
                     {
-                        SetFocus(pConnector);
+                        SetMouseFocus( hOverlay );
+
                         float flX = -vrEvent.data.scroll.xdelta * m_flScrollSpeed;
                         float flY = -vrEvent.data.scroll.ydelta * m_flScrollSpeed;
                         wlserver_lock();
@@ -1299,24 +1420,6 @@ namespace gamescope
                     }
                     break;
 
-                case vr::VREvent_ButtonPress:
-                    if (pConnector)
-                    {
-                        SetFocus(pConnector);
-                        vr::EVRButtonId button = (vr::EVRButtonId)vrEvent.data.controller.button;
-
-                        if (button != vr::k_EButton_Steam && button != vr::k_EButton_QAM)
-                            break;
-
-                        if (button == vr::k_EButton_Steam)
-                            openvr_log.infof("STEAM button pressed.");
-                        else
-                            openvr_log.infof("QAM button pressed.");
-
-                        wlserver_open_steam_menu(button == vr::k_EButton_QAM);
-                    }
-                    break;
-
                 case vr::VREvent_OverlayShown:
                 case vr::VREvent_OverlayHidden:
                     if (pConnector)
@@ -1419,7 +1522,8 @@ namespace gamescope
         friend COpenVRConnector;
         std::vector<COpenVRConnector*> m_pActiveConnectors;
         std::mutex m_mutActiveConnectors;
-        std::atomic<COpenVRConnector *> m_pFocusConnector;
+        std::atomic<COpenVRConnector *> m_pMouseFocusConnector;
+        std::atomic<COpenVRConnector *> m_pKeyboardFocusConnector;
 
         std::atomic<bool> m_bInitted = { false };
         std::atomic<bool> m_bRunning = { false };
@@ -1462,9 +1566,10 @@ namespace gamescope
             m_pBackend->m_pActiveConnectors.erase( iter );
 
         COpenVRConnector *pThis = this;
-        m_pBackend->m_pFocusConnector.compare_exchange_strong( pThis, nullptr );
+        m_pBackend->m_pMouseFocusConnector.compare_exchange_strong( pThis, nullptr );
+        pThis = this;
+        m_pBackend->m_pKeyboardFocusConnector.compare_exchange_strong( pThis, nullptr );
     }
-
     GamescopeScreenType COpenVRConnector::GetScreenType() const
     {
         return GAMESCOPE_SCREEN_TYPE_INTERNAL;

src/backend.h

@@ -349,6 +349,10 @@ namespace gamescope
 		}
 
         virtual IBackendConnector *GetCurrentConnector() = 0;
+        virtual IBackendConnector *GetCurrentMouseConnector()
+        {
+            return this->GetCurrentConnector();
+        }
         virtual IBackendConnector *GetConnector( GamescopeScreenType eScreenType ) = 0;
 
         virtual bool SupportsPlaneHardwareCursor() const = 0;