vrclient: Inline some IVROverlay override code.

CW-Bug-Id: #22729

vrclient_x64/vrclient_x64/vroverlay_manual.c

@@ -43,108 +43,79 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
-static EVROverlayError ivroverlay_set_overlay_texture_dxvk( EVROverlayError (*cpp_func)( void *, VROverlayHandle_t, const Texture_t * ),
+struct set_overlay_texture_state
-                                                            void *linux_side, VROverlayHandle_t overlayHandle,
-                                                            const Texture_t *texture, unsigned int version,
-                                                            IDXGIVkInteropSurface *dxvk_surface )
 {
+    struct Texture_t texture;
     struct VRVulkanTextureData_t vkdata;
-    IDXGIVkInteropDevice *dxvk_device;
-    struct Texture_t vktexture;
 
     VkImageLayout image_layout;
-    VkImageCreateInfo image_info;
     VkImageSubresourceRange subresources;
+    IDXGIVkInteropSurface *dxvk_surface;
+    IDXGIVkInteropDevice *dxvk_device;
+};
 
-    EVRCompositorError err;
+static void load_overlay_texture_dxvk( const Texture_t *texture, struct set_overlay_texture_state *state )
+{
+    VkImageCreateInfo image_info;
+    IUnknown *texture_iface;
 
-    vktexture = vrclient_translate_texture_dxvk( texture, &vkdata, dxvk_surface, &dxvk_device, &image_layout, &image_info );
+    TRACE( "texture = %p\n", texture );
 
-    subresources.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    if (!(texture_iface = texture->handle))
-    subresources.baseMipLevel = 0;
+    {
-    subresources.levelCount = image_info.mipLevels;
+        WARN( "No D3D11 texture %p.\n", texture );
-    subresources.baseArrayLayer = 0;
+        return;
-    subresources.layerCount = image_info.arrayLayers;
+    }
 
-    dxvk_device->lpVtbl->TransitionSurfaceLayout( dxvk_device, dxvk_surface, &subresources,
+    if (FAILED(texture_iface->lpVtbl->QueryInterface( texture_iface, &IID_IDXGIVkInteropSurface,
-                                                  image_layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL );
+                                                      (void **)&state->dxvk_surface )))
-    dxvk_device->lpVtbl->FlushRenderingCommands( dxvk_device );
+    {
-    dxvk_device->lpVtbl->LockSubmissionQueue( dxvk_device );
+        WARN( "Invalid D3D11 texture %p.\n", texture );
+        return;
+    }
 
-    err = cpp_func( linux_side, overlayHandle, &vktexture );
+    state->texture = vrclient_translate_texture_dxvk( texture, &state->vkdata, state->dxvk_surface, &state->dxvk_device,
+                                                      &state->image_layout, &image_info );
 
-    dxvk_device->lpVtbl->ReleaseSubmissionQueue( dxvk_device );
+    state->subresources.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    dxvk_device->lpVtbl->TransitionSurfaceLayout( dxvk_device, dxvk_surface, &subresources,
+    state->subresources.baseMipLevel = 0;
-                                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image_layout );
+    state->subresources.levelCount = image_info.mipLevels;
+    state->subresources.baseArrayLayer = 0;
+    state->subresources.layerCount = image_info.arrayLayers;
 
-    dxvk_device->lpVtbl->Release( dxvk_device );
+    state->dxvk_device->lpVtbl->TransitionSurfaceLayout( state->dxvk_device, state->dxvk_surface, &state->subresources,
-    dxvk_surface->lpVtbl->Release( dxvk_surface );
+                                                         state->image_layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL );
-    return err;
+    state->dxvk_device->lpVtbl->FlushRenderingCommands( state->dxvk_device );
+    state->dxvk_device->lpVtbl->LockSubmissionQueue( state->dxvk_device );
 }
 
-static EVROverlayError ivroverlay_set_overlay_texture_vulkan( EVROverlayError (*cpp_func)( void *, VROverlayHandle_t, const Texture_t * ),
+static void free_unix_overlay_texture_dxvk( struct set_overlay_texture_state *state )
-                                                              void *linux_side, VROverlayHandle_t overlay_handle,
-                                                              const Texture_t *texture, unsigned int version )
 {
-    struct VRVulkanTextureData_t our_vkdata, *their_vkdata;
+    if (!state->dxvk_device) return;
-    Texture_t our_texture;
+
+    state->dxvk_device->lpVtbl->ReleaseSubmissionQueue( state->dxvk_device );
+    state->dxvk_device->lpVtbl->TransitionSurfaceLayout( state->dxvk_device, state->dxvk_surface, &state->subresources,
+                                                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, state->image_layout );
+    state->dxvk_device->lpVtbl->Release( state->dxvk_device );
+    state->dxvk_surface->lpVtbl->Release( state->dxvk_surface );
+}
+
+static void load_overlay_texture_vulkan( const Texture_t *texture, struct set_overlay_texture_state *state )
+{
+    struct VRVulkanTextureData_t *their_vkdata;
+
+    TRACE( "texture = %p\n", texture );
 
     their_vkdata = texture->handle;
 
-    our_vkdata = *their_vkdata;
+    state->vkdata = *their_vkdata;
-    our_vkdata.m_pDevice = get_native_VkDevice( our_vkdata.m_pDevice );
+    state->vkdata.m_pDevice = get_native_VkDevice( their_vkdata->m_pDevice );
-    our_vkdata.m_pPhysicalDevice = get_native_VkPhysicalDevice( our_vkdata.m_pPhysicalDevice );
+    state->vkdata.m_pPhysicalDevice = get_native_VkPhysicalDevice( their_vkdata->m_pPhysicalDevice );
-    our_vkdata.m_pInstance = get_native_VkInstance( our_vkdata.m_pInstance );
+    state->vkdata.m_pInstance = get_native_VkInstance( their_vkdata->m_pInstance );
-    our_vkdata.m_pQueue = get_native_VkQueue( our_vkdata.m_pQueue );
+    state->vkdata.m_pQueue = get_native_VkQueue( their_vkdata->m_pQueue );
 
-    our_texture = *texture;
+    state->texture = *texture;
-    our_texture.handle = &our_vkdata;
+    state->texture.handle = &state->vkdata;
-
-    return cpp_func( linux_side, overlay_handle, &our_texture );
-}
-
-static EVROverlayError ivroverlay_set_overlay_texture( EVROverlayError (*cpp_func)( void *, VROverlayHandle_t, const Texture_t * ),
-                                                       void *linux_side, VROverlayHandle_t overlayHandle,
-                                                       const Texture_t *texture, unsigned int version )
-{
-    IUnknown *texture_iface;
-    HRESULT hr;
-
-    TRACE( "%p, overlayHandle = %s, texture = %p\n", linux_side, wine_dbgstr_longlong( overlayHandle ), texture );
-
-    switch (texture->eType)
-    {
-    case TextureType_DirectX:
-    {
-        IDXGIVkInteropSurface *dxvk_surface;
-
-        TRACE( "D3D11\n" );
-
-        if (!texture->handle)
-        {
-            WARN( "No D3D11 texture %p.\n", texture );
-            return cpp_func( linux_side, overlayHandle, texture );
-        }
-
-        texture_iface = texture->handle;
-
-        if (SUCCEEDED(hr = texture_iface->lpVtbl->QueryInterface( texture_iface, &IID_IDXGIVkInteropSurface,
-                                                                  (void **)&dxvk_surface )))
-        {
-            return ivroverlay_set_overlay_texture_dxvk( cpp_func, linux_side, overlayHandle, texture, version, dxvk_surface );
-        }
-
-        WARN( "Invalid D3D11 texture %p.\n", texture );
-        return cpp_func( linux_side, overlayHandle, texture );
-    }
-
-    case TextureType_Vulkan:
-        TRACE( "Vulkan\n" );
-        return ivroverlay_set_overlay_texture_vulkan( cpp_func, linux_side, overlayHandle, texture, version );
-
-    default:
-        return cpp_func( linux_side, overlayHandle, texture );
-    }
 }
 
 VROverlayError __thiscall winIVROverlay_IVROverlay_001_SetOverlayTexture( struct w_steam_iface *_this,
@@ -194,179 +165,287 @@ VROverlayError __thiscall winIVROverlay_IVROverlay_005_SetOverlayTexture( struct
 EVROverlayError __thiscall winIVROverlay_IVROverlay_007_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_007_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 7 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_007_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_008_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_008_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 8 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_008_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_010_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_010_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 10 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_010_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_011_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_011_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 11 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_011_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_012_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_012_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 12 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_012_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_013_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_013_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 13 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_013_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_014_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_014_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 14 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_014_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_016_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_016_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 16 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_016_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_017_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_017_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 17 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_017_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_018_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_018_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 18 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_018_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_019_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_019_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 19 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_019_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_020_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_020_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 20 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_020_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_021_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 21 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_021_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_022_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_022_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 22 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_022_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_024_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 24 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_024_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_025_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 25 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_025_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_026_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 26 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_026_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }
 
 EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTexture( struct w_steam_iface *_this, VROverlayHandle_t ulOverlayHandle,
                                                                            const Texture_t *pTexture )
 {
+    struct set_overlay_texture_state state = {.texture = *pTexture};
     EVROverlayError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivroverlay_set_overlay_texture( cppIVROverlay_IVROverlay_027_SetOverlayTexture,
+
-                                           _this->u_iface, ulOverlayHandle, pTexture, 27 );
+    if (pTexture->eType == TextureType_DirectX) load_overlay_texture_dxvk( pTexture, &state );
+    if (pTexture->eType == TextureType_Vulkan) load_overlay_texture_vulkan( pTexture, &state );
+    _ret = cppIVROverlay_IVROverlay_027_SetOverlayTexture( _this->u_iface, ulOverlayHandle, &state.texture );
+    if (pTexture->eType == TextureType_DirectX) free_unix_overlay_texture_dxvk( &state );
+
     return _ret;
 }

vrclient_x64/vrclient_x64/vrrendermodels_manual.c

@@ -100,79 +100,71 @@ static EVRRenderModelError load_into_texture_d3d11( ID3D11Texture2D *texture, co
     return VRRenderModelError_None;
 }
 
-static EVRRenderModelError load_linux_texture_map( void *linux_side, TextureID_t texture_id,
+static EVRRenderModelError load_linux_texture_map_004( void *linux_side, TextureID_t texture_id,
-                                                   struct winRenderModel_TextureMap_t_1237 **texture_map,
+                                                       struct winRenderModel_TextureMap_t_1237 **texture_map )
-                                                   unsigned int version )
 {
-    EVRRenderModelError ret;
+    struct winRenderModel_TextureMap_t_0918 *orig_map;
+    EVRRenderModelError _ret;
 
-    switch (version)
+    _ret = cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async( linux_side, texture_id, &orig_map );
-    {
+    if (_ret) return _ret;
-    case 4:
-    {
-        struct winRenderModel_TextureMap_t_0918 *orig_map;
-        if ((ret = cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async( linux_side, texture_id, &orig_map )))
-            return ret;
-        *texture_map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map) );
-        memcpy( *texture_map, orig_map, sizeof(*orig_map) );
-        cppIVRRenderModels_IVRRenderModels_004_FreeTexture( linux_side, orig_map );
-        return 0;
-    }
-    case 5:
-    {
-        struct winRenderModel_TextureMap_t_1015 *orig_map;
-        if ((ret = cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async( linux_side, texture_id, &orig_map )))
-            return ret;
-        *texture_map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map) );
-        memcpy( *texture_map, orig_map, sizeof(*orig_map) );
-        cppIVRRenderModels_IVRRenderModels_005_FreeTexture( linux_side, orig_map );
-        return 0;
-    }
-    case 6:
-        return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async( linux_side, texture_id,
-                                                                         (winRenderModel_TextureMap_t_1267 **)texture_map );
-    }
 
-    FIXME( "Unsupported IVRRenderModels version! %u\n", version );
+    *texture_map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map) );
-    return VRRenderModelError_NotSupported;
+    memcpy( *texture_map, orig_map, sizeof(*orig_map) );
+    cppIVRRenderModels_IVRRenderModels_004_FreeTexture( linux_side, orig_map );
+
+    return 0;
 }
 
-static void free_linux_texture_map( void *linux_side, struct winRenderModel_TextureMap_t_1237 *texture_map,
+static void free_linux_texture_map_004( void *linux_side, struct winRenderModel_TextureMap_t_1237 *texture_map )
-                                    unsigned int version )
 {
-    switch (version)
+    HeapFree( GetProcessHeap(), 0, texture_map );
-    {
-    case 4: HeapFree( GetProcessHeap(), 0, texture_map ); break;
-    case 5: HeapFree( GetProcessHeap(), 0, texture_map ); break;
-    case 6:
-        cppIVRRenderModels_IVRRenderModels_006_FreeTexture( linux_side, (winRenderModel_TextureMap_t_1267 *)texture_map );
-        break;
-    default: FIXME( "Unsupported IVRRenderModels version! %u\n", version ); break;
-    }
 }
 
-static EVRRenderModelError ivrrendermodels_load_texture_d3d11_async( void *linux_side, TextureID_t texture_id,
+static EVRRenderModelError load_linux_texture_map_005( void *linux_side, TextureID_t texture_id,
-                                                                     void *device, void **dst_texture, unsigned int version )
+                                                       struct winRenderModel_TextureMap_t_1237 **texture_map )
+{
+    struct winRenderModel_TextureMap_t_1015 *orig_map;
+    EVRRenderModelError _ret;
+
+    _ret = cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async( linux_side, texture_id, &orig_map );
+    if (_ret) return _ret;
+
+    *texture_map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map) );
+    memcpy( *texture_map, orig_map, sizeof(*orig_map) );
+    cppIVRRenderModels_IVRRenderModels_005_FreeTexture( linux_side, orig_map );
+
+    return 0;
+}
+
+static void free_linux_texture_map_005( void *linux_side, struct winRenderModel_TextureMap_t_1237 *texture_map )
+{
+    HeapFree( GetProcessHeap(), 0, texture_map );
+}
+
+static EVRRenderModelError load_linux_texture_map_006( void *linux_side, TextureID_t texture_id,
+                                                       struct winRenderModel_TextureMap_t_1237 **texture_map )
+{
+    EVRRenderModelError _ret;
+
+    _ret = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async( linux_side, texture_id, (struct winRenderModel_TextureMap_t_1267 **)texture_map );
+
+    return _ret;
+}
+
+static void free_linux_texture_map_006( void *linux_side, struct winRenderModel_TextureMap_t_1237 *texture_map )
+{
+    cppIVRRenderModels_IVRRenderModels_006_FreeTexture( linux_side, (struct winRenderModel_TextureMap_t_1267 *)texture_map );
+}
+
+static EVRRenderModelError ivrrendermodels_load_texture_d3d11_async( void *device, struct winRenderModel_TextureMap_t_1237 *texture_map, void **dst_texture )
 {
-    struct winRenderModel_TextureMap_t_1237 *texture_map;
     EVRRenderModelError error;
     D3D11_TEXTURE2D_DESC desc;
     ID3D11Device *d3d11_device = device;
     ID3D11Texture2D *texture;
     HRESULT hr;
 
-    error = load_linux_texture_map( linux_side, texture_id, &texture_map, version );
-    if (error == VRRenderModelError_Loading)
-    {
-        TRACE( "Loading.\n" );
-        return error;
-    }
-    if (error != VRRenderModelError_None)
-    {
-        WARN( "Failed to load texture %#x.\n", error );
-        return error;
-    }
-
     desc.Width = texture_map->unWidth;
     desc.Height = texture_map->unHeight;
     desc.MipLevels = 1;
@@ -189,7 +181,6 @@ static EVRRenderModelError ivrrendermodels_load_texture_d3d11_async( void *linux
     if (FAILED(hr))
     {
         WARN( "Failed to create D3D11 texture %#x\n", hr );
-        free_linux_texture_map( linux_side, texture_map, version );
         return VRRenderModelError_InvalidTexture;
     }
 
@@ -204,33 +195,15 @@ static EVRRenderModelError ivrrendermodels_load_texture_d3d11_async( void *linux
         *dst_texture = NULL;
     }
 
-    free_linux_texture_map( linux_side, texture_map, version );
-
     return error;
 }
 
-static EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async( void *linux_side, TextureID_t texture_id,
+static EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async( void *dst_texture, struct winRenderModel_TextureMap_t_1237 *texture_map )
-                                                                          void *dst_texture, unsigned int version )
 {
-    struct winRenderModel_TextureMap_t_1237 *texture_map;
     IUnknown *unk = dst_texture;
     EVRRenderModelError error;
     ID3D11Texture2D *texture;
 
-    if (!dst_texture) return VRRenderModelError_InvalidArg;
-
-    error = load_linux_texture_map( linux_side, texture_id, &texture_map, version );
-    if (error == VRRenderModelError_Loading)
-    {
-        TRACE( "Loading.\n" );
-        return error;
-    }
-    if (error != VRRenderModelError_None)
-    {
-        WARN( "Failed to load texture %#x.\n", error );
-        return error;
-    }
-
     if (SUCCEEDED(unk->lpVtbl->QueryInterface( unk, &IID_ID3D11Texture2D, (void **)&texture )))
     {
         error = load_into_texture_d3d11( texture, texture_map );
@@ -242,35 +215,84 @@ static EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async( void *
         error = VRRenderModelError_NotSupported;
     }
 
-    free_linux_texture_map( linux_side, texture_map, version );
-
     return error;
 }
 
 EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_004_LoadTextureD3D11_Async( struct w_steam_iface *_this, TextureID_t textureId,
                                                                                               void *pD3D11Device, void **ppD3D11Texture2D )
 {
+    struct winRenderModel_TextureMap_t_1237 *texture_map = NULL;
     EVRRenderModelError _ret;
     TRACE( "%p\n", _this );
-    _ret = ivrrendermodels_load_texture_d3d11_async( _this->u_iface, textureId, pD3D11Device, ppD3D11Texture2D, 4 );
+
+    _ret = load_linux_texture_map_004( _this->u_iface, textureId, &texture_map );
+    if (_ret == VRRenderModelError_Loading)
+    {
+        TRACE( "Loading.\n" );
+        return _ret;
+    }
+    if (_ret != VRRenderModelError_None)
+    {
+        WARN( "Failed to load texture %#x.\n", _ret );
+        return _ret;
+    }
+
+    _ret = ivrrendermodels_load_texture_d3d11_async( pD3D11Device, texture_map, ppD3D11Texture2D );
+
+    free_linux_texture_map_004( _this->u_iface, texture_map );
+
     return _ret;
 }
 
 EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async( struct w_steam_iface *_this, TextureID_t textureId,
                                                                                               void *pD3D11Device, void **ppD3D11Texture2D )
 {
+    struct winRenderModel_TextureMap_t_1237 *texture_map = NULL;
     EVRRenderModelError _ret;
     TRACE( "%p\n", _this );
-    _ret = ivrrendermodels_load_texture_d3d11_async( _this->u_iface, textureId, pD3D11Device, ppD3D11Texture2D, 5 );
+
+    _ret = load_linux_texture_map_005( _this->u_iface, textureId, &texture_map );
+    if (_ret == VRRenderModelError_Loading)
+    {
+        TRACE( "Loading.\n" );
+        return _ret;
+    }
+    if (_ret != VRRenderModelError_None)
+    {
+        WARN( "Failed to load texture %#x.\n", _ret );
+        return _ret;
+    }
+
+    _ret = ivrrendermodels_load_texture_d3d11_async( pD3D11Device, texture_map, ppD3D11Texture2D );
+
+    free_linux_texture_map_005( _this->u_iface, texture_map );
+
     return _ret;
 }
 
 EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async( struct w_steam_iface *_this, TextureID_t textureId,
                                                                                               void *pD3D11Device, void **ppD3D11Texture2D )
 {
+    struct winRenderModel_TextureMap_t_1237 *texture_map = NULL;
     EVRRenderModelError _ret;
     TRACE( "%p\n", _this );
-    _ret = ivrrendermodels_load_texture_d3d11_async( _this->u_iface, textureId, pD3D11Device, ppD3D11Texture2D, 6 );
+
+    _ret = load_linux_texture_map_006( _this->u_iface, textureId, &texture_map );
+    if (_ret == VRRenderModelError_Loading)
+    {
+        TRACE( "Loading.\n" );
+        return _ret;
+    }
+    if (_ret != VRRenderModelError_None)
+    {
+        WARN( "Failed to load texture %#x.\n", _ret );
+        return _ret;
+    }
+
+    _ret = ivrrendermodels_load_texture_d3d11_async( pD3D11Device, texture_map, ppD3D11Texture2D );
+
+    free_linux_texture_map_006( _this->u_iface, texture_map );
+
     return _ret;
 }
 
@@ -284,9 +306,29 @@ void __thiscall winIVRRenderModels_IVRRenderModels_004_FreeTextureD3D11( struct
 EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadIntoTextureD3D11_Async( struct w_steam_iface *_this, TextureID_t textureId,
                                                                                                   void *pDstTexture )
 {
+    struct winRenderModel_TextureMap_t_1237 *texture_map = NULL;
     EVRRenderModelError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivrrendermodels_load_into_texture_d3d11_async( _this->u_iface, textureId, pDstTexture, 5 );
+
+    if (!pDstTexture) return VRRenderModelError_InvalidArg;
+
+    _ret = load_linux_texture_map_005( _this->u_iface, textureId, &texture_map );
+    if (_ret == VRRenderModelError_Loading)
+    {
+        TRACE( "Loading.\n" );
+        return _ret;
+    }
+    if (_ret != VRRenderModelError_None)
+    {
+        WARN( "Failed to load texture %#x.\n", _ret );
+        return _ret;
+    }
+
+    _ret = ivrrendermodels_load_into_texture_d3d11_async( pDstTexture, texture_map );
+
+    free_linux_texture_map_005( _this->u_iface, texture_map );
+
     return _ret;
 }
 
@@ -300,9 +342,29 @@ void __thiscall winIVRRenderModels_IVRRenderModels_005_FreeTextureD3D11( struct
 EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async( struct w_steam_iface *_this, TextureID_t textureId,
                                                                                                   void *pDstTexture )
 {
+    struct winRenderModel_TextureMap_t_1237 *texture_map = NULL;
     EVRRenderModelError _ret;
+
     TRACE( "%p\n", _this );
-    _ret = ivrrendermodels_load_into_texture_d3d11_async( _this->u_iface, textureId, pDstTexture, 6 );
+
+    if (!pDstTexture) return VRRenderModelError_InvalidArg;
+
+    _ret = load_linux_texture_map_006( _this->u_iface, textureId, &texture_map );
+    if (_ret == VRRenderModelError_Loading)
+    {
+        TRACE( "Loading.\n" );
+        return _ret;
+    }
+    if (_ret != VRRenderModelError_None)
+    {
+        WARN( "Failed to load texture %#x.\n", _ret );
+        return _ret;
+    }
+
+    _ret = ivrrendermodels_load_into_texture_d3d11_async( pDstTexture, texture_map );
+
+    free_linux_texture_map_006( _this->u_iface, texture_map );
+
     return _ret;
 }