[util] Disable supportDFFormats for Prototype

Incorrect shadows on AMD & Intel

.github/ISSUE_TEMPLATE/bug_report.md

@@ -26,6 +26,6 @@ Name of the game, settings used etc.
 For instructions on how to use apitrace, see: https://github.com/doitsujin/dxvk/wiki/Using-Apitrace
 
 ### Log files
-- d3d9.log:
-- d3d11.log:
-- dxgi.log:
+Please attach Proton or Wine logs as a text file:
+- When using Proton, set the Steam launch options for your game to `PROTON_LOG=1 %command%` and attach the corresponding `steam-xxxxx.log` file in your home directory.
+- When using regular Wine, use `wine game.exe > game.log 2>&1` and attach the resulting `game.log` file.

.github/workflows/test-build-windows.yml

@@ -16,9 +16,8 @@ jobs:
     - name: Setup glslangValidator
       shell: pwsh
       run: |
-        choco install vulkan-sdk -y
-        Write-Output "$([System.Environment]::GetEnvironmentVariable('VULKAN_SDK', 'Machine'))\Bin" `
-          | Out-File -FilePath "${Env:GITHUB_PATH}" -Append
+        Invoke-WebRequest -Uri "https://raw.githubusercontent.com/HansKristian-Work/vkd3d-proton-ci/main/glslangValidator.exe" -OutFile "glslangValidator.exe"
+        Write-Output "$pwd" | Out-File -FilePath "${Env:GITHUB_PATH}" -Append
 
     - name: Setup Meson
       shell: pwsh

.gitmodules

@@ -7,3 +7,7 @@
 [submodule "include/spirv"]
 	path = include/spirv
 	url = https://github.com/KhronosGroup/SPIRV-Headers.git
+[submodule "subprojects/libdisplay-info"]
+	path = subprojects/libdisplay-info
+	url = https://gitlab.freedesktop.org/JoshuaAshton/libdisplay-info.git
+	branch = windows

LICENSE

@@ -1,5 +1,5 @@
-                  Copyright (c) 2017-2021 Philip Rebohle
-                  Copyright (c) 2019-2021 Joshua Ashton
+                  Copyright (c) 2017 Philip Rebohle
+                  Copyright (c) 2019 Joshua Ashton
 
                           zlib/libpng license
 

README.md

@@ -9,27 +9,32 @@ The most recent development builds can be found [here](https://github.com/doitsu
 Release builds can be found [here](https://github.com/doitsujin/dxvk/releases).
 
 ## How to use
-In order to install a DXVK package obtained from the [release](https://github.com/doitsujin/dxvk/releases) page into a given wine prefix, run the following commands from within the DXVK directory:
+In order to install a DXVK package obtained from the [release](https://github.com/doitsujin/dxvk/releases) page into a given wine prefix, copy or symlink the DLLs into the following directories as follows, then open `winecfg` and manually add DLL overrides for `d3d11`, `d3d10core`, `dxgi`, and `d3d9`.
 
+In a default Wine prefix that would be as follows:
 ```
-export WINEPREFIX=/path/to/.wine-prefix
-./setup_dxvk.sh install
+export WINEPREFIX=/path/to/wineprefix
+cp x64/*.dll $WINEPREFIX/drive_c/windows/system32
+cp x32/*.dll $WINEPREFIX/drive_c/windows/syswow64
+winecfg
 ```
 
-This will **copy** the DLLs into the `system32` and `syswow64` directories of your wine prefix and set up the required DLL overrides. Pure 32-bit prefixes are also supported.
-
-The setup script optionally takes the following arguments:
-- `--symlink`: Create symbolic links to the DLL files instead of copying them. This is especially useful for development.
-- `--without-dxgi`: Do not install DXVK's DXGI implementation and use the one provided by wine instead.
-
-Verify that your application uses DXVK instead of wined3d by checking for the presence of the log file `d3d9.log` or `d3d11.log` in the application's directory, or by enabling the HUD (see notes below).
-
-In order to remove DXVK from a prefix, run the following command:
+For a pure 32-bit Wine prefix (non default) the 32-bit DLLs instead go to the `system32` directory:
 ```
-export WINEPREFIX=/path/to/.wine-prefix
-./setup_dxvk.sh uninstall
+export WINEPREFIX=/path/to/wineprefix
+cp x32/*.dll $WINEPREFIX/drive_c/windows/system32
+winecfg
 ```
 
+Verify that your application uses DXVK instead of wined3d by enabling the HUD (see notes below).
+
+In order to remove DXVK from a prefix, remove the DLLs and DLL overrides, and run `wineboot -u` to restore the original DLL files.
+
+Tools such as Steam Play, Lutris, Bottles, Heroic Launcher, etc will automatically handle setup of dxvk on their own when enabled.
+
+### Notes on Vulkan drivers
+Before reporting an issue, please check the [Wiki](https://github.com/doitsujin/dxvk/wiki/Driver-support) page on the current driver status and make sure you run a recent enough driver version for your hardware.
+
 ## Build instructions
 
 In order to pull in all submodules that are needed for building, clone the repository using the following command:
@@ -40,7 +45,7 @@ git clone --recursive https://github.com/doitsujin/dxvk.git
 
 
 ### Requirements:
-- [wine 3.10](https://www.winehq.org/) or newer
+- [wine 7.1](https://www.winehq.org/) or newer
 - [Meson](https://mesonbuild.com/) build system (at least version 0.49)
 - [Mingw-w64](https://www.mingw-w64.org) compiler and headers (at least version 10.0)
 - [glslang](https://github.com/KhronosGroup/glslang) compiler
@@ -73,12 +78,14 @@ ninja install
 
 The D3D9, D3D10, D3D11 and DXGI DLLs will be located in `/your/dxvk/directory/bin`. Setup has to be done manually in this case.
 
-### Notes on Vulkan drivers
-Before reporting an issue, please check the [Wiki](https://github.com/doitsujin/dxvk/wiki/Driver-support) page on the current driver status and make sure you run a recent enough driver version for your hardware.
-
 ### Online multi-player games
 Manipulation of Direct3D libraries in multi-player games may be considered cheating and can get your account **banned**. This may also apply to single-player games with an embedded or dedicated multiplayer portion. **Use at your own risk.**
 
+### Logs
+When used with Wine, DXVK will print log messages to `stderr`. Additionally, standalone log files can optionally be generated by setting the `DXVK_LOG_PATH` variable, where log files in the given directory will be called `app_d3d11.log`, `app_dxgi.log` etc., where `app` is the name of the game executable.
+
+On Windows, log files will be created in the game's working directory by default, which is usually next to the game executable.
+
 ### HUD
 The `DXVK_HUD` environment variable controls a HUD which can display the framerate and some stat counters. It accepts a comma-separated list of the following options:
 - `devinfo`: Displays the name of the GPU and the driver version.
@@ -96,6 +103,7 @@ The `DXVK_HUD` environment variable controls a HUD which can display the framera
 - `compiler`: Shows shader compiler activity
 - `samplers`: Shows the current number of sampler pairs used *[D3D9 Only]*
 - `scale=x`: Scales the HUD by a factor of `x` (e.g. `1.5`)
+- `opacity=y`: Adjusts the HUD opacity by a factor of `y` (e.g. `0.5`, `1.0` being fully opaque).
 
 Additionally, `DXVK_HUD=1` has the same effect as `DXVK_HUD=devinfo,fps`, and `DXVK_HUD=full` enables all available HUD elements.
 
@@ -108,6 +116,15 @@ Some applications do not provide a method to select a different GPU. In that cas
 
 **Note:** If the device filter is configured incorrectly, it may filter out all devices and applications will be unable to create a D3D device.
 
+### Graphics Pipeline Library
+On drivers which support `VK_EXT_graphics_pipeline_library` Vulkan shaders will be compiled at the time the game loads its D3D shaders, rather than at draw time. This reduces or eliminates shader compile stutter in many games when compared to the previous system.
+
+In games that load their shaders during loading screens or in the menu, this can lead to prolonged periods of very high CPU utilization, especially on weaker CPUs. For affected games it is recommended to wait for shader compilation to finish before starting the game to avoid stutter and low performance. Shader compiler activity can be monitored with `DXVK_HUD=compiler`.
+
+This feature largely replaces the state cache.
+
+**Note:** Games which only load their D3D shaders at draw time (e.g. most Unreal Engine games) will still exhibit some stutter, although it should still be less severe than without this feature.
+
 ### State cache
 DXVK caches pipeline state by default, so that shaders can be recompiled ahead of time on subsequent runs of an application, even if the driver's own shader cache got invalidated in the meantime. This cache is enabled by default, and generally reduces stuttering.
 
@@ -117,13 +134,16 @@ The following environment variables can be used to control the cache:
   - `reset`: Clears the cache file.
 - `DXVK_STATE_CACHE_PATH=/some/directory` Specifies a directory where to put the cache files. Defaults to the current working directory of the application.
 
+This feature is mostly only relevant on systems without support for `VK_EXT_graphics_pipeline_library`
+
 ### Debugging
 The following environment variables can be used for **debugging** purposes.
 - `VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation` Enables Vulkan debug layers. Highly recommended for troubleshooting rendering issues and driver crashes. Requires the Vulkan SDK to be installed on the host system.
 - `DXVK_LOG_LEVEL=none|error|warn|info|debug` Controls message logging.
 - `DXVK_LOG_PATH=/some/directory` Changes path where log files are stored. Set to `none` to disable log file creation entirely, without disabling logging.
-- `DXVK_CONFIG_FILE=/xxx/dxvk.conf` Sets path to the configuration file.
 - `DXVK_DEBUG=markers|validation` Enables use of the `VK_EXT_debug_utils` extension for translating performance event markers, or to enable Vulkan validation, respecticely.
+- `DXVK_CONFIG_FILE=/xxx/dxvk.conf` Sets path to the configuration file.
+- `DXVK_CONFIG="dxgi.hideAmdGpu = True; dxgi.syncInterval = 0"` Can be used to set config variables through the environment instead of a configuration file using the same syntax. `;` is used as a seperator.
 
 ## Troubleshooting
 DXVK requires threading support from your mingw-w64 build environment. If you
@@ -143,3 +163,22 @@ For non debian based distros, make sure that your mingw-w64-gcc cross compiler
 does have `--enable-threads=posix` enabled during configure. If your distro does
 ship its mingw-w64-gcc binary with `--enable-threads=win32` you might have to
 recompile locally or open a bug at your distro's bugtracker to ask for it. 
+
+# DXVK Native
+
+DXVK Native is a version of DXVK which allows it to be used natively without Wine.
+
+This is primarily useful for game and application ports to either avoid having to write another rendering backend, or to help with port bringup during development.
+
+[Release builds](https://github.com/doitsujin/dxvk/releases) are built using the Steam Runtime.
+
+### How does it work?
+
+DXVK Native replaces certain Windows-isms with a platform and framework-agnostic replacement, for example, `HWND`s can become `SDL_Window*`s, etc.
+All it takes to do that is to add another WSI backend.
+
+**Note:** DXVK Native requires a backend to be explicitly set via the `DXVK_WSI_DRIVER` environment variable. The current built-in options are `SDL2` and `GLFW`.
+
+DXVK Native comes with a slim set of Windows header definitions required for D3D9/11 and the MinGW headers for D3D9/11.
+In most cases, it will end up being plug and play with your renderer, but there may be certain teething issues such as:
+- `__uuidof(type)` is supported, but `__uuidof(variable)` is not supported. Use `__uuidof_var(variable)` instead.

RELEASE

@@ -1 +1 @@
-2.0
+2.3.1

VP_DXVK_requirements.json

@@ -185,7 +185,9 @@
                 "VK_EXT_memory_priority": 1,
                 "VK_EXT_vertex_attribute_divisor": 1,
                 "VK_EXT_custom_border_color": 1,
-                "VK_EXT_depth_clip_enable": 1
+                "VK_EXT_depth_clip_enable": 1,
+                "VK_EXT_swapchain_colorspace": 1,
+                "VK_EXT_hdr_metadata": 1
             },
             "features": {
                 "VkPhysicalDeviceFeatures": {
@@ -385,6 +387,12 @@
         }
     },
     "history": [
+        {
+            "revision": 4,
+            "date": "2022-12-18",
+            "author": "Joshua Ashton",
+            "comment": "Add VK_EXT_swapchain_colorspace and VK_EXT_hdr_metadata to d3d11_baseline_optional"
+        },
         {
             "revision": 3,
             "date": "2022-10-13",

dxvk.conf

@@ -1,3 +1,15 @@
+# Expose the HDR10 ColorSpace (DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020)
+# to the application by default.
+# This shows to the game that the global Windows 'HDR Mode' is enabled.
+# Many (broken) games will need this to be set to consider exposing HDR output
+# as determine it based on the DXGIOutput's current ColorSpace instead of
+# using CheckColorSpaceSupport.
+# This defaults to the value of the DXVK_HDR environment variable.
+# 
+# Supported values: True, False
+
+# dxgi.enableHDR = True
+
 # Create the VkSurface on the first call to IDXGISwapChain::Present,
 # rather than when creating the swap chain. Some games that start
 # rendering with a different graphics API may require this option,
@@ -49,18 +61,43 @@
 # d3d9.customDeviceDesc = ""
 
 
-# Report Nvidia GPUs as AMD GPUs by default. This is enabled by default
-# to work around issues with NVAPI, but may cause issues in some games.
+# Report Nvidia GPUs as AMD GPUs. Unless NVAPI support is explicitly
+# enabled through Proton, this is done by default in order to work
+# around crashes or low performance with Nvidia-speciic code paths
+# in games, especially Unreal Engine.
 #
-# Supported values: True, False
+# Supported values: Auto, True, False
 
-# dxgi.nvapiHack = True
+# dxgi.hideNvidiaGpu = Auto
 
 
+# Report Nvidia GPUs running on NVK as AMD GPUs.
+#
+# Supported values: Auto, True, False
+
+# dxgi.hideNvkGpu = Auto
+
+
+# Report AMD GPUs as Nvidia GPUs. This is only done for games that are
+# known to have issues with AMDAGS or other AMD-specific code paths.
+#
+# Supported values: Auto, True, False
+
+# dxgi.hideAmdGpu = Auto
+
+
+# Report Intel GPUs as AMD GPUs. This is only done for games that are
+# known to have issues with Intel-specific libraries such as XESS.
+#
+# Supported values: Auto, True, False
+
+# dxgi.hideIntelGpu = Auto
+
 
 # Override maximum amount of device memory and shared system memory
 # reported to the application. This may fix texture streaming issues
 # in games that do not support cards with large amounts of VRAM.
+# This is not a hard cap and applications can choose to ignore it.
 #
 # Supported values: Any number in Megabytes.
 
@@ -110,8 +147,7 @@
 #
 # Supported values: Auto, True, False
 
-# dxgi.tearFree = Auto
-# d3d9.tearFree = Auto
+# dxvk.tearFree = Auto
 
 
 # Assume single-use mode for command lists created on deferred contexts.
@@ -178,6 +214,16 @@
 # Supported values: Any number between -2.0 and 1.0
 
 # d3d11.samplerLodBias = 0.0
+# d3d9.samplerLodBias = 0.0
+
+
+# Clamps any negative LOD bias to 0. Applies after samplerLodBias has been
+# applied. May help with games that use a high negative LOD bias by default.
+#
+# Supported values: True, False
+
+# d3d11.clampNegativeLodBias = False
+# d3d9.clampNegativeLodBias = False
 
 
 # Declares vertex positions as invariant in order to solve
@@ -189,6 +235,16 @@
 # d3d9.invariantPosition = True
 
 
+# Forces per-sample rate shading when MSAA is enabled, rather than per-pixel
+# shading. May improve visual clarity at a significant performance cost, but
+# may also introduce visual issues in some games.
+#
+# Supported values: True, False
+
+# d3d11.forceSampleRateShading = False
+# d3d9.forceSampleRateShading = False
+
+
 # Forces the sample count of all textures to 1, and performs
 # the needed fixups in resolve operations and shaders.
 #
@@ -244,6 +300,18 @@
 # d3d11.enableContextLock = False
 
 
+# Exposes or hides support for driver command lists
+#
+# Some games use the feature flag to decide whether to use deferred
+# contexts or not. We enable this by default, but in some situations
+# this can lead to issues if games detect an AMD GPU where command
+# lists are not natively supported on Windows.
+#
+# Supported values: True, False
+
+# d3d11.exposeDriverCommandLists = True
+
+
 # Sets number of pipeline compiler threads.
 # 
 # If the graphics pipeline library feature is enabled, the given
@@ -272,6 +340,17 @@
 # dxvk.useRawSsbo = Auto
 
 
+# Changes memory chunk size.
+#
+# Can be used to override the maximum memory chunk size.
+#
+# Supported values:
+# - 0 to use the defaults
+# - any positive integer to limit the chunk size, in MiB
+
+# dxvk.maxChunkSize = 0
+
+
 # Controls graphics pipeline library behaviour
 #
 # Can be used to change VK_EXT_graphics_pipeline_library usage for
@@ -420,6 +499,7 @@
 # Supported values:
 # - True/False
 
+# d3d11.longMad = False
 # d3d9.longMad = False
 
 # Device Local Constant Buffers
@@ -433,18 +513,11 @@
 
 # d3d9.deviceLocalConstantBuffers = False
 
-# No Explicit Front Buffer
-#
-# Disables the front buffer
-#
-# Supported values:
-# - True/False
-
-# d3d9.noExplicitFrontBuffer = False
-
 # Support DF formats
 #
-# Support the vendor extension DF floating point depth formats
+# Support the vendor extension DF floating point depth formats on AMD and Intel.
+# Note that this config is ignored and disabled by default on Nvidia, or when
+# spoofing a Nvidia GPU, as it does not support these formats natively.
 #
 # Supported values:
 # - True/False
@@ -463,7 +536,7 @@
 # Support X4R4G4B4
 #
 # Support the X4R4G4B4 format.
-# The Sims 2 is a horrible game made by complete morons.
+# The Sims 2 is a very broken game.
 #
 # Supported values:
 # - True/False
@@ -482,7 +555,7 @@
 # Disable A8 as a Render Target
 #
 # Disable support for A8 format render targets
-# Once again, The Sims 2 is a horrible game made by complete morons.
+# Once again, The Sims 2 is a very broken game.
 #
 # Supported values:
 # - True/False
@@ -522,16 +595,6 @@
 
 # d3d9.forceAspectRatio = ""
 
-# Allow Discard
-#
-# Allow the discard lock flag to be used
-# Useful if some apps use this incorrectly.
-#
-# Supported values:
-# - True/False
-
-# d3d9.allowDiscard = True
-
 # Enumerate by Displays
 #
 # Whether we should enumerate D3D9 adapters by display (windows behaviour)
@@ -543,16 +606,17 @@
 
 # d3d9.enumerateByDisplays = True
 
-# APITrace Mode
+# Cached Dynamic Buffers
 #
-# Makes all host visible buffers cached and coherent
-# Improves performance when apitracing, but also can impact
-# some dumb games.
+# Allocates dynamic resources in D3DPOOL_DEFAULT in
+# cached system memory rather than uncached memory or host-visible
+# VRAM, in order to allow fast readback from the CPU. This is only
+# useful for buggy applications, and may reduce GPU-bound performance.
 #
 # Supported values:
 # - True/False
 
-# d3d9.apitraceMode = False
+# d3d9.cachedDynamicBuffers = False
 
 # Seamless Cubes
 #
@@ -582,3 +646,37 @@
 # DO NOT CHANGE THIS UNLESS YOU HAVE A VERY GOOD REASON.
 
 # d3d9.textureMemory = 100
+
+# Hide integrated graphics from applications
+#
+# Only has an effect when dedicated GPUs are present on the system. It is
+# not recommended to use this option at all unless absolutely necessary for
+# a game to work; prefer using DXVK_FILTER_DEVICE_NAME whenever possible.
+#
+# Supported values:
+# - True/False
+
+# dxvk.hideIntegratedGraphics = False
+
+# Trigger DEVICELOST when losing focus
+#
+# D3D9 requires the application to call Device::Reset after
+# it loses focus in fullscreen.
+# Some games rely on observing a D3DERR_DEVICELOST or D3DERR_NOTRESET.
+# Others don't handle it correctly.
+#
+# Supported values:
+# - True/False
+
+# d3d9.deviceLossOnFocusLoss = False
+
+# Reject Device::Reset if any losable resource is still alive
+#
+# D3D9 rejects Device::Reset if there's still any alive resources of specific types.
+# (State blocks, additional swapchains, D3DPOOL_DEFAULT resources)
+# Some games leak resources leading to a hang.
+#
+# Supported values:
+# - True/False
+
+# d3d9.countLosableResources = True

include/native/windows/unknwn.h

@@ -12,6 +12,10 @@ struct IUnknown {
 public:
 
   virtual HRESULT QueryInterface(REFIID riid, void** ppvObject) = 0;
+  template<class Q>
+  HRESULT STDMETHODCALLTYPE QueryInterface(Q **pp) {
+    return QueryInterface(__uuidof(Q), (void **)pp);
+  }
 
   virtual ULONG AddRef()  = 0;
   virtual ULONG Release() = 0;

include/native/windows/windows_base.h

@@ -23,10 +23,16 @@ typedef uint32_t UINT;
 
 typedef int32_t LONG;
 typedef uint32_t ULONG;
+typedef int32_t *LPLONG;
 
 typedef int32_t HRESULT;
 
 typedef wchar_t WCHAR;
+typedef WCHAR *NWPSTR, *LPWSTR, *PWSTR;
+typedef unsigned char UCHAR, *PUCHAR;
+
+typedef char CHAR;
+typedef const CHAR *LPCSTR, *PCSTR;
 
 typedef INT BOOL;
 typedef BOOL WINBOOL;
@@ -35,11 +41,13 @@ typedef uint16_t UINT16;
 typedef uint32_t UINT32;
 typedef uint64_t UINT64;
 typedef void VOID;
+typedef void* PVOID;
 typedef void* LPVOID;
 typedef const void* LPCVOID;
 
 typedef size_t SIZE_T;
 
+typedef int8_t INT8;
 typedef uint8_t UINT8;
 typedef uint8_t BYTE;
 
@@ -47,7 +55,13 @@ typedef int16_t SHORT;
 typedef uint16_t USHORT;
 
 typedef int64_t LONGLONG;
+typedef int64_t INT64;
+
 typedef uint64_t ULONGLONG;
+typedef uint64_t UINT64;
+
+typedef intptr_t LONG_PTR;
+typedef uintptr_t ULONG_PTR;
 
 typedef float FLOAT;
 
@@ -66,9 +80,11 @@ typedef GUID IID;
 #ifdef __cplusplus
 #define REFIID const IID&
 #define REFGUID const GUID&
+#define REFCLSID const GUID&
 #else
 #define REFIID const IID*
 #define REFGUID const GUID*
+#define REFCLSID const GUID* const
 #endif // __cplusplus
 
 #ifdef __cplusplus
@@ -86,6 +102,7 @@ inline bool operator!=(const GUID& a, const GUID& b) { return std::memcmp(&a, &b
 
 typedef uint32_t DWORD;
 typedef uint16_t WORD;
+typedef DWORD *LPDWORD;
 
 typedef void* HANDLE;
 typedef HANDLE HMONITOR;
@@ -107,6 +124,12 @@ typedef uint32_t UINT_PTR;
 typedef INT_PTR*  PINT_PTR;
 typedef UINT_PTR* PUINT_PTR;
 
+#ifdef STRICT
+#define DECLARE_HANDLE(a) typedef struct a##__ { int unused; } *a
+#else /*STRICT*/
+#define DECLARE_HANDLE(a) typedef HANDLE a
+#endif /*STRICT*/
+
 typedef char* LPSTR;
 typedef wchar_t* LPWSTR;
 typedef const char* LPCSTR;
@@ -129,12 +152,12 @@ typedef struct RECT {
   LONG top;
   LONG right;
   LONG bottom;
-} RECT;
+} RECT,*PRECT,*NPRECT,*LPRECT;
 
 typedef struct SIZE {
   LONG cx;
   LONG cy;
-} SIZE;
+} SIZE,*PSIZE,*LPSIZE;
 
 typedef union {
   struct {
@@ -166,7 +189,7 @@ typedef struct PALETTEENTRY {
   BYTE peGreen;
   BYTE peBlue;
   BYTE peFlags;
-} PALETTEENTRY;
+} PALETTEENTRY, *PPALETTEENTRY, *LPPALETTEENTRY;
 
 typedef struct RGNDATAHEADER {
   DWORD dwSize;
@@ -179,7 +202,7 @@ typedef struct RGNDATAHEADER {
 typedef struct RGNDATA {
   RGNDATAHEADER rdh;
   char          Buffer[1];
-} RGNDATA;
+} RGNDATA,*PRGNDATA,*NPRGNDATA,*LPRGNDATA;
 
 // Ignore these.
 #define STDMETHODCALLTYPE
@@ -191,6 +214,11 @@ typedef struct RGNDATA {
 #define TRUE 1
 #define FALSE 0
 
+#define WAIT_TIMEOUT    0x00000102
+#define WAIT_FAILED	    0xffffffff
+#define WAIT_OBJECT_0		0
+#define WAIT_ABANDONED  0x00000080
+
 #define interface struct
 #define MIDL_INTERFACE(x) struct
 
@@ -278,6 +306,7 @@ typedef struct RGNDATA {
 #define THIS_
 #define THIS
 
+#define __C89_NAMELESSSTRUCTNAME
 #define __C89_NAMELESSUNIONNAME
 #define __C89_NAMELESSUNIONNAME1
 #define __C89_NAMELESSUNIONNAME2
@@ -290,17 +319,35 @@ typedef struct RGNDATA {
 #define __C89_NAMELESS
 #define DUMMYUNIONNAME
 #define DUMMYSTRUCTNAME
+#define DUMMYUNIONNAME1
+#define DUMMYUNIONNAME2
+#define DUMMYUNIONNAME3
+#define DUMMYUNIONNAME4
+#define DUMMYUNIONNAME5
+#define DUMMYUNIONNAME6
+#define DUMMYUNIONNAME7
+#define DUMMYUNIONNAME8
+#define DUMMYUNIONNAME9
 
 #ifdef __cplusplus
 #define DECLARE_INTERFACE(x)     struct x
 #define DECLARE_INTERFACE_(x, y) struct x : public y
 #else
+#ifdef CONST_VTABLE
 #define DECLARE_INTERFACE(x) \
     typedef interface x { \
         const struct x##Vtbl *lpVtbl; \
     } x; \
     typedef const struct x##Vtbl x##Vtbl; \
     const struct x##Vtbl
+#else
+#define DECLARE_INTERFACE(x) \
+    typedef interface x { \
+        struct x##Vtbl *lpVtbl; \
+    } x; \
+    typedef struct x##Vtbl x##Vtbl; \
+    struct x##Vtbl
+#endif // CONST_VTABLE
 #define DECLARE_INTERFACE_(x, y) DECLARE_INTERFACE(x)
 #endif // __cplusplus
 
@@ -327,3 +374,25 @@ typedef struct RGNDATA {
 
 #define FAILED(hr) ((HRESULT)(hr) < 0)
 #define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
+
+#define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
+#define ZeroMemory RtlZeroMemory
+
+#ifndef DEFINE_ENUM_FLAG_OPERATORS
+
+#ifdef __cplusplus
+# define DEFINE_ENUM_FLAG_OPERATORS(type) \
+extern "C++" \
+{ \
+    inline type operator &(type x, type y) { return (type)((int)x & (int)y); } \
+    inline type operator &=(type &x, type y) { return (type &)((int &)x &= (int)y); } \
+    inline type operator ~(type x) { return (type)~(int)x; } \
+    inline type operator |(type x, type y) { return (type)((int)x | (int)y); } \
+    inline type operator |=(type &x, type y) { return (type &)((int &)x |= (int)y); } \
+    inline type operator ^(type x, type y) { return (type)((int)x ^ (int)y); } \
+    inline type operator ^=(type &x, type y) { return (type &)((int &)x ^= (int)y); } \
+}
+#else
+# define DEFINE_ENUM_FLAG_OPERATORS(type)
+#endif
+#endif /* DEFINE_ENUM_FLAG_OPERATORS */

include/native/wsi/native_glfw.h

@@ -0,0 +1,25 @@
+#include <windows.h>
+
+#include <GLFW/glfw3.h>
+
+namespace dxvk::wsi {
+
+  inline GLFWwindow* fromHwnd(HWND hWindow) {
+    return reinterpret_cast<GLFWwindow*>(hWindow);
+  }
+
+  inline HWND toHwnd(GLFWwindow* pWindow) {
+    return reinterpret_cast<HWND>(pWindow);
+  }
+
+  // Offset so null HMONITORs go to -1
+  inline int32_t fromHmonitor(HMONITOR hMonitor) {
+    return static_cast<int32_t>(reinterpret_cast<intptr_t>(hMonitor)) - 1;
+  }
+
+  // Offset so -1 display id goes to 0 == NULL
+  inline HMONITOR toHmonitor(int32_t displayId) {
+    return reinterpret_cast<HMONITOR>(static_cast<intptr_t>(displayId + 1));
+  }
+
+}

include/native/wsi/native_sdl2.h

@@ -1,6 +1,6 @@
 #include <windows.h>
 
-#include <SDL2/SDL.h>
+#include <SDL.h>
 
 namespace dxvk::wsi {
 
@@ -22,4 +22,4 @@ namespace dxvk::wsi {
     return reinterpret_cast<HMONITOR>(static_cast<intptr_t>(displayId + 1));
   }
 
-}
+}

include/native/wsi/native_wsi.h

@@ -4,6 +4,8 @@
 #error You shouldnt be using this code path.
 #elif DXVK_WSI_SDL2
 #include "wsi/native_sdl2.h"
+#elif DXVK_WSI_GLFW
+#include "wsi/native_glfw.h"
 #else
 #error Unknown wsi!
 #endif

include/spirv

@@ -1 +1 @@
-Subproject commit 0bcc624926a25a2a273d07877fd25a6ff5ba1cfb
+Subproject commit 8b246ff75c6615ba4532fe4fde20f1be090c3764

include/vulkan

@@ -1 +1 @@
-Subproject commit 98f440ce6868c94f5ec6e198cc1adda4760e8849
+Subproject commit 46dc0f6e514f5730784bb2cac2a7c731636839e8

meson.build

@@ -1,11 +1,12 @@
-project('dxvk', ['c', 'cpp'], version : 'v2.0', meson_version : '>= 0.49', default_options : [ 'cpp_std=c++17', 'warning_level=2' ])
+project('dxvk', ['c', 'cpp'], version : 'v2.3.1', meson_version : '>= 0.58', default_options : [ 'cpp_std=c++17', 'warning_level=2' ])
 
 cpu_family = target_machine.cpu_family()
 platform   = target_machine.system()
+fs = import('fs')
 
 cpp = meson.get_compiler('cpp')
 cc = meson.get_compiler('c')
-dxvk_is_msvc = cpp.get_id() == 'msvc'
+dxvk_is_msvc = cpp.get_argument_syntax() == 'msvc'
 
 compiler_args = [
   '-msse',
@@ -33,11 +34,24 @@ if get_option('build_id')
   ]
 endif
 
-dxvk_include_dirs = [
-  './include',
-  './include/vulkan/include',
-  './include/spirv/include'
-]
+dxvk_include_dirs = ['./include']
+if fs.is_dir('./include/vulkan/include')
+  dxvk_include_dirs += ['./include/vulkan/include']
+elif not cpp.check_header('vulkan/vulkan.h')
+  error('Missing Vulkan-Headers')
+endif
+if fs.is_dir('./include/spirv/include')
+  dxvk_include_dirs += ['./include/spirv/include']
+elif not cpp.check_header('spirv/unified1/spirv.hpp')
+  error('Missing SPIRV-Headers')
+endif
+
+dep_displayinfo = dependency(
+  'libdisplay-info',
+  version: ['>= 0.0.0', '< 0.2.0'],
+  fallback: ['libdisplay-info', 'di_dep'],
+  default_options: ['default_library=static'],
+)
 
 if platform == 'windows'
   compiler_args += [
@@ -45,29 +59,34 @@ if platform == 'windows'
     '-D_WIN32_WINNT=0xa00',
   ]
 
-  link_args += [
-    '-static',
-    '-static-libgcc',
-    '-static-libstdc++',
-    # We need to set the section alignment for debug symbols to
-    # work properly as well as avoiding a memcpy from the Wine loader.
-    '-Wl,--file-alignment=4096',
-  ]
-
-  # Wine's built-in back traces only work with dwarf2 symbols
-  if get_option('debug')
-    compiler_args += [
-      '-gstrict-dwarf',
-      '-gdwarf-2',
-    ]
-  endif
-
-  # Enable stdcall fixup on 32-bit
-  if cpu_family == 'x86'
+  if not dxvk_is_msvc
     link_args += [
-      '-Wl,--enable-stdcall-fixup',
-      '-Wl,--add-stdcall-alias',
-  ]
+      '-static',
+      '-static-libgcc',
+      '-static-libstdc++',
+      # We need to set the section alignment for debug symbols to
+      # work properly as well as avoiding a memcpy from the Wine loader.
+      '-Wl,--file-alignment=4096',
+    ]
+
+    # Wine's built-in back traces only work with dwarf4 symbols
+    if get_option('debug')
+      compiler_args += [
+        '-gdwarf-4',
+      ]
+    endif
+
+    # Enable stdcall fixup on 32-bit
+    if cpu_family == 'x86'
+      link_args += [
+        '-Wl,--enable-stdcall-fixup',
+        '-Wl,--kill-at',
+      ]
+    endif
+  else
+    link_args += [
+      '/FILEALIGN:4096',
+    ]
   endif
 
   lib_d3d9    = cpp.find_library('d3d9')
@@ -96,12 +115,9 @@ if platform == 'windows'
     )
   endif
 
-  dxvk_wsi = 'win32'
   dxvk_name_prefix = ''
   compiler_args += ['-DDXVK_WSI_WIN32']
 else
-  lib_sdl2   = cpp.find_library('SDL2')
-
   wrc           = find_program('touch')
   wrc_generator = generator(wrc, output : [ '@BASENAME@_ignored.h' ], arguments : [ '@OUTPUT@' ] )
 
@@ -111,9 +127,19 @@ else
     './include/native/directx'
   ]
 
-  dxvk_wsi = 'sdl2'
+  lib_sdl2 = dependency('SDL2', required: false)
+  lib_glfw = dependency('glfw', required: false)
+  if lib_sdl2.found()
+    compiler_args += ['-DDXVK_WSI_SDL2']
+  endif
+  if lib_glfw.found()
+    compiler_args += ['-DDXVK_WSI_GLFW']
+  endif
+  if (not lib_sdl2.found() and not lib_glfw.found())
+    error('SDL2 or GLFW are required to build dxvk-native')
+  endif
+  
   dxvk_name_prefix = 'libdxvk_'
-  compiler_args += ['-DDXVK_WSI_SDL2']
 
   link_args += [
     '-static-libgcc',
@@ -132,10 +158,10 @@ exe_ext = ''
 dll_ext = ''
 def_spec_ext = '.def'
 
-glsl_compiler = find_program('glslangValidator')
+glsl_compiler = find_program('glslang', 'glslangValidator')
 glsl_args = [
   '--quiet',
-  '--target-env', 'vulkan1.2',
+  '--target-env', 'vulkan1.3',
   '--vn', '@BASENAME@',
   '--depfile', '@DEPFILE@',
   '@INPUT@',

meson_options.txt

@@ -3,3 +3,5 @@ option('enable_d3d9',  type : 'boolean', value : true, description: 'Build D3D9'
 option('enable_d3d10', type : 'boolean', value : true, description: 'Build D3D10')
 option('enable_d3d11', type : 'boolean', value : true, description: 'Build D3D11')
 option('build_id',     type : 'boolean', value : false)
+
+option('dxvk_native_wsi',   type : 'string',  value : 'sdl2', description: 'WSI system to use if building natively.')

package-native.sh

@@ -10,7 +10,8 @@ if [ -z "$1" ] || [ -z "$2" ]; then
 fi
 
 DXVK_VERSION="$1"
-DXVK_SRC_DIR=`dirname $(readlink -f $0)`
+DXVK_SRC_DIR=$(readlink -f "$0")
+DXVK_SRC_DIR=$(dirname "$DXVK_SRC_DIR")
 DXVK_BUILD_DIR=$(realpath "$2")"/dxvk-native-$DXVK_VERSION"
 DXVK_ARCHIVE_PATH=$(realpath "$2")"/dxvk-native-$DXVK_VERSION.tar.gz"
 
@@ -55,13 +56,14 @@ function build_arch {
     opt_strip=--strip
   fi
 
-  CC="$CC -m$1" CXX="$CXX -m$1" meson setup \
-        --buildtype "release"               \
-        --prefix "$DXVK_BUILD_DIR/usr"      \
-        $opt_strip                          \
-        --bindir "$2"                       \
-        --libdir "$2"                       \
-        -Dbuild_id=$opt_buildid             \
+  CC="$CC -m$1" CXX="$CXX -m$1" meson setup  \
+        --buildtype "release"                \
+        --prefix "$DXVK_BUILD_DIR/usr"       \
+        $opt_strip                           \
+        --bindir "$2"                        \
+        --libdir "$2"                        \
+        -Dbuild_id=$opt_buildid              \
+        --force-fallback-for=libdisplay-info \
         "$DXVK_BUILD_DIR/build.$1"
 
   cd "$DXVK_BUILD_DIR/build.$1"

package-release.sh

@@ -10,7 +10,8 @@ if [ -z "$1" ] || [ -z "$2" ]; then
 fi
 
 DXVK_VERSION="$1"
-DXVK_SRC_DIR=`dirname $(readlink -f $0)`
+DXVK_SRC_DIR=$(readlink -f "$0")
+DXVK_SRC_DIR=$(dirname "$DXVK_SRC_DIR")
 DXVK_BUILD_DIR=$(realpath "$2")"/dxvk-$DXVK_VERSION"
 DXVK_ARCHIVE_PATH=$(realpath "$2")"/dxvk-$DXVK_VERSION.tar.gz"
 
@@ -76,11 +77,6 @@ function build_arch {
   fi
 }
 
-function build_script {
-  cp "$DXVK_SRC_DIR/setup_dxvk.sh" "$DXVK_BUILD_DIR/setup_dxvk.sh"
-  chmod +x "$DXVK_BUILD_DIR/setup_dxvk.sh"
-}
-
 function package {
   cd "$DXVK_BUILD_DIR/.."
   tar -czf "$DXVK_ARCHIVE_PATH" "dxvk-$DXVK_VERSION"
@@ -89,7 +85,6 @@ function package {
 
 build_arch 64
 build_arch 32
-build_script
 
 if [ $opt_nopackage -eq 0 ]; then
   package

setup_dxvk.sh

@@ -1,206 +0,0 @@
-#!/usr/bin/env bash
-
-# default directories
-dxvk_lib32=${dxvk_lib32:-"x32"}
-dxvk_lib64=${dxvk_lib64:-"x64"}
-
-# figure out where we are
-basedir="$(dirname "$(readlink -f "$0")")"
-
-# figure out which action to perform
-action="$1"
-
-case "$action" in
-install)
-  ;;
-uninstall)
-  ;;
-*)
-  echo "Unrecognized action: $action"
-  echo "Usage: $0 [install|uninstall] [--without-dxgi] [--symlink]"
-  exit 1
-esac
-
-# process arguments
-shift
-
-with_dxgi=true
-file_cmd="cp -v --reflink=auto"
-
-while (($# > 0)); do
-  case "$1" in
-  "--without-dxgi")
-    with_dxgi=false
-    ;;
-  "--symlink")
-    file_cmd="ln -s -v"
-    ;;
-  esac
-  shift
-done
-
-# check wine prefix before invoking wine, so that we
-# don't accidentally create one if the user screws up
-if [ -n "$WINEPREFIX" ] && ! [ -f "$WINEPREFIX/system.reg" ]; then
-  echo "$WINEPREFIX:"' Not a valid wine prefix.' >&2
-  exit 1
-fi
-
-# find wine executable
-export WINEDEBUG=-all
-# disable mscoree and mshtml to avoid downloading
-# wine gecko and mono
-export WINEDLLOVERRIDES="mscoree,mshtml="
-
-wine="wine"
-wine64="wine64"
-wineboot="wineboot"
-
-# $PATH is the way for user to control where wine is located (including custom Wine versions).
-# Pure 64-bit Wine (non Wow64) requries skipping 32-bit steps.
-# In such case, wine64 and winebooot will be present, but wine binary will be missing,
-# however it can be present in other PATHs, so it shouldn't be used, to avoid versions mixing.
-wine_path=$(dirname "$(which $wineboot)")
-wow64=true
-if ! [ -f "$wine_path/$wine" ]; then
-   wine=$wine64
-   wow64=false
-fi
-
-# resolve 32-bit and 64-bit system32 path
-winever=$($wine --version | grep wine)
-if [ -z "$winever" ]; then
-    echo "$wine:"' Not a wine executable. Check your $wine.' >&2
-    exit 1
-fi
-
-# ensure wine placeholder dlls are recreated
-# if they are missing
-$wineboot -u
-
-win64_sys_path=$($wine64 winepath -u 'C:\windows\system32' 2> /dev/null)
-win64_sys_path="${win64_sys_path/$'\r'/}"
-if $wow64; then
-  win32_sys_path=$($wine winepath -u 'C:\windows\system32' 2> /dev/null)
-  win32_sys_path="${win32_sys_path/$'\r'/}"
-fi
-
-if [ -z "$win32_sys_path" ] && [ -z "$win64_sys_path" ]; then
-  echo 'Failed to resolve C:\windows\system32.' >&2
-  exit 1
-fi
-
-# create native dll override
-overrideDll() {
-  $wine reg add 'HKEY_CURRENT_USER\Software\Wine\DllOverrides' /v $1 /d native /f >/dev/null 2>&1
-  if [ $? -ne 0 ]; then
-    echo -e "Failed to add override for $1"
-    exit 1
-  fi
-}
-
-# remove dll override
-restoreDll() {
-  $wine reg delete 'HKEY_CURRENT_USER\Software\Wine\DllOverrides' /v $1 /f > /dev/null 2>&1
-  if [ $? -ne 0 ]; then
-    echo "Failed to remove override for $1"
-  fi
-}
-
-# copy or link dxvk dll, back up original file
-installFile() {
-  dstfile="${1}/${3}.dll"
-  srcfile="${basedir}/${2}/${3}.dll"
-
-  if [ -f "${srcfile}.so" ]; then
-    srcfile="${srcfile}.so"
-  fi
-
-  if ! [ -f "${srcfile}" ]; then
-    echo "${srcfile}: File not found. Skipping." >&2
-    return 1
-  fi
-
-  if [ -n "$1" ]; then
-    if [ -f "${dstfile}" ] || [ -h "${dstfile}" ]; then
-      if ! [ -f "${dstfile}.old" ]; then
-        mv -v "${dstfile}" "${dstfile}.old"
-      else
-        rm -v "${dstfile}"
-      fi
-      $file_cmd "${srcfile}" "${dstfile}"
-    else
-      echo "${dstfile}: File not found in wine prefix" >&2
-      return 1
-    fi
-  fi
-  return 0
-}
-
-# remove dxvk dll, restore original file
-uninstallFile() {
-  dstfile="${1}/${3}.dll"
-  srcfile="${basedir}/${2}/${3}.dll"
-
-  if [ -f "${srcfile}.so" ]; then
-    srcfile="${srcfile}.so"
-  fi
-
-  if ! [ -f "${srcfile}" ]; then
-    echo "${srcfile}: File not found. Skipping." >&2
-    return 1
-  fi
-
-  if ! [ -f "${dstfile}" ] && ! [ -h "${dstfile}" ]; then
-    echo "${dstfile}: File not found. Skipping." >&2
-    return 1
-  fi
-
-  if [ -f "${dstfile}.old" ]; then
-    rm -v "${dstfile}"
-    mv -v "${dstfile}.old" "${dstfile}"
-    return 0
-  else
-    return 1
-  fi
-}
-
-install() {
-  installFile "$win64_sys_path" "$dxvk_lib64" "$1"
-  inst64_ret="$?"
-
-  inst32_ret=-1
-  if $wow64; then
-    installFile "$win32_sys_path" "$dxvk_lib32" "$1"
-    inst32_ret="$?"
-  fi
-
-  if (( ($inst32_ret == 0) || ($inst64_ret == 0) )); then
-    overrideDll "$1"
-  fi
-}
-
-uninstall() {
-  uninstallFile "$win64_sys_path" "$dxvk_lib64" "$1"
-  uninst64_ret="$?"
-
-  uninst32_ret=-1
-  if $wow64; then
-    uninstallFile "$win32_sys_path" "$dxvk_lib32" "$1"
-    uninst32_ret="$?"
-  fi
-
-  if (( ($uninst32_ret == 0) || ($uninst64_ret == 0) )); then
-    restoreDll "$1"
-  fi
-}
-
-# skip dxgi during install if not explicitly
-# enabled, but always try to uninstall it
-if $with_dxgi || [ "$action" == "uninstall" ]; then
-  $action dxgi
-fi
-
-$action d3d9
-$action d3d10core
-$action d3d11

src/d3d10/d3d10_core.cpp

@@ -9,10 +9,14 @@ extern "C" {
   HRESULT __stdcall D3D11CoreCreateDevice(
           IDXGIFactory*       pFactory,
           IDXGIAdapter*       pAdapter,
+          D3D_DRIVER_TYPE     DriverType,
+          HMODULE             Software,
           UINT                Flags,
     const D3D_FEATURE_LEVEL*  pFeatureLevels,
           UINT                FeatureLevels,
-          ID3D11Device**      ppDevice);
+          UINT                SDKVersion,
+          ID3D11Device**      ppDevice,
+          D3D_FEATURE_LEVEL*  pFeatureLevel);
 
 
   DLLEXPORT HRESULT __stdcall D3D10CoreCreateDevice(
@@ -31,8 +35,8 @@ extern "C" {
     if (FAILED(hr))
       return hr;
 
-    hr = D3D11CoreCreateDevice(pFactory, pAdapter,
-      Flags, &FeatureLevel, 1, &d3d11Device);
+    hr = D3D11CoreCreateDevice(pFactory, pAdapter, D3D_DRIVER_TYPE_UNKNOWN,
+      nullptr, Flags, &FeatureLevel, 1, D3D11_SDK_VERSION, &d3d11Device, nullptr);
 
     if (FAILED(hr))
       return hr;

src/d3d10/meson.build

@@ -7,14 +7,17 @@ d3d10_core_src = [
 d3d10_core_ld_args      = []
 d3d10_core_link_depends = []
 
-if platform != 'windows'
+if platform == 'windows'
+  d3d10_d3d11_dep = lib_d3d11
+else
   d3d10_core_ld_args      += [ '-Wl,--version-script', join_paths(meson.current_source_dir(), 'd3d10core.sym') ]
   d3d10_core_link_depends += files('d3d10core.sym')
+  d3d10_d3d11_dep = d3d11_dep
 endif
 
 d3d10_core_dll = shared_library('d3d10core'+dll_ext, d3d10_core_src, d3d10_core_res,
   name_prefix         : dxvk_name_prefix,
-  dependencies        : [ d3d11_dep ],
+  dependencies        : [ d3d10_d3d11_dep ],
   include_directories : dxvk_include_path,
   install             : true,
   vs_module_defs      : 'd3d10core'+def_spec_ext,

src/d3d11/d3d11_blend.cpp

@@ -58,8 +58,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11BlendState::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11BlendState), riid)) {
+      Logger::warn("D3D11BlendState::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_buffer.cpp

@@ -8,10 +8,11 @@ namespace dxvk {
   
   D3D11Buffer::D3D11Buffer(
           D3D11Device*                pDevice,
-    const D3D11_BUFFER_DESC*          pDesc)
+    const D3D11_BUFFER_DESC*          pDesc,
+    const D3D11_ON_12_RESOURCE_INFO*  p11on12Info)
   : D3D11DeviceChild<ID3D11Buffer>(pDevice),
     m_desc        (*pDesc),
-    m_resource    (this),
+    m_resource    (this, pDevice),
     m_d3d10       (this) {
     DxvkBufferCreateInfo info;
     info.flags  = 0;
@@ -83,17 +84,27 @@ namespace dxvk {
         info.access |= VK_ACCESS_HOST_WRITE_BIT;
     }
 
-    if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)) {
+    if (p11on12Info) {
+      m_11on12 = *p11on12Info;
+
+      DxvkBufferImportInfo importInfo;
+      importInfo.buffer = VkBuffer(m_11on12.VulkanHandle);
+      importInfo.offset = m_11on12.VulkanOffset;
+
+      if (m_desc.CPUAccessFlags)
+        m_11on12.Resource->Map(0, nullptr, &importInfo.mapPtr);
+
+      m_buffer = m_parent->GetDXVKDevice()->importBuffer(info, importInfo, GetMemoryFlags());
+      m_mapped = m_buffer->getSliceHandle();
+
+      m_mapMode = DetermineMapMode();
+    } else if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)) {
       // Create the buffer and set the entire buffer slice as mapped,
       // so that we only have to update it when invalidating the buffer
       m_buffer = m_parent->GetDXVKDevice()->createBuffer(info, GetMemoryFlags());
       m_mapped = m_buffer->getSliceHandle();
 
       m_mapMode = DetermineMapMode();
-
-      // For Stream Output buffers we need a counter
-      if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT)
-        m_soCounter = CreateSoCounterBuffer();
     } else {
       m_sparseAllocator = m_parent->GetDXVKDevice()->createSparsePageAllocator();
       m_sparseAllocator->setCapacity(info.size / SparseMemoryPageSize);
@@ -101,11 +112,16 @@ namespace dxvk {
       m_mapped = DxvkBufferSliceHandle();
       m_mapMode = D3D11_COMMON_BUFFER_MAP_MODE_NONE;
     }
+
+    // For Stream Output buffers we need a counter
+    if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT)
+      m_soCounter = CreateSoCounterBuffer();
   }
   
   
   D3D11Buffer::~D3D11Buffer() {
-
+    if (m_desc.CPUAccessFlags && m_11on12.Resource != nullptr)
+      m_11on12.Resource->Unmap(0, nullptr);
   }
   
   
@@ -138,8 +154,11 @@ namespace dxvk {
        return S_OK;
     }
     
-    Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11Buffer), riid)) {
+      Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -238,6 +257,36 @@ namespace dxvk {
   }
 
 
+  HRESULT D3D11Buffer::GetDescFromD3D12(
+          ID3D12Resource*         pResource,
+    const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+          D3D11_BUFFER_DESC*      pBufferDesc) {
+    D3D12_RESOURCE_DESC desc12 = pResource->GetDesc();
+
+    pBufferDesc->ByteWidth = desc12.Width;
+    pBufferDesc->Usage = D3D11_USAGE_DEFAULT;
+    pBufferDesc->BindFlags = D3D11_BIND_SHADER_RESOURCE;
+    pBufferDesc->MiscFlags = 0;
+    pBufferDesc->CPUAccessFlags = 0;
+    pBufferDesc->StructureByteStride = 0;
+
+    if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
+      pBufferDesc->BindFlags |= D3D11_BIND_RENDER_TARGET;
+
+    if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
+      pBufferDesc->BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
+
+    if (pResourceFlags) {
+      pBufferDesc->BindFlags = pResourceFlags->BindFlags;
+      pBufferDesc->MiscFlags |= pResourceFlags->MiscFlags;
+      pBufferDesc->CPUAccessFlags = pResourceFlags->CPUAccessFlags;
+      pBufferDesc->StructureByteStride = pResourceFlags->StructureByteStride;
+    }
+
+    return S_OK;
+  }
+
+
   BOOL D3D11Buffer::CheckFormatFeatureSupport(
           VkFormat              Format,
           VkFormatFeatureFlags2 Features) const {
@@ -290,6 +339,7 @@ namespace dxvk {
                   || (m_parent->GetOptions()->cachedDynamicResources & m_desc.BindFlags);
 
     if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && useCached) {
+      memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
       memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                   |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
     }

src/d3d11/d3d11_buffer.h

@@ -7,6 +7,7 @@
 
 #include "d3d11_device_child.h"
 #include "d3d11_interfaces.h"
+#include "d3d11_on_12.h"
 #include "d3d11_resource.h"
 
 namespace dxvk {
@@ -41,7 +42,9 @@ namespace dxvk {
     
     D3D11Buffer(
             D3D11Device*                pDevice,
-      const D3D11_BUFFER_DESC*          pDesc);
+      const D3D11_BUFFER_DESC*          pDesc,
+      const D3D11_ON_12_RESOURCE_INFO*  p11on12Info);
+
     ~D3D11Buffer();
     
     HRESULT STDMETHODCALLTYPE QueryInterface(
@@ -142,6 +145,14 @@ namespace dxvk {
         : DxvkCsThread::SynchronizeAll;
     }
 
+    /**
+     * \brief Retrieves D3D11on12 resource info
+     * \returns 11on12 resource info
+     */
+    D3D11_ON_12_RESOURCE_INFO Get11on12Info() const {
+      return m_11on12;
+    }
+
     /**
      * \brief Normalizes buffer description
      * 
@@ -151,9 +162,23 @@ namespace dxvk {
     static HRESULT NormalizeBufferProperties(
             D3D11_BUFFER_DESC*      pDesc);
 
+    /**
+     * \brief Initializes D3D11 buffer description from D3D12
+     *
+     * \param [in] pResource D3D12 resource
+     * \param [in] pResourceFlags D3D11 flag overrides
+     * \param [out] pBufferDesc D3D11 buffer description
+     * \returns \c S_OK if the parameters are valid
+     */
+    static HRESULT GetDescFromD3D12(
+            ID3D12Resource*         pResource,
+      const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+            D3D11_BUFFER_DESC*      pBufferDesc);
+
   private:
     
     D3D11_BUFFER_DESC             m_desc;
+    D3D11_ON_12_RESOURCE_INFO     m_11on12;
     D3D11_COMMON_BUFFER_MAP_MODE  m_mapMode;
     
     Rc<DxvkBuffer>                m_buffer;

src/d3d11/d3d11_class_linkage.cpp

@@ -28,8 +28,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11ClassLinkage::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11ClassLinkage), riid)) {
+      Logger::warn("D3D11ClassLinkage::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_cmdlist.cpp

@@ -30,8 +30,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11CommandList::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11CommandList), riid)) {
+      Logger::warn("D3D11CommandList::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -41,54 +44,79 @@ namespace dxvk {
   }
   
   
-  void D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) {
-    m_chunks.push_back(std::move(Chunk));
-  }
-  
-  
   void D3D11CommandList::AddQuery(D3D11Query* pQuery) {
     m_queries.emplace_back(pQuery);
   }
 
 
-  void D3D11CommandList::EmitToCommandList(ID3D11CommandList* pCommandList) {
-    auto cmdList = static_cast<D3D11CommandList*>(pCommandList);
-    
-    for (const auto& chunk : m_chunks)
-      cmdList->m_chunks.push_back(chunk);
-
-    for (const auto& query : m_queries)
-      cmdList->m_queries.push_back(query);
-
-    for (const auto& resource : m_resources)
-      cmdList->m_resources.push_back(resource);
-
-    MarkSubmitted();
+  uint64_t D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) {
+    m_chunks.push_back(std::move(Chunk));
+    return m_chunks.size() - 1;
   }
   
   
-  uint64_t D3D11CommandList::EmitToCsThread(DxvkCsThread* CsThread) {
-    uint64_t seq = 0;
+  uint64_t D3D11CommandList::AddCommandList(
+          D3D11CommandList*   pCommandList) {
+    // This will be the chunk ID of the first chunk
+    // added, for the purpose of resource tracking.
+    uint64_t baseChunkId = m_chunks.size();
+    
+    for (const auto& chunk : pCommandList->m_chunks)
+      m_chunks.push_back(chunk);
 
+    for (const auto& query : pCommandList->m_queries)
+      m_queries.push_back(query);
+
+    for (const auto& resource : pCommandList->m_resources) {
+      TrackedResource entry = resource;
+      entry.chunkId += baseChunkId;
+
+      m_resources.push_back(std::move(entry));
+    }
+
+    pCommandList->MarkSubmitted();
+
+    // Return ID of the last chunk added. The command list
+    // added can never be empty, so do not handle zero.
+    return m_chunks.size() - 1;
+  }
+
+
+  void D3D11CommandList::EmitToCsThread(
+    const D3D11ChunkDispatchProc& DispatchProc) {
     for (const auto& query : m_queries)
       query->DoDeferredEnd();
 
-    for (const auto& chunk : m_chunks)
-      seq = CsThread->dispatchChunk(DxvkCsChunkRef(chunk));
-    
-    for (const auto& resource : m_resources)
-      TrackResourceSequenceNumber(resource, seq);
+    for (size_t i = 0, j = 0; i < m_chunks.size(); i++) {
+      // If there are resources to track for the current chunk,
+      // use a strong flush hint to dispatch GPU work quickly.
+      GpuFlushType flushType = GpuFlushType::ImplicitWeakHint;
+
+      if (j < m_resources.size() && m_resources[j].chunkId == i)
+        flushType = GpuFlushType::ImplicitStrongHint;
+
+      // Dispatch the chunk and capture its sequence number
+      uint64_t seq = DispatchProc(DxvkCsChunkRef(m_chunks[i]), flushType);
+
+      // Track resource sequence numbers for the added chunk
+      while (j < m_resources.size() && m_resources[j].chunkId == i)
+        TrackResourceSequenceNumber(m_resources[j++].ref, seq);
+    }
 
     MarkSubmitted();
-    return seq;
   }
   
   
   void D3D11CommandList::TrackResourceUsage(
           ID3D11Resource*     pResource,
           D3D11_RESOURCE_DIMENSION ResourceType,
-          UINT                Subresource) {
-    m_resources.emplace_back(pResource, Subresource, ResourceType);
+          UINT                Subresource,
+          uint64_t            ChunkId) {
+    TrackedResource entry;
+    entry.ref = D3D11ResourceRef(pResource, Subresource, ResourceType);
+    entry.chunkId = ChunkId;
+
+    m_resources.push_back(std::move(entry));
   }
 
 
@@ -96,7 +124,6 @@ namespace dxvk {
     const D3D11ResourceRef&   Resource,
           uint64_t            Seq) {
     ID3D11Resource* iface = Resource.Get();
-    UINT subresource = Resource.GetSubresource();
 
     switch (Resource.GetType()) {
       case D3D11_RESOURCE_DIMENSION_UNKNOWN:
@@ -109,17 +136,17 @@ namespace dxvk {
 
       case D3D11_RESOURCE_DIMENSION_TEXTURE1D: {
         auto impl = static_cast<D3D11Texture1D*>(iface)->GetCommonTexture();
-        impl->TrackSequenceNumber(subresource, Seq);
+        impl->TrackSequenceNumber(Resource.GetSubresource(), Seq);
       } break;
 
       case D3D11_RESOURCE_DIMENSION_TEXTURE2D: {
         auto impl = static_cast<D3D11Texture2D*>(iface)->GetCommonTexture();
-        impl->TrackSequenceNumber(subresource, Seq);
+        impl->TrackSequenceNumber(Resource.GetSubresource(), Seq);
       } break;
 
       case D3D11_RESOURCE_DIMENSION_TEXTURE3D: {
         auto impl = static_cast<D3D11Texture3D*>(iface)->GetCommonTexture();
-        impl->TrackSequenceNumber(subresource, Seq);
+        impl->TrackSequenceNumber(Resource.GetSubresource(), Seq);
       } break;
     }
   }

src/d3d11/d3d11_cmdlist.h

@@ -1,9 +1,13 @@
 #pragma once
 
+#include <functional>
+
 #include "d3d11_context.h"
 
 namespace dxvk {
   
+  using D3D11ChunkDispatchProc = std::function<uint64_t (DxvkCsChunkRef&&, GpuFlushType)>;
+
   class D3D11CommandList : public D3D11DeviceChild<ID3D11CommandList> {
     
   public:
@@ -20,30 +24,36 @@ namespace dxvk {
     
     UINT STDMETHODCALLTYPE GetContextFlags() final;
     
-    void AddChunk(
-            DxvkCsChunkRef&&    Chunk);
-
     void AddQuery(
             D3D11Query*         pQuery);
     
-    void EmitToCommandList(
-            ID3D11CommandList*  pCommandList);
-    
-    uint64_t EmitToCsThread(
-            DxvkCsThread*       CsThread);
+    uint64_t AddChunk(
+            DxvkCsChunkRef&&    Chunk);
+
+    uint64_t AddCommandList(
+            D3D11CommandList*   pCommandList);
+
+    void EmitToCsThread(
+      const D3D11ChunkDispatchProc& DispatchProc);
 
     void TrackResourceUsage(
             ID3D11Resource*     pResource,
             D3D11_RESOURCE_DIMENSION ResourceType,
-            UINT                Subresource);
+            UINT                Subresource,
+            uint64_t            ChunkId);
 
   private:
 
-    UINT         const m_contextFlags;
+    struct TrackedResource {
+      D3D11ResourceRef  ref;
+      uint64_t          chunkId;
+    };
+
+    UINT m_contextFlags;
     
     std::vector<DxvkCsChunkRef>         m_chunks;
     std::vector<Com<D3D11Query, false>> m_queries;
-    std::vector<D3D11ResourceRef>       m_resources;
+    std::vector<TrackedResource>        m_resources;
 
     std::atomic<bool> m_submitted = { false };
     std::atomic<bool> m_warned    = { false };

src/d3d11/d3d11_context.cpp

@@ -61,8 +61,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11DeviceContext::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11DeviceContext), riid)) {
+      Logger::warn("D3D11DeviceContext::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -329,13 +332,14 @@ namespace dxvk {
     if (!buf || !uav)
       return;
 
-    auto counterSlice = uav->GetCounterSlice();
-    if (!counterSlice.defined())
+    auto counterView = uav->GetCounterView();
+
+    if (counterView == nullptr)
       return;
 
     EmitCs([
       cDstSlice = buf->GetBufferSlice(DstAlignedByteOffset),
-      cSrcSlice = std::move(counterSlice)
+      cSrcSlice = counterView->slice()
     ] (DxvkContext* ctx) {
       ctx->copyBuffer(
         cDstSlice.buffer(),
@@ -382,11 +386,16 @@ namespace dxvk {
     const UINT                              Values[4]) {
     D3D10DeviceLock lock = LockContext();
 
-    auto uav = static_cast<D3D11UnorderedAccessView*>(pUnorderedAccessView);
-
-    if (!uav)
+    if (!pUnorderedAccessView)
       return;
 
+    Com<ID3D11UnorderedAccessView> qiUav;
+
+    if (FAILED(pUnorderedAccessView->QueryInterface(IID_PPV_ARGS(&qiUav))))
+      return;
+
+    auto uav = static_cast<D3D11UnorderedAccessView*>(qiUav.ptr());
+
     // Gather UAV format info. We'll use this to determine
     // whether we need to create a temporary view or not.
     D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
@@ -402,15 +411,22 @@ namespace dxvk {
 
     VkClearValue clearValue;
 
-    // R11G11B10 is a special case since there's no corresponding
-    // integer format with the same bit layout. Use R32 instead.
-    if (uavFormat == VK_FORMAT_B10G11R11_UFLOAT_PACK32) {
+    if (uavDesc.Format == DXGI_FORMAT_R11G11B10_FLOAT) {
+      // R11G11B10 is a special case since there's no corresponding
+      // integer format with the same bit layout. Use R32 instead.
       clearValue.color.uint32[0] = ((Values[0] & 0x7FF) <<  0)
                                  | ((Values[1] & 0x7FF) << 11)
                                  | ((Values[2] & 0x3FF) << 22);
       clearValue.color.uint32[1] = 0;
       clearValue.color.uint32[2] = 0;
       clearValue.color.uint32[3] = 0;
+    } else if (uavDesc.Format == DXGI_FORMAT_A8_UNORM) {
+      // We need to use R8_UINT to clear A8_UNORM images,
+      // so remap the alpha component to the red channel.
+      clearValue.color.uint32[0] = Values[3];
+      clearValue.color.uint32[1] = 0;
+      clearValue.color.uint32[2] = 0;
+      clearValue.color.uint32[3] = 0;
     } else {
       clearValue.color.uint32[0] = Values[0];
       clearValue.color.uint32[1] = Values[1];
@@ -912,6 +928,34 @@ namespace dxvk {
     const void*                             pSrcData,
           UINT                              SrcRowPitch,
           UINT                              SrcDepthPitch) {
+    if (IsDeferred && unlikely(pDstBox != nullptr) && unlikely(!m_parent->GetOptions()->exposeDriverCommandLists)) {
+      // If called from a deferred context and native command list support is not
+      // exposed, we need to apply the destination box to the source pointer. This
+      // only applies to UpdateSubresource, not to UpdateSubresource1. See MSDN:
+      // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476486(v=vs.85).aspx)
+      size_t srcOffset = pDstBox->left;
+
+      // For textures, the offset logic needs to take the format into account.
+      // Ignore that multi-planar images exist, this is hairy enough already.
+      D3D11CommonTexture* dstTexture = GetCommonTexture(pDstResource);
+
+      if (dstTexture) {
+        auto dstFormat = dstTexture->GetPackedFormat();
+        auto dstFormatInfo = lookupFormatInfo(dstFormat);
+
+        size_t blockSize = dstFormatInfo->elementSize;
+
+        VkOffset3D offset;
+        offset.x = pDstBox->left / dstFormatInfo->blockSize.width;
+        offset.y = pDstBox->top / dstFormatInfo->blockSize.height;
+        offset.z = pDstBox->front / dstFormatInfo->blockSize.depth;
+
+        srcOffset = offset.x * blockSize + offset.y * SrcRowPitch + offset.z * SrcDepthPitch;
+      }
+
+      pSrcData = reinterpret_cast<const char*>(pSrcData) + srcOffset;
+    }
+
     UpdateResource(pDstResource, DstSubresource, pDstBox,
       pSrcData, SrcRowPitch, SrcDepthPitch, 0);
   }
@@ -2193,9 +2237,6 @@ namespace dxvk {
           ID3D11DepthStencilView*           pDepthStencilView) {
     D3D10DeviceLock lock = LockContext();
 
-    if constexpr (!IsDeferred)
-      GetTypedContext()->FlushImplicit(true);
-
     SetRenderTargetsAndUnorderedAccessViews(
       NumViews, ppRenderTargetViews, pDepthStencilView,
       NumViews, 0, nullptr, nullptr);
@@ -2213,9 +2254,6 @@ namespace dxvk {
     const UINT*                             pUAVInitialCounts) {
     D3D10DeviceLock lock = LockContext();
 
-    if constexpr (!IsDeferred)
-      GetTypedContext()->FlushImplicit(true);
-
     SetRenderTargetsAndUnorderedAccessViews(
       NumRTVs, ppRenderTargetViews, pDepthStencilView,
       UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts);
@@ -2261,6 +2299,10 @@ namespace dxvk {
       ApplyDepthStencilState();
     }
 
+    // The D3D11 runtime only appears to store the low 8 bits,
+    // and some games rely on this behaviour. Do the same here.
+    StencilRef &= 0xFF;
+
     if (m_state.om.stencilRef != StencilRef) {
       m_state.om.stencilRef = StencilRef;
       ApplyStencilRef();
@@ -2628,6 +2670,8 @@ namespace dxvk {
           ID3D11Buffer*                     pBuffer,
           UINT64                            BufferStartOffsetInBytes,
           UINT                              Flags) {
+    D3D10DeviceLock lock = LockContext();
+
     if (!pTiledResource || !pBuffer)
       return;
 
@@ -2658,11 +2702,13 @@ namespace dxvk {
     const D3D11_TILED_RESOURCE_COORDINATE*  pSourceRegionCoordinate,
     const D3D11_TILE_REGION_SIZE*           pTileRegionSize,
           UINT                              Flags) {
+    D3D10DeviceLock lock = LockContext();
+
     if (!pDestTiledResource || !pSourceTiledResource)
       return E_INVALIDARG;
 
     if constexpr (!IsDeferred)
-      GetTypedContext()->FlushImplicit(false);
+      GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint);
 
     DxvkSparseBindInfo bindInfo;
     bindInfo.dstResource = GetPagedResource(pDestTiledResource);
@@ -2736,6 +2782,8 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11CommonContext<ContextType>::ResizeTilePool(
           ID3D11Buffer*                     pTilePool,
           UINT64                            NewSizeInBytes) {
+    D3D10DeviceLock lock = LockContext();
+
     if (NewSizeInBytes % SparseMemoryPageSize)
       return E_INVALIDARG;
 
@@ -2761,6 +2809,8 @@ namespace dxvk {
   void STDMETHODCALLTYPE D3D11CommonContext<ContextType>::TiledResourceBarrier(
           ID3D11DeviceChild*                pTiledResourceOrViewAccessBeforeBarrier,
           ID3D11DeviceChild*                pTiledResourceOrViewAccessAfterBarrier) {
+    D3D10DeviceLock lock = LockContext();
+
     DxvkGlobalPipelineBarrier srcBarrier = GetTiledResourceDependency(pTiledResourceOrViewAccessBeforeBarrier);
     DxvkGlobalPipelineBarrier dstBarrier = GetTiledResourceDependency(pTiledResourceOrViewAccessAfterBarrier);
 
@@ -2789,11 +2839,13 @@ namespace dxvk {
     const UINT*                             pRangeTileOffsets,
     const UINT*                             pRangeTileCounts,
           UINT                              Flags) {
+    D3D10DeviceLock lock = LockContext();
+
     if (!pTiledResource || !NumRegions || !NumRanges)
       return E_INVALIDARG;
 
     if constexpr (!IsDeferred)
-      GetTypedContext()->FlushImplicit(false);
+      GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint);
 
     // Find sparse allocator if the tile pool is defined
     DxvkSparseBindInfo bindInfo;
@@ -2942,6 +2994,8 @@ namespace dxvk {
     const D3D11_TILE_REGION_SIZE*           pDestTileRegionSize,
     const void*                             pSourceTileData,
           UINT                              Flags) {
+    D3D10DeviceLock lock = LockContext();
+
     if (!pDestTiledResource || !pSourceTileData)
       return;
 
@@ -3358,7 +3412,7 @@ namespace dxvk {
 
         ctx->bindShader<stage>(
           Forwarder::move(cShader));
-        ctx->bindResourceBuffer(stage, slotId,
+        ctx->bindUniformBuffer(stage, slotId,
           Forwarder::move(cBuffer));
       });
     } else {
@@ -3369,14 +3423,30 @@ namespace dxvk {
           D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT);
 
         ctx->bindShader<stage>(nullptr);
-        ctx->bindResourceBuffer(stage, slotId, DxvkBufferSlice());
+        ctx->bindUniformBuffer(stage, slotId, DxvkBufferSlice());
       });
     }
   }
 
 
+  static VkDepthBiasRepresentationEXT FormatToDepthBiasRepresentation(DXGI_FORMAT format) {
+    switch (format) {
+      default:
+      case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+      case DXGI_FORMAT_D32_FLOAT:
+        return VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT;
+
+      case DXGI_FORMAT_D24_UNORM_S8_UINT:
+      case DXGI_FORMAT_D16_UNORM:
+        return VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT;
+    }
+  }
+
   template<typename ContextType>
   void D3D11CommonContext<ContextType>::BindFramebuffer() {
+    DxvkDepthBiasRepresentation depthBiasRepresentation =
+      { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT,
+        m_device->features().extDepthBiasControl.depthBiasExact };
     DxvkRenderTargets attachments;
     uint32_t sampleCount = 0;
 
@@ -3397,12 +3467,17 @@ namespace dxvk {
         m_state.om.dsv->GetImageView(),
         m_state.om.dsv->GetRenderLayout() };
       sampleCount = m_state.om.dsv->GetSampleCount();
+
+      if (m_device->features().extDepthBiasControl.leastRepresentableValueForceUnormRepresentation)
+        depthBiasRepresentation.depthBiasRepresentation = FormatToDepthBiasRepresentation(m_state.om.dsv->GetViewFormat());
     }
 
     // Create and bind the framebuffer object to the context
     EmitCs([
-      cAttachments = std::move(attachments)
+      cAttachments    = std::move(attachments),
+      cRepresentation = depthBiasRepresentation
     ] (DxvkContext* ctx) mutable {
+      ctx->setDepthBiasRepresentation(cRepresentation);
       ctx->bindRenderTargets(Forwarder::move(cAttachments), 0u);
     });
 
@@ -3581,7 +3656,7 @@ namespace dxvk {
         cBufferSlice = pBuffer->GetBufferSlice(16 * Offset, 16 * Length)
       ] (DxvkContext* ctx) mutable {
         VkShaderStageFlagBits stage = GetShaderStage(ShaderStage);
-        ctx->bindResourceBuffer(stage, cSlotId,
+        ctx->bindUniformBuffer(stage, cSlotId,
           Forwarder::move(cBufferSlice));
       });
     } else {
@@ -3589,7 +3664,7 @@ namespace dxvk {
         cSlotId      = Slot
       ] (DxvkContext* ctx) {
         VkShaderStageFlagBits stage = GetShaderStage(ShaderStage);
-        ctx->bindResourceBuffer(stage, cSlotId, DxvkBufferSlice());
+        ctx->bindUniformBuffer(stage, cSlotId, DxvkBufferSlice());
       });
     }
   }
@@ -3607,7 +3682,7 @@ namespace dxvk {
       cLength       = 16 * Length
     ] (DxvkContext* ctx) {
       VkShaderStageFlagBits stage = GetShaderStage(ShaderStage);
-      ctx->bindResourceBufferRange(stage, cSlotId, cOffset, cLength);
+      ctx->bindUniformBufferRange(stage, cSlotId, cOffset, cLength);
     });
   }
 
@@ -3686,25 +3761,27 @@ namespace dxvk {
           cUavSlotId    = UavSlot,
           cCtrSlotId    = CtrSlot,
           cBufferView   = pUav->GetBufferView(),
-          cCounterSlice = pUav->GetCounterSlice(),
+          cCounterView  = pUav->GetCounterView(),
           cCounterValue = Counter
         ] (DxvkContext* ctx) mutable {
           VkShaderStageFlags stages = ShaderStage == DxbcProgramType::ComputeShader
             ? VK_SHADER_STAGE_COMPUTE_BIT
             : VK_SHADER_STAGE_ALL_GRAPHICS;
 
-          if (cCounterSlice.defined() && cCounterValue != ~0u) {
+          if (cCounterView != nullptr && cCounterValue != ~0u) {
+            auto counterSlice = cCounterView->slice();
+
             ctx->updateBuffer(
-              cCounterSlice.buffer(),
-              cCounterSlice.offset(),
+              counterSlice.buffer(),
+              counterSlice.offset(),
               sizeof(uint32_t),
               &cCounterValue);
           }
 
           ctx->bindResourceBufferView(stages, cUavSlotId,
             Forwarder::move(cBufferView));
-          ctx->bindResourceBuffer(stages, cCtrSlotId,
-            Forwarder::move(cCounterSlice));
+          ctx->bindResourceBufferView(stages, cCtrSlotId,
+            Forwarder::move(cCounterView));
         });
       } else {
         EmitCs([
@@ -3718,7 +3795,7 @@ namespace dxvk {
 
           ctx->bindResourceImageView(stages, cUavSlotId,
             Forwarder::move(cImageView));
-          ctx->bindResourceBuffer(stages, cCtrSlotId, DxvkBufferSlice());
+          ctx->bindResourceBufferView(stages, cCtrSlotId, nullptr);
         });
       }
     } else {
@@ -3731,7 +3808,7 @@ namespace dxvk {
           : VK_SHADER_STAGE_ALL_GRAPHICS;
 
         ctx->bindResourceImageView(stages, cUavSlotId, nullptr);
-        ctx->bindResourceBuffer(stages, cCtrSlotId, DxvkBufferSlice());
+        ctx->bindResourceBufferView(stages, cCtrSlotId, nullptr);
       });
     }
   }
@@ -4371,10 +4448,10 @@ namespace dxvk {
 
         // Unbind constant buffers, including the shader's ICB
         auto cbSlotId = computeConstantBufferBinding(programType, 0);
-        ctx->bindResourceBuffer(stage, cbSlotId + D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, DxvkBufferSlice());
+        ctx->bindUniformBuffer(stage, cbSlotId + D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, DxvkBufferSlice());
 
         for (uint32_t j = 0; j < cUsedBindings.stages[i].cbvCount; j++)
-          ctx->bindResourceBuffer(stage, cbSlotId + j, DxvkBufferSlice());
+          ctx->bindUniformBuffer(stage, cbSlotId + j, DxvkBufferSlice());
 
         // Unbind shader resource views
         auto srvSlotId = computeSrvBinding(programType, 0);
@@ -4400,7 +4477,7 @@ namespace dxvk {
 
           for (uint32_t j = 0; j < cUsedBindings.stages[i].uavCount; j++) {
             ctx->bindResourceImageView(stages, uavSlotId, nullptr);
-            ctx->bindResourceBuffer(stages, ctrSlotId, DxvkBufferSlice());
+            ctx->bindResourceBufferView(stages, ctrSlotId, nullptr);
           }
         }
       }
@@ -4902,8 +4979,14 @@ namespace dxvk {
       }
     }
 
-    if (needsUpdate)
+    if (needsUpdate) {
       BindFramebuffer();
+
+      if constexpr (!IsDeferred) {
+        // Doing this makes it less likely to flush during render passes
+        GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint);
+      }
+    }
   }
 
 
@@ -5358,6 +5441,7 @@ namespace dxvk {
     pRsState->conservativeMode = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT;
     pRsState->sampleCount     = 0;
     pRsState->flatShading     = VK_FALSE;
+    pRsState->lineMode        = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
   }
 
 

src/d3d11/d3d11_context.h

@@ -10,6 +10,8 @@
 
 #include "../d3d10/d3d10_multithread.h"
 
+#include "../util/util_flush.h"
+
 #include "d3d11_annotation.h"
 #include "d3d11_buffer.h"
 #include "d3d11_cmd.h"
@@ -1064,27 +1066,35 @@ namespace dxvk {
             DxvkMultisampleState*             pMsState,
             UINT                              SampleMask);
 
-    template<typename Cmd>
+    template<bool AllowFlush = !IsDeferred, typename Cmd>
     void EmitCs(Cmd&& command) {
       m_cmdData = nullptr;
 
       if (unlikely(!m_csChunk->push(command))) {
         GetTypedContext()->EmitCsChunk(std::move(m_csChunk));
-        
         m_csChunk = AllocCsChunk();
+
+        if constexpr (AllowFlush)
+          GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint);
+
         m_csChunk->push(command);
       }
     }
 
-    template<typename M, typename Cmd, typename... Args>
+    template<typename M, bool AllowFlush = !IsDeferred, typename Cmd, typename... Args>
     M* EmitCsCmd(Cmd&& command, Args&&... args) {
       M* data = m_csChunk->pushCmd<M, Cmd, Args...>(
         command, std::forward<Args>(args)...);
 
       if (unlikely(!data)) {
         GetTypedContext()->EmitCsChunk(std::move(m_csChunk));
-        
         m_csChunk = AllocCsChunk();
+
+        if constexpr (AllowFlush)
+          GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint);
+
+        // We must record this command after the potential
+        // flush since the caller may still access the data
         data = m_csChunk->pushCmd<M, Cmd, Args...>(
           command, std::forward<Args>(args)...);
       }
@@ -1120,7 +1130,7 @@ namespace dxvk {
       if (likely(pBuffer != nullptr))
         bufferSize = static_cast<D3D11Buffer*>(pBuffer)->Desc()->ByteWidth;
 
-      return bufferSize >= Offset + Size;
+      return uint64_t(bufferSize) >= uint64_t(Offset) + uint64_t(Size);
     }
 
   private:

src/d3d11/d3d11_context_def.cpp

@@ -148,8 +148,9 @@ namespace dxvk {
     // Record any chunks from the given command list into the
     // current command list and deal with context state
     auto commandList = static_cast<D3D11CommandList*>(pCommandList);
-    commandList->EmitToCommandList(m_commandList.ptr());
+    m_chunkId = m_commandList->AddCommandList(commandList);
     
+    // Restore deferred context state
     if (RestoreContextState)
       RestoreCommandListState();
     else
@@ -166,7 +167,8 @@ namespace dxvk {
     FinalizeQueries();
 
     // Clean up command list state so that the any state changed
-    // by this command list does not affect the calling context
+    // by this command list does not affect the calling context.
+    // This also ensures that the command list is never empty.
     ResetCommandListState();
 
     // Make sure all commands are visible to the command list
@@ -180,6 +182,7 @@ namespace dxvk {
     // Any use of ExecuteCommandList will reset command list state
     // before the command list is actually executed.
     m_commandList = CreateCommandList();
+    m_chunkId = 0;
     
     if (RestoreDeferredContextState)
       RestoreCommandListState();
@@ -388,7 +391,12 @@ namespace dxvk {
   
   
   void D3D11DeferredContext::EmitCsChunk(DxvkCsChunkRef&& chunk) {
-    m_commandList->AddChunk(std::move(chunk));
+    m_chunkId = m_commandList->AddChunk(std::move(chunk));
+  }
+
+
+  uint64_t D3D11DeferredContext::GetCurrentChunkId() const {
+    return m_csChunk->empty() ? m_chunkId : m_chunkId + 1;
   }
 
 
@@ -398,14 +406,15 @@ namespace dxvk {
     m_commandList->TrackResourceUsage(
       pResource->GetInterface(),
       pResource->GetDimension(),
-      Subresource);
+      Subresource, GetCurrentChunkId());
   }
 
 
   void D3D11DeferredContext::TrackBufferSequenceNumber(
           D3D11Buffer*                pResource) {
-    m_commandList->TrackResourceUsage(
-      pResource, D3D11_RESOURCE_DIMENSION_BUFFER, 0);
+    m_commandList->TrackResourceUsage(pResource,
+      D3D11_RESOURCE_DIMENSION_BUFFER, 0,
+      GetCurrentChunkId());
   }
 
 

src/d3d11/d3d11_context_def.h

@@ -96,6 +96,9 @@ namespace dxvk {
     // Begun and ended queries, will also be stored in command list
     std::vector<Com<D3D11Query, false>> m_queriesBegun;
 
+    // Chunk ID within the current command list
+    uint64_t m_chunkId = 0ull;
+
     HRESULT MapBuffer(
             ID3D11Resource*               pResource,
             D3D11_MAPPED_SUBRESOURCE*     pMappedResource);
@@ -118,6 +121,8 @@ namespace dxvk {
     
     void EmitCsChunk(DxvkCsChunkRef&& chunk);
 
+    uint64_t GetCurrentChunkId() const;
+
     void TrackTextureSequenceNumber(
             D3D11CommonTexture*           pResource,
             UINT                          Subresource);

src/d3d11/d3d11_context_imm.cpp

@@ -18,6 +18,7 @@ namespace dxvk {
   : D3D11CommonContext<D3D11ImmediateContext>(pParent, Device, 0, DxvkCsChunkFlag::SingleUse),
     m_csThread(Device, Device->createContext(DxvkContextType::Primary)),
     m_maxImplicitDiscardSize(pParent->GetOptions()->maxImplicitDiscardSize),
+    m_submissionFence(new sync::CallbackFence()),
     m_multithread(this, false, pParent->GetOptions()->enableContextLock),
     m_videoContext(this, Device) {
     EmitCs([
@@ -48,7 +49,7 @@ namespace dxvk {
     if (this_thread::isInModuleDetachment())
       return;
 
-    Flush();
+    ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true);
     SynchronizeCsThread(DxvkCsThread::SynchronizeAll);
     SynchronizeDevice();
   }
@@ -99,7 +100,8 @@ namespace dxvk {
 
       // Ignore the DONOTFLUSH flag here as some games will spin
       // on queries without ever flushing the context otherwise.
-      FlushImplicit(FALSE);
+      D3D10DeviceLock lock = LockContext();
+      ConsiderFlush(GpuFlushType::ImplicitSynchronization);
     }
     
     return hr;
@@ -148,47 +150,33 @@ namespace dxvk {
       query->NotifyEnd();
 
       if (query->IsStalling())
-        Flush();
+        ExecuteFlush(GpuFlushType::ImplicitSynchronization, nullptr, false);
       else if (query->IsEvent())
-        FlushImplicit(TRUE);
+        ConsiderFlush(GpuFlushType::ImplicitStrongHint);
     }
   }
 
 
   void STDMETHODCALLTYPE D3D11ImmediateContext::Flush() {
-    Flush1(D3D11_CONTEXT_TYPE_ALL, nullptr);
+    D3D10DeviceLock lock = LockContext();
+
+    ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true);
   }
 
 
   void STDMETHODCALLTYPE D3D11ImmediateContext::Flush1(
           D3D11_CONTEXT_TYPE          ContextType,
           HANDLE                      hEvent) {
-    m_parent->FlushInitContext();
-
-    if (hEvent)
-      SignalEvent(hEvent);
-    
     D3D10DeviceLock lock = LockContext();
-    
-    if (m_csIsBusy || !m_csChunk->empty()) {
-      // Add commands to flush the threaded
-      // context, then flush the command list
-      EmitCs([] (DxvkContext* ctx) {
-        ctx->flushCommandList();
-      });
-      
-      FlushCsChunk();
-      
-      // Reset flush timer used for implicit flushes
-      m_lastFlush = dxvk::high_resolution_clock::now();
-      m_csIsBusy  = false;
-    }
+
+    ExecuteFlush(GpuFlushType::ExplicitFlush, hEvent, true);
   }
   
   
   HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::Signal(
           ID3D11Fence*                pFence,
           UINT64                      Value) {
+    D3D10DeviceLock lock = LockContext();
     auto fence = static_cast<D3D11Fence*>(pFence);
 
     if (!fence)
@@ -201,7 +189,7 @@ namespace dxvk {
       ctx->signalFence(cFence, cValue);
     });
 
-    Flush();
+    ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true);
     return S_OK;
   }
 
@@ -209,12 +197,13 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::Wait(
           ID3D11Fence*                pFence,
           UINT64                      Value) {
+    D3D10DeviceLock lock = LockContext();
     auto fence = static_cast<D3D11Fence*>(pFence);
 
     if (!fence)
       return E_INVALIDARG;
 
-    Flush();
+    ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true);
 
     EmitCs([
       cFence = fence->GetFence(),
@@ -246,21 +235,27 @@ namespace dxvk {
     
     // As an optimization, flush everything if the
     // number of pending draw calls is high enough.
-    FlushImplicit(FALSE);
-    
-    // Dispatch command list to the CS thread and
-    // restore the immediate context's state
-    uint64_t csSeqNum = commandList->EmitToCsThread(&m_csThread);
-    m_csSeqNum = std::max(m_csSeqNum, csSeqNum);
-    
+    ConsiderFlush(GpuFlushType::ImplicitWeakHint);
+
+    // Dispatch command list to the CS thread
+    commandList->EmitToCsThread([this] (DxvkCsChunkRef&& chunk, GpuFlushType flushType) {
+      EmitCsChunk(std::move(chunk));
+
+      // Return the sequence number from before the flush since
+      // that is actually going to be needed for resource tracking
+      uint64_t csSeqNum = m_csSeqNum;
+
+      // Consider a flush after every chunk in case the app
+      // submits a very large command list or the GPU is idle
+      ConsiderFlush(flushType);
+      return csSeqNum;
+    });
+
+    // Restore the immediate context's state
     if (RestoreContextState)
       RestoreCommandListState();
     else
       ResetContextState();
-    
-    // Mark CS thread as busy so that subsequent
-    // flush operations get executed correctly.
-    m_csIsBusy = true;
   }
   
   
@@ -390,8 +385,6 @@ namespace dxvk {
       }
 
       if (doInvalidatePreserve) {
-        FlushImplicit(TRUE);
-
         auto prevSlice = pResource->GetMappedSlice();
         auto physSlice = pResource->DiscardSlice();
 
@@ -537,8 +530,6 @@ namespace dxvk {
       }
 
       if (doFlags & DoInvalidate) {
-        FlushImplicit(TRUE);
-
         DxvkBufferSliceHandle prevSlice = pResource->GetMappedSlice(Subresource);
         DxvkBufferSliceHandle physSlice = pResource->DiscardSlice(Subresource);
 
@@ -762,6 +753,74 @@ namespace dxvk {
   }
 
 
+  void D3D11ImmediateContext::Acquire11on12Resource(
+          ID3D11Resource*             pResource,
+          VkImageLayout               SrcLayout) {
+    D3D10DeviceLock lock = LockContext();
+
+    auto texture = GetCommonTexture(pResource);
+    auto buffer = GetCommonBuffer(pResource);
+
+    if (buffer) {
+      EmitCs([
+        cBuffer   = buffer->GetBuffer()
+      ] (DxvkContext* ctx) {
+        ctx->emitBufferBarrier(cBuffer,
+          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+          VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT,
+          cBuffer->info().stages,
+          cBuffer->info().access);
+      });
+    } else if (texture) {
+      EmitCs([
+        cImage    = texture->GetImage(),
+        cLayout   = SrcLayout
+      ] (DxvkContext* ctx) {
+        ctx->emitImageBarrier(cImage, cLayout,
+          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+          VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT,
+          cImage->info().layout,
+          cImage->info().stages,
+          cImage->info().access);
+      });
+    }
+  }
+
+
+  void D3D11ImmediateContext::Release11on12Resource(
+          ID3D11Resource*             pResource,
+          VkImageLayout               DstLayout) {
+    D3D10DeviceLock lock = LockContext();
+
+    auto texture = GetCommonTexture(pResource);
+    auto buffer = GetCommonBuffer(pResource);
+
+    if (buffer) {
+      EmitCs([
+        cBuffer   = buffer->GetBuffer()
+      ] (DxvkContext* ctx) {
+        ctx->emitBufferBarrier(cBuffer,
+          cBuffer->info().stages,
+          cBuffer->info().access,
+          VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+          VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT);
+      });
+    } else if (texture) {
+      EmitCs([
+        cImage    = texture->GetImage(),
+        cLayout   = DstLayout
+      ] (DxvkContext* ctx) {
+        ctx->emitImageBarrier(cImage,
+          cImage->info().layout,
+          cImage->info().stages,
+          cImage->info().access,
+          cLayout, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+          VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT);
+      });
+    }
+  }
+
+
   void D3D11ImmediateContext::SynchronizeCsThread(uint64_t SequenceNumber) {
     D3D10DeviceLock lock = LockContext();
 
@@ -782,7 +841,7 @@ namespace dxvk {
   void D3D11ImmediateContext::EndFrame() {
     D3D10DeviceLock lock = LockContext();
 
-    EmitCs([] (DxvkContext* ctx) {
+    EmitCs<false>([] (DxvkContext* ctx) {
       ctx->endFrame();
     });
   }
@@ -813,14 +872,14 @@ namespace dxvk {
         // We don't have to wait, but misbehaving games may
         // still try to spin on `Map` until the resource is
         // idle, so we should flush pending commands
-        FlushImplicit(FALSE);
+        ConsiderFlush(GpuFlushType::ImplicitSynchronization);
         return false;
       }
     } else {
       if (isInUse) {
         // Make sure pending commands using the resource get
         // executed on the the GPU if we have to wait for it
-        Flush();
+        ExecuteFlush(GpuFlushType::ImplicitSynchronization, nullptr, false);
         SynchronizeCsThread(SequenceNumber);
 
         m_device->waitForResource(Resource, access);
@@ -833,7 +892,6 @@ namespace dxvk {
   
   void D3D11ImmediateContext::EmitCsChunk(DxvkCsChunkRef&& chunk) {
     m_csSeqNum = m_csThread.dispatchChunk(std::move(chunk));
-    m_csIsBusy = true;
   }
 
 
@@ -843,7 +901,7 @@ namespace dxvk {
     uint64_t sequenceNumber = GetCurrentSequenceNumber();
     pResource->TrackSequenceNumber(Subresource, sequenceNumber);
 
-    FlushImplicit(TRUE);
+    ConsiderFlush(GpuFlushType::ImplicitStrongHint);
   }
 
 
@@ -852,7 +910,7 @@ namespace dxvk {
     uint64_t sequenceNumber = GetCurrentSequenceNumber();
     pResource->TrackSequenceNumber(sequenceNumber);
 
-    FlushImplicit(TRUE);
+    ConsiderFlush(GpuFlushType::ImplicitStrongHint);
   }
 
 
@@ -864,40 +922,67 @@ namespace dxvk {
   }
 
 
-  void D3D11ImmediateContext::FlushImplicit(BOOL StrongHint) {
-    // Flush only if the GPU is about to go idle, in
-    // order to keep the number of submissions low.
-    uint32_t pending = m_device->pendingSubmissions();
-
-    if (StrongHint || pending <= MaxPendingSubmits) {
-      auto now = dxvk::high_resolution_clock::now();
-
-      uint32_t delay = MinFlushIntervalUs
-                     + IncFlushIntervalUs * pending;
-
-      // Prevent flushing too often in short intervals.
-      if (now - m_lastFlush >= std::chrono::microseconds(delay))
-        Flush();
-    }
+  uint64_t D3D11ImmediateContext::GetPendingCsChunks() {
+    return GetCurrentSequenceNumber() - m_flushSeqNum;
   }
 
 
-  void D3D11ImmediateContext::SignalEvent(HANDLE hEvent) {
-    uint64_t value = ++m_eventCount;
+  void D3D11ImmediateContext::ConsiderFlush(
+          GpuFlushType                FlushType) {
+    uint64_t chunkId = GetCurrentSequenceNumber();
+    uint64_t submissionId = m_submissionFence->value();
 
-    if (m_eventSignal == nullptr)
-      m_eventSignal = new sync::CallbackFence();
+    if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId))
+      ExecuteFlush(FlushType, nullptr, false);
+  }
 
-    m_eventSignal->setCallback(value, [hEvent] {
-      SetEvent(hEvent);
-    });
 
-    EmitCs([
-      cSignal = m_eventSignal,
-      cValue  = value
+  void D3D11ImmediateContext::ExecuteFlush(
+          GpuFlushType                FlushType,
+          HANDLE                      hEvent,
+          BOOL                        Synchronize) {
+    bool synchronizeSubmission = Synchronize && m_parent->Is11on12Device();
+
+    if (synchronizeSubmission)
+      m_submitStatus.result = VK_NOT_READY;
+
+    // Flush init context so that new resources are fully initialized
+    // before the app can access them in any way. This has to happen
+    // unconditionally since we may otherwise deadlock on Map.
+    m_parent->FlushInitContext();
+
+    // Exit early if there's nothing to do
+    if (!GetPendingCsChunks() && !hEvent)
+      return;
+
+    // Signal the submission fence and flush the command list
+    uint64_t submissionId = ++m_submissionId;
+
+    if (hEvent) {
+      m_submissionFence->setCallback(submissionId, [hEvent] {
+        SetEvent(hEvent);
+      });
+    }
+
+    EmitCs<false>([
+      cSubmissionFence  = m_submissionFence,
+      cSubmissionId     = submissionId,
+      cSubmissionStatus = synchronizeSubmission ? &m_submitStatus : nullptr
     ] (DxvkContext* ctx) {
-      ctx->signal(cSignal, cValue);
+      ctx->signal(cSubmissionFence, cSubmissionId);
+      ctx->flushCommandList(cSubmissionStatus);
     });
+
+    FlushCsChunk();
+
+    // Notify flush tracker about the flush
+    m_flushSeqNum = m_csSeqNum;
+    m_flushTracker.notifyFlush(m_flushSeqNum, submissionId);
+
+    // If necessary, block calling thread until the
+    // Vulkan queue submission is performed.
+    if (synchronizeSubmission)
+      m_device->waitForSubmission(&m_submitStatus);
   }
   
 }

src/d3d11/d3d11_context_imm.h

@@ -12,11 +12,12 @@ namespace dxvk {
   
   class D3D11Buffer;
   class D3D11CommonTexture;
-  
+
   class D3D11ImmediateContext : public D3D11CommonContext<D3D11ImmediateContext> {
     friend class D3D11CommonContext<D3D11ImmediateContext>;
     friend class D3D11SwapChain;
     friend class D3D11VideoContext;
+    friend class D3D11DXGIKeyedMutex;
   public:
     
     D3D11ImmediateContext(
@@ -77,9 +78,21 @@ namespace dxvk {
             ID3DDeviceContextState*           pState,
             ID3DDeviceContextState**          ppPreviousState);
 
+    void Acquire11on12Resource(
+            ID3D11Resource*             pResource,
+            VkImageLayout               SrcLayout);
+
+    void Release11on12Resource(
+            ID3D11Resource*             pResource,
+            VkImageLayout               DstLayout);
+
     void SynchronizeCsThread(
             uint64_t                          SequenceNumber);
 
+    D3D10Multithread& GetMultithread() {
+        return m_multithread;
+    }
+
     D3D10DeviceLock LockContext() {
       return m_multithread.AcquireLock();
     }
@@ -88,19 +101,20 @@ namespace dxvk {
     
     DxvkCsThread            m_csThread;
     uint64_t                m_csSeqNum = 0ull;
-    bool                    m_csIsBusy = false;
 
-    Rc<sync::CallbackFence> m_eventSignal;
-    uint64_t                m_eventCount = 0ull;
     uint32_t                m_mappedImageCount = 0u;
 
     VkDeviceSize            m_maxImplicitDiscardSize = 0ull;
 
-    dxvk::high_resolution_clock::time_point m_lastFlush
-      = dxvk::high_resolution_clock::now();
-    
-    D3D10Multithread             m_multithread;
-    D3D11VideoContext            m_videoContext;
+    Rc<sync::CallbackFence> m_submissionFence;
+    uint64_t                m_submissionId = 0ull;
+    DxvkSubmitStatus        m_submitStatus;
+
+    uint64_t                m_flushSeqNum = 0ull;
+    GpuFlushTracker         m_flushTracker;
+
+    D3D10Multithread        m_multithread;
+    D3D11VideoContext       m_videoContext;
 
     Com<D3D11DeviceContextState, false> m_stateObject;
     
@@ -131,21 +145,21 @@ namespace dxvk {
       const D3D11_COMMON_TEXTURE_REGION* pRegion);
 
     void UpdateMappedBuffer(
-            D3D11Buffer*                  pDstBuffer,
-            UINT                          Offset,
-            UINT                          Length,
-      const void*                         pSrcData,
-            UINT                          CopyFlags);
+            D3D11Buffer*                pDstBuffer,
+            UINT                        Offset,
+            UINT                        Length,
+      const void*                       pSrcData,
+            UINT                        CopyFlags);
 
     void SynchronizeDevice();
 
     void EndFrame();
     
     bool WaitForResource(
-      const Rc<DxvkResource>&                 Resource,
-            uint64_t                          SequenceNumber,
-            D3D11_MAP                         MapType,
-            UINT                              MapFlags);
+      const Rc<DxvkResource>&           Resource,
+            uint64_t                    SequenceNumber,
+            D3D11_MAP                   MapType,
+            UINT                        MapFlags);
     
     void EmitCsChunk(DxvkCsChunkRef&& chunk);
 
@@ -158,10 +172,16 @@ namespace dxvk {
 
     uint64_t GetCurrentSequenceNumber();
 
-    void FlushImplicit(BOOL StrongHint);
+    uint64_t GetPendingCsChunks();
+
+    void ConsiderFlush(
+            GpuFlushType                FlushType);
+
+    void ExecuteFlush(
+            GpuFlushType                FlushType,
+            HANDLE                      hEvent,
+            BOOL                        Synchronize);
 
-    void SignalEvent(HANDLE hEvent);
-    
   };
   
 }

src/d3d11/d3d11_depth_stencil.cpp

@@ -37,12 +37,15 @@ namespace dxvk {
 
     if (riid == __uuidof(ID3D10DeviceChild)
      || riid == __uuidof(ID3D10DepthStencilState)) {
-      *ppvObject = ref(this);
+      *ppvObject = ref(&m_d3d10);
       return S_OK;
     }
     
-    Logger::warn("D3D11DepthStencilState::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11DepthStencilState), riid)) {
+      Logger::warn("D3D11DepthStencilState::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_device.cpp

@@ -45,10 +45,10 @@ namespace dxvk {
     m_dxvkDevice        (pContainer->GetDXVKDevice()),
     m_dxvkAdapter       (m_dxvkDevice->adapter()),
     m_d3d11Formats      (m_dxvkDevice),
-    m_d3d11Options      (m_dxvkDevice->instance()->config(), m_dxvkDevice),
+    m_d3d11Options      (m_dxvkDevice->instance()->config()),
     m_dxbcOptions       (m_dxvkDevice, m_d3d11Options),
     m_maxFeatureLevel   (GetMaxFeatureLevel(m_dxvkDevice->instance(), m_dxvkDevice->adapter())),
-    m_deviceFeatures    (m_dxvkDevice->instance(), m_dxvkDevice->adapter(), m_featureLevel) {
+    m_deviceFeatures    (m_dxvkDevice->instance(), m_dxvkDevice->adapter(), m_d3d11Options, m_featureLevel) {
     m_initializer = new D3D11Initializer(this);
     m_context     = new D3D11ImmediateContext(this, m_dxvkDevice);
     m_d3d10Device = new D3D10Device(this, m_context.ptr());
@@ -100,7 +100,7 @@ namespace dxvk {
       return S_FALSE;
     
     try {
-      const Com<D3D11Buffer> buffer = new D3D11Buffer(this, &desc);
+      const Com<D3D11Buffer> buffer = new D3D11Buffer(this, &desc, nullptr);
 
       if (!(desc.MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL))
         m_initializer->InitBuffer(buffer.ptr(), pInitialData);
@@ -149,7 +149,7 @@ namespace dxvk {
       return S_FALSE;
     
     try {
-      const Com<D3D11Texture1D> texture = new D3D11Texture1D(this, &desc);
+      const Com<D3D11Texture1D> texture = new D3D11Texture1D(this, &desc, nullptr);
       m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData);
       *ppTexture1D = texture.ref();
       return S_OK;
@@ -229,7 +229,7 @@ namespace dxvk {
       return S_FALSE;
     
     try {
-      Com<D3D11Texture2D> texture = new D3D11Texture2D(this, &desc, nullptr);
+      Com<D3D11Texture2D> texture = new D3D11Texture2D(this, &desc, nullptr, nullptr);
       m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData);
       *ppTexture2D = texture.ref();
       return S_OK;
@@ -308,7 +308,7 @@ namespace dxvk {
       return S_FALSE;
       
     try {
-      Com<D3D11Texture3D> texture = new D3D11Texture3D(this, &desc);
+      Com<D3D11Texture3D> texture = new D3D11Texture3D(this, &desc, nullptr);
       m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData);
       *ppTexture3D = texture.ref();
       return S_OK;
@@ -1348,7 +1348,7 @@ namespace dxvk {
       m_deviceFeatures = D3D11DeviceFeatures(
         m_dxvkDevice->instance(),
         m_dxvkDevice->adapter(),
-        m_featureLevel);
+        m_d3d11Options, m_featureLevel);
     }
 
     if (pChosenFeatureLevel)
@@ -1832,6 +1832,11 @@ namespace dxvk {
           DXGI_VK_FORMAT_MODE   Mode) const {
     return m_d3d11Formats.GetFormatFamily(Format, Mode);
   }
+
+
+  bool D3D11Device::Is11on12Device() const {
+    return m_container->Is11on12Device();
+  }
   
   
   void D3D11Device::FlushInitContext() {
@@ -1948,6 +1953,11 @@ namespace dxvk {
     enabled.core.features.shaderFloat64                           = supported.core.features.shaderFloat64;
     enabled.core.features.shaderInt64                             = supported.core.features.shaderInt64;
 
+    // Depth bias control
+    enabled.extDepthBiasControl.depthBiasControl                                = supported.extDepthBiasControl.depthBiasControl;
+    enabled.extDepthBiasControl.depthBiasExact                                  = supported.extDepthBiasControl.depthBiasExact;
+    enabled.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation = supported.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation;
+
     return enabled;
   }
   
@@ -2299,10 +2309,14 @@ namespace dxvk {
     d3d11Desc.CPUAccessFlags = metadata.CPUAccessFlags;
     d3d11Desc.MiscFlags      = metadata.MiscFlags;
     d3d11Desc.TextureLayout  = metadata.TextureLayout;
+    if ((d3d11Desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE) && !(d3d11Desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX))) {
+      Logger::warn("Fixing up wrong MiscFlags");
+      d3d11Desc.MiscFlags |= D3D11_RESOURCE_MISC_SHARED;
+    }
 
     // Only 2D textures may be shared
     try {
-      const Com<D3D11Texture2D> texture = new D3D11Texture2D(this, &d3d11Desc, hResource);
+      const Com<D3D11Texture2D> texture = new D3D11Texture2D(this, &d3d11Desc, nullptr, hResource);
       texture->QueryInterface(ReturnedInterface, ppResource);
       return S_OK;
     }
@@ -3019,85 +3033,6 @@ namespace dxvk {
 
 
 
-  WineDXGISwapChainFactory::WineDXGISwapChainFactory(
-          D3D11DXGIDevice*        pContainer,
-          D3D11Device*            pDevice)
-  : m_container(pContainer), m_device(pDevice) {
-    
-  }
-  
-  
-  ULONG STDMETHODCALLTYPE WineDXGISwapChainFactory::AddRef() {
-    return m_device->AddRef();
-  }
-  
-  
-  ULONG STDMETHODCALLTYPE WineDXGISwapChainFactory::Release() {
-    return m_device->Release();
-  }
-  
-  
-  HRESULT STDMETHODCALLTYPE WineDXGISwapChainFactory::QueryInterface(
-          REFIID                  riid,
-          void**                  ppvObject) {
-    return m_device->QueryInterface(riid, ppvObject);
-  }
-  
-  
-  HRESULT STDMETHODCALLTYPE WineDXGISwapChainFactory::CreateSwapChainForHwnd(
-          IDXGIFactory*           pFactory,
-          HWND                    hWnd,
-    const DXGI_SWAP_CHAIN_DESC1*  pDesc,
-    const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc,
-          IDXGIOutput*            pRestrictToOutput,
-          IDXGISwapChain1**       ppSwapChain) {
-    InitReturnPtr(ppSwapChain);
-    
-    if (!ppSwapChain || !pDesc || !hWnd)
-      return DXGI_ERROR_INVALID_CALL;
-    
-    // Make sure the back buffer size is not zero
-    DXGI_SWAP_CHAIN_DESC1 desc = *pDesc;
-    
-    wsi::getWindowSize(hWnd,
-      desc.Width  ? nullptr : &desc.Width,
-      desc.Height ? nullptr : &desc.Height);
-    
-    // If necessary, set up a default set of
-    // fullscreen parameters for the swap chain
-    DXGI_SWAP_CHAIN_FULLSCREEN_DESC fsDesc;
-    
-    if (pFullscreenDesc) {
-      fsDesc = *pFullscreenDesc;
-    } else {
-      fsDesc.RefreshRate      = { 0, 0 };
-      fsDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
-      fsDesc.Scaling          = DXGI_MODE_SCALING_UNSPECIFIED;
-      fsDesc.Windowed         = TRUE;
-    }
-    
-    try {
-      auto vki = m_device->GetDXVKDevice()->adapter()->vki();
-
-      // Create surface factory for the window
-      Com<IDXGIVkSurfaceFactory> surfaceFactory = new DxgiSurfaceFactory(vki->getLoaderProc(), hWnd);
-
-      // Create presenter for the device
-      Com<D3D11SwapChain> presenter = new D3D11SwapChain(
-        m_container, m_device, surfaceFactory.ptr(), &desc);
-      
-      // Create the actual swap chain
-      *ppSwapChain = ref(new DxgiSwapChain(
-        pFactory, presenter.ptr(), hWnd, &desc, &fsDesc));
-      return S_OK;
-    } catch (const DxvkError& e) {
-      Logger::err(e.message());
-      return E_INVALIDARG;
-    }
-  }
-  
-  
-
   DXGIDXVKDevice::DXGIDXVKDevice(D3D11DXGIDevice* pContainer)
   : m_container(pContainer), m_apiVersion(11) {
 
@@ -3136,27 +3071,30 @@ namespace dxvk {
 
   D3D11DXGIDevice::D3D11DXGIDevice(
           IDXGIAdapter*       pAdapter,
-    const Rc<DxvkInstance>&   pDxvkInstance,
-    const Rc<DxvkAdapter>&    pDxvkAdapter,
+          ID3D12Device*       pD3D12Device,
+          ID3D12CommandQueue* pD3D12Queue,
+          Rc<DxvkInstance>    pDxvkInstance,
+          Rc<DxvkAdapter>     pDxvkAdapter,
+          Rc<DxvkDevice>      pDxvkDevice,
           D3D_FEATURE_LEVEL   FeatureLevel,
           UINT                FeatureFlags)
   : m_dxgiAdapter   (pAdapter),
     m_dxvkInstance  (pDxvkInstance),
     m_dxvkAdapter   (pDxvkAdapter),
-    m_dxvkDevice    (CreateDevice(FeatureLevel)),
+    m_dxvkDevice    (pDxvkDevice),
     m_d3d11Device   (this, FeatureLevel, FeatureFlags),
     m_d3d11DeviceExt(this, &m_d3d11Device),
     m_d3d11Interop  (this, &m_d3d11Device),
     m_d3d11Video    (this, &m_d3d11Device),
+    m_d3d11on12     (this, &m_d3d11Device, pD3D12Device, pD3D12Queue),
     m_metaDevice    (this),
-    m_dxvkFactory   (this, &m_d3d11Device),
-    m_wineFactory   (this, &m_d3d11Device) {
+    m_dxvkFactory   (this, &m_d3d11Device) {
 
   }
   
   
   D3D11DXGIDevice::~D3D11DXGIDevice() {
-    
+
   }
   
   
@@ -3215,16 +3153,18 @@ namespace dxvk {
       return S_OK;
     }
 
-    if (riid == __uuidof(IWineDXGISwapChainFactory)) {
-      *ppvObject = ref(&m_wineFactory);
-      return S_OK;
-    }
-
     if (riid == __uuidof(ID3D11VideoDevice)) {
       *ppvObject = ref(&m_d3d11Video);
       return S_OK;
     }
 
+    if (m_d3d11on12.Is11on12Device()) {
+      if (riid == __uuidof(ID3D11On12Device)) {
+        *ppvObject = ref(&m_d3d11on12);
+        return S_OK;
+      }
+    }
+
     if (riid == __uuidof(ID3D10Multithread)) {
       Com<ID3D11DeviceContext> context;
       m_d3d11Device.GetImmediateContext(&context);
@@ -3238,8 +3178,11 @@ namespace dxvk {
     if (riid == GUID{0xd56e2a4c,0x5127,0x8437,{0x65,0x8a,0x98,0xc5,0xbb,0x78,0x94,0x98}})
       return E_NOINTERFACE;
     
-    Logger::warn("D3D11DXGIDevice::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(IDXGIDXVKDevice), riid)) {
+      Logger::warn("D3D11DXGIDevice::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -3468,8 +3411,9 @@ namespace dxvk {
 
 
   HRESULT STDMETHODCALLTYPE D3D11DXGIDevice::EnqueueSetEvent(HANDLE hEvent) {
-    Logger::err("D3D11DXGIDevice::EnqueueSetEvent: Not implemented");
-    return DXGI_ERROR_UNSUPPORTED;           
+    auto immediateContext = m_d3d11Device.GetContext();
+    immediateContext->Flush1(D3D11_CONTEXT_TYPE_ALL, hEvent);
+    return S_OK;            
   }
 
 
@@ -3485,10 +3429,4 @@ namespace dxvk {
     return m_dxvkDevice;
   }
 
-
-  Rc<DxvkDevice> D3D11DXGIDevice::CreateDevice(D3D_FEATURE_LEVEL FeatureLevel) {
-    DxvkDeviceFeatures deviceFeatures = D3D11Device::GetDeviceFeatures(m_dxvkAdapter);
-    return m_dxvkAdapter->createDevice(m_dxvkInstance, deviceFeatures);
-  }
-
 }

src/d3d11/d3d11_device.h

@@ -20,6 +20,7 @@
 #include "d3d11_initializer.h"
 #include "d3d11_interfaces.h"
 #include "d3d11_interop.h"
+#include "d3d11_on_12.h"
 #include "d3d11_options.h"
 #include "d3d11_shader.h"
 #include "d3d11_state.h"
@@ -420,7 +421,13 @@ namespace dxvk {
     D3D10Device* GetD3D10Interface() const {
       return m_d3d10Device;
     }
-    
+
+    D3D11ImmediateContext* GetContext() const {
+      return m_context.ptr();
+    }
+
+    bool Is11on12Device() const;
+
     static D3D_FEATURE_LEVEL GetMaxFeatureLevel(
       const Rc<DxvkInstance>& Instance,
       const Rc<DxvkAdapter>&  Adapter);
@@ -430,7 +437,7 @@ namespace dxvk {
     
   private:
     
-    IDXGIObject*                    m_container;
+    D3D11DXGIDevice*                m_container;
 
     D3D_FEATURE_LEVEL               m_featureLevel;
     UINT                            m_featureFlags;
@@ -722,41 +729,6 @@ namespace dxvk {
   };
 
 
-  /**
-   * \brief DXGI swap chain factory
-   */
-  class WineDXGISwapChainFactory : public IWineDXGISwapChainFactory {
-    
-  public:
-    
-    WineDXGISwapChainFactory(
-            D3D11DXGIDevice*        pContainer,
-            D3D11Device*            pDevice);
-    
-    ULONG STDMETHODCALLTYPE AddRef();
-    
-    ULONG STDMETHODCALLTYPE Release();
-    
-    HRESULT STDMETHODCALLTYPE QueryInterface(
-            REFIID                  riid,
-            void**                  ppvObject);
-    
-    HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd(
-            IDXGIFactory*           pFactory,
-            HWND                    hWnd,
-      const DXGI_SWAP_CHAIN_DESC1*  pDesc,
-      const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc,
-            IDXGIOutput*            pRestrictToOutput,
-            IDXGISwapChain1**       ppSwapChain);
-    
-  private:
-    
-    D3D11DXGIDevice* m_container;
-    D3D11Device*     m_device;
-    
-  };
-  
-
   /**
    * \brief D3D11 device metadata shenanigans
    */
@@ -799,8 +771,11 @@ namespace dxvk {
     
     D3D11DXGIDevice(
             IDXGIAdapter*       pAdapter,
-      const Rc<DxvkInstance>&   pDxvkInstance,
-      const Rc<DxvkAdapter>&    pDxvkAdapter,
+            ID3D12Device*       pD3D12Device,
+            ID3D12CommandQueue* pD3D12Queue,
+            Rc<DxvkInstance>    pDxvkInstance,
+            Rc<DxvkAdapter>     pDxvkAdapter,
+            Rc<DxvkDevice>      pDxvkDevice,
             D3D_FEATURE_LEVEL   FeatureLevel,
             UINT                FeatureFlags);
     
@@ -869,6 +844,10 @@ namespace dxvk {
     
     Rc<DxvkDevice> STDMETHODCALLTYPE GetDXVKDevice();
 
+    BOOL Is11on12Device() const {
+      return m_d3d11on12.Is11on12Device();
+    }
+
   private:
 
     Com<IDXGIAdapter>   m_dxgiAdapter;
@@ -881,15 +860,13 @@ namespace dxvk {
     D3D11DeviceExt      m_d3d11DeviceExt;
     D3D11VkInterop      m_d3d11Interop;
     D3D11VideoDevice    m_d3d11Video;
+    D3D11on12Device     m_d3d11on12;
     DXGIDXVKDevice      m_metaDevice;
     
     DXGIVkSwapChainFactory   m_dxvkFactory;
-    WineDXGISwapChainFactory m_wineFactory;
     
     uint32_t m_frameLatency = DefaultFrameLatency;
 
-    Rc<DxvkDevice> CreateDevice(D3D_FEATURE_LEVEL FeatureLevel);
-
   };
   
 }

src/d3d11/d3d11_features.cpp

@@ -12,6 +12,7 @@ namespace dxvk {
   D3D11DeviceFeatures::D3D11DeviceFeatures(
     const Rc<DxvkInstance>&     Instance,
     const Rc<DxvkAdapter>&      Adapter,
+    const D3D11Options&         Options,
           D3D_FEATURE_LEVEL     FeatureLevel)
   : m_features    (Adapter->features()),
     m_properties  (Adapter->devicePropertiesExt()) {
@@ -107,7 +108,7 @@ namespace dxvk {
     m_gpuVirtualAddress.MaxGPUVirtualAddressBitsPerProcess = 40;
 
     // Marker support only depends on the debug utils extension
-    m_marker.Profile = Instance->extensions().extDebugUtils;
+    m_marker.Profile = static_cast<bool>(Instance->extensions().extDebugUtils);
 
     // DXVK will keep all shaders in memory once created, and all Vulkan
     // drivers that we know of that can run DXVK have an on-disk cache.
@@ -118,11 +119,11 @@ namespace dxvk {
     m_shaderMinPrecision.PixelShaderMinPrecision          = 0;
     m_shaderMinPrecision.AllOtherShaderStagesMinPrecision = 0;
 
-    // Report native support for command lists here so that we do not actually have
-    // to re-implement the UpdateSubresource bug from the D3D11 runtime, see MSDN:
-    // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476486(v=vs.85).aspx)
+    // Report native support for command lists by default. Deferred context
+    // usage can be beneficial for us as ExecuteCommandList has low overhead,
+    // and we avoid having to deal with known UpdateSubresource bugs this way.
     m_threading.DriverConcurrentCreates                   = TRUE;
-    m_threading.DriverCommandLists                        = TRUE;
+    m_threading.DriverCommandLists                        = Options.exposeDriverCommandLists;
   }
 
 
@@ -182,7 +183,8 @@ namespace dxvk {
   D3D_FEATURE_LEVEL D3D11DeviceFeatures::GetMaxFeatureLevel(
     const Rc<DxvkInstance>&     Instance,
     const Rc<DxvkAdapter>&      Adapter) {
-    D3D11DeviceFeatures features(Instance, Adapter, D3D_FEATURE_LEVEL_12_1);
+    D3D11Options options(Instance->config());
+    D3D11DeviceFeatures features(Instance, Adapter, options, D3D_FEATURE_LEVEL_12_1);
     return features.GetMaxFeatureLevel();
   }
 

src/d3d11/d3d11_features.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "d3d11_include.h"
+#include "d3d11_options.h"
 
 #include "../dxvk/dxvk_adapter.h"
 #include "../dxvk/dxvk_instance.h"
@@ -21,6 +22,7 @@ namespace dxvk {
     D3D11DeviceFeatures(
       const Rc<DxvkInstance>&     Instance,
       const Rc<DxvkAdapter>&      Adapter,
+      const D3D11Options&         Options,
             D3D_FEATURE_LEVEL     FeatureLevel);
 
     ~D3D11DeviceFeatures();

src/d3d11/d3d11_fence.cpp

@@ -48,8 +48,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11Fence: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11Fence), riid)) {
+      Logger::warn("D3D11Fence: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -81,13 +84,13 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11Fence::SetEventOnCompletion(
           UINT64              Value,
           HANDLE              hEvent) {
-    // TODO in case of rewinds, the stored value may be higher.
-    // For shared fences, calling vkWaitSemaphores here could alleviate the issue.
-
-    m_fence->enqueueWait(Value, [hEvent] {
-      SetEvent(hEvent);
-    });
-
+    if (hEvent) {
+      m_fence->enqueueWait(Value, [hEvent] {
+        SetEvent(hEvent);
+      });
+    } else {
+      m_fence->wait(Value);
+    }
     return S_OK;
   }
 

src/d3d11/d3d11_gdi.cpp

@@ -150,11 +150,8 @@ namespace dxvk {
   HRESULT D3D11GDISurface::CreateReadbackResource() {
     auto tex = GetCommonTexture(m_resource);
 
-    Com<ID3D11Device>         device;
-    Com<ID3D11DeviceContext>  context;
-
+    Com<ID3D11Device> device;
     m_resource->GetDevice(&device);
-    device->GetImmediateContext(&context);
 
     D3D11_RESOURCE_DIMENSION dim = { };
     m_resource->GetType(&dim);

src/d3d11/d3d11_initializer.cpp

@@ -49,23 +49,28 @@ namespace dxvk {
       InitHostVisibleTexture(pTexture, pInitialData);
     else
       InitDeviceLocalTexture(pTexture, pInitialData);
+
+    SyncKeyedMutex(pTexture->GetInterface());
   }
 
 
   void D3D11Initializer::InitUavCounter(
           D3D11UnorderedAccessView*   pUav) {
-    auto counterBuffer = pUav->GetCounterSlice();
+    auto counterView = pUav->GetCounterView();
 
-    if (!counterBuffer.defined())
+    if (counterView == nullptr)
       return;
 
+    auto counterSlice = counterView->slice();
+
     std::lock_guard<dxvk::mutex> lock(m_mutex);
     m_transferCommands += 1;
 
     const uint32_t zero = 0;
     m_context->updateBuffer(
-      counterBuffer.buffer(),
-      0, sizeof(zero), &zero);
+      counterSlice.buffer(),
+      counterSlice.offset(),
+      sizeof(zero), &zero);
 
     FlushImplicit();
   }
@@ -275,10 +280,20 @@ namespace dxvk {
 
 
   void D3D11Initializer::FlushInternal() {
-    m_context->flushCommandList();
+    m_context->flushCommandList(nullptr);
     
     m_transferCommands = 0;
     m_transferMemory   = 0;
   }
 
+
+  void D3D11Initializer::SyncKeyedMutex(ID3D11Resource *pResource) {
+    Com<IDXGIKeyedMutex> keyedMutex;
+    if (pResource->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&keyedMutex)) != S_OK)
+      return;
+
+    keyedMutex->AcquireSync(0, 0);
+    keyedMutex->ReleaseSync(0);
+  }
+
 }

src/d3d11/d3d11_initializer.h

@@ -71,6 +71,8 @@ namespace dxvk {
     void FlushImplicit();
     void FlushInternal();
 
+    void SyncKeyedMutex(ID3D11Resource *pResource);
+
   };
 
 }

src/d3d11/d3d11_input_layout.cpp

@@ -46,8 +46,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11InputLayout::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11InputLayout), riid)) {
+      Logger::warn("D3D11InputLayout::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_interfaces.h

@@ -183,13 +183,7 @@ ID3D11VkExtContext1 : public ID3D11VkExtContext {
 };
 
 
-#ifdef _MSC_VER
-struct __declspec(uuid("bb8a4fb9-3935-4762-b44b-35189a26414a")) ID3D11VkExtShader;
-struct __declspec(uuid("8a6e3c42-f74c-45b7-8265-a231b677ca17")) ID3D11VkExtDevice;
-struct __declspec(uuid("cfcf64ef-9586-46d0-bca4-97cf2ca61b06")) ID3D11VkExtDevice1;
-struct __declspec(uuid("fd0bca13-5cb6-4c3a-987e-4750de2ca791")) ID3D11VkExtContext;
-struct __declspec(uuid("874b09b2-ae0b-41d8-8476-5f3b7a0e879d")) ID3D11VkExtContext1;
-#else
+#ifndef _MSC_VER
 __CRT_UUID_DECL(ID3D11VkExtShader,         0xbb8a4fb9,0x3935,0x4762,0xb4,0x4b,0x35,0x18,0x9a,0x26,0x41,0x4a);
 __CRT_UUID_DECL(ID3D11VkExtDevice,         0x8a6e3c42,0xf74c,0x45b7,0x82,0x65,0xa2,0x31,0xb6,0x77,0xca,0x17);
 __CRT_UUID_DECL(ID3D11VkExtDevice1,        0xcfcf64ef,0x9586,0x46d0,0xbc,0xa4,0x97,0xcf,0x2c,0xa6,0x1b,0x06);

src/d3d11/d3d11_interop.cpp

@@ -75,21 +75,15 @@ namespace dxvk {
     const VkImageSubresourceRange*  pSubresources,
           VkImageLayout             OldLayout,
           VkImageLayout             NewLayout) {
-    Com<ID3D11DeviceContext> deviceContext = nullptr;
-    m_device->GetImmediateContext(&deviceContext);
-    
-    auto immediateContext = static_cast<D3D11ImmediateContext*>(deviceContext.ptr());
-    
+    auto immediateContext = m_device->GetContext();
+
     immediateContext->TransitionSurfaceLayout(
       pSurface, pSubresources, OldLayout, NewLayout);
   }
   
   
   void STDMETHODCALLTYPE D3D11VkInterop::FlushRenderingCommands() {
-    Com<ID3D11DeviceContext> deviceContext = nullptr;
-    m_device->GetImmediateContext(&deviceContext);
-    
-    auto immediateContext = static_cast<D3D11ImmediateContext*>(deviceContext.ptr());
+    auto immediateContext = m_device->GetContext();
     immediateContext->Flush();
     immediateContext->SynchronizeCsThread(DxvkCsThread::SynchronizeAll);
   }

src/d3d11/d3d11_main.cpp

@@ -15,7 +15,7 @@ namespace dxvk {
 extern "C" {
   using namespace dxvk;
   
-  DLLEXPORT HRESULT __stdcall D3D11CoreCreateDevice(
+  HRESULT D3D11InternalCreateDevice(
           IDXGIFactory*       pFactory,
           IDXGIAdapter*       pAdapter,
           UINT                Flags,
@@ -34,11 +34,11 @@ extern "C" {
       dxvkAdapter  = dxgiVkAdapter->GetDXVKAdapter();
       dxvkInstance = dxgiVkAdapter->GetDXVKInstance();
     } else {
-      Logger::warn("D3D11CoreCreateDevice: Adapter is not a DXVK adapter");
+      Logger::warn("D3D11InternalCreateDevice: Adapter is not a DXVK adapter");
       DXGI_ADAPTER_DESC desc;
       pAdapter->GetDesc(&desc);
 
-      dxvkInstance = new DxvkInstance();
+      dxvkInstance = new DxvkInstance(0);
       dxvkAdapter  = dxvkInstance->findAdapterByLuid(&desc.AdapterLuid);
 
       if (dxvkAdapter == nullptr)
@@ -70,7 +70,7 @@ extern "C" {
     D3D_FEATURE_LEVEL minFeatureLevel = D3D_FEATURE_LEVEL();
     D3D_FEATURE_LEVEL devFeatureLevel = D3D_FEATURE_LEVEL();
 
-    Logger::info(str::format("D3D11CoreCreateDevice: Maximum supported feature level: ", maxFeatureLevel));
+    Logger::info(str::format("D3D11InternalCreateDevice: Maximum supported feature level: ", maxFeatureLevel));
 
     for (uint32_t flId = 0 ; flId < FeatureLevels; flId++) {
       minFeatureLevel = pFeatureLevels[flId];
@@ -82,21 +82,26 @@ extern "C" {
     }
 
     if (!devFeatureLevel) {
-      Logger::err(str::format("D3D11CoreCreateDevice: Minimum required feature level ", minFeatureLevel, " not supported"));
+      Logger::err(str::format("D3D11InternalCreateDevice: Minimum required feature level ", minFeatureLevel, " not supported"));
       return E_INVALIDARG;
     }
 
     try {
-      Logger::info(str::format("D3D11CoreCreateDevice: Using feature level ", devFeatureLevel));
+      Logger::info(str::format("D3D11InternalCreateDevice: Using feature level ", devFeatureLevel));
+
+      DxvkDeviceFeatures deviceFeatures = D3D11Device::GetDeviceFeatures(dxvkAdapter);
+      Rc<DxvkDevice> dxvkDevice = dxvkAdapter->createDevice(dxvkInstance, deviceFeatures);
 
       Com<D3D11DXGIDevice> device = new D3D11DXGIDevice(
-        pAdapter, dxvkInstance, dxvkAdapter, devFeatureLevel, Flags);
+        pAdapter, nullptr, nullptr,
+        dxvkInstance, dxvkAdapter, dxvkDevice,
+        devFeatureLevel, Flags);
 
       return device->QueryInterface(
         __uuidof(ID3D11Device),
         reinterpret_cast<void**>(ppDevice));
     } catch (const DxvkError& e) {
-      Logger::err("D3D11CoreCreateDevice: Failed to create D3D11 device");
+      Logger::err("D3D11InternalCreateDevice: Failed to create D3D11 device");
       return E_FAIL;
     }
   }
@@ -168,7 +173,7 @@ extern "C" {
     }
     
     // Create the actual device
-    hr = D3D11CoreCreateDevice(
+    hr = D3D11InternalCreateDevice(
       dxgiFactory.ptr(), dxgiAdapter.ptr(),
       Flags, pFeatureLevels, FeatureLevels,
       &device);
@@ -207,6 +212,25 @@ extern "C" {
   }
   
 
+    DLLEXPORT HRESULT __stdcall D3D11CoreCreateDevice(
+            IDXGIFactory*       pFactory,
+            IDXGIAdapter*       pAdapter,
+            D3D_DRIVER_TYPE     DriverType,
+            HMODULE             Software,
+            UINT                Flags,
+      const D3D_FEATURE_LEVEL*  pFeatureLevels,
+            UINT                FeatureLevels,
+            UINT                SDKVersion,
+            ID3D11Device**      ppDevice,
+            D3D_FEATURE_LEVEL*  pFeatureLevel) {
+    return D3D11InternalCreateDeviceAndSwapChain(
+      pAdapter, DriverType, Software, Flags,
+      pFeatureLevels, FeatureLevels, SDKVersion,
+      nullptr, nullptr,
+      ppDevice, pFeatureLevel, nullptr);
+  }
+
+
   DLLEXPORT HRESULT __stdcall D3D11CreateDevice(
           IDXGIAdapter*         pAdapter,
           D3D_DRIVER_TYPE       DriverType,
@@ -258,12 +282,169 @@ extern "C" {
           ID3D11Device**        ppDevice,
           ID3D11DeviceContext** ppImmediateContext,
           D3D_FEATURE_LEVEL*    pChosenFeatureLevel) {
-    static bool s_errorShown = false;
+    InitReturnPtr(ppDevice);
+    InitReturnPtr(ppImmediateContext);
 
-    if (!std::exchange(s_errorShown, true))
-      Logger::err("D3D11On12CreateDevice: Not implemented");
+    if (pChosenFeatureLevel)
+      *pChosenFeatureLevel = D3D_FEATURE_LEVEL(0);
 
-    return E_NOTIMPL;
+    if (!pDevice)
+      return E_INVALIDARG;
+
+    // Figure out D3D12 objects
+    Com<ID3D12Device> d3d12Device;
+    Com<ID3D12CommandQueue> d3d12Queue;
+
+    if (FAILED(pDevice->QueryInterface(__uuidof(ID3D12Device), reinterpret_cast<void**>(&d3d12Device)))) {
+      Logger::err("D3D11On12CreateDevice: Device is not a valid D3D12 device");
+      return E_INVALIDARG;
+    }
+
+    if (NodeMask & (NodeMask - 1)) {
+      Logger::err("D3D11On12CreateDevice: Invalid node mask");
+      return E_INVALIDARG;
+    }
+
+    if (!NumQueues || !ppCommandQueues || !ppCommandQueues[0]) {
+      Logger::err("D3D11On12CreateDevice: No command queue specified");
+      return E_INVALIDARG;
+    }
+
+    if (NumQueues > 1) {
+      // Not sure what to do with more than one graphics queue
+      Logger::warn("D3D11On12CreateDevice: Only one queue supported");
+    }
+
+    if (FAILED(ppCommandQueues[0]->QueryInterface(__uuidof(ID3D12CommandQueue), reinterpret_cast<void**>(&d3d12Queue)))) {
+      Logger::err("D3D11On12CreateDevice: Queue is not a valid D3D12 command queue");
+      return E_INVALIDARG;
+    }
+
+    // Determine feature level for the D3D11 device
+    std::array<D3D_FEATURE_LEVEL, 4> defaultFeatureLevels = {{
+      D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_11_1,
+      D3D_FEATURE_LEVEL_12_0, D3D_FEATURE_LEVEL_12_1,
+    }};
+
+    D3D12_FEATURE_DATA_FEATURE_LEVELS featureLevel = { };
+
+    if (!FeatureLevels || !pFeatureLevels) {
+      featureLevel.NumFeatureLevels = defaultFeatureLevels.size();
+      featureLevel.pFeatureLevelsRequested = defaultFeatureLevels.data();
+    } else {
+      featureLevel.NumFeatureLevels = FeatureLevels;
+      featureLevel.pFeatureLevelsRequested = pFeatureLevels;
+    }
+
+    HRESULT hr = d3d12Device->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &featureLevel, sizeof(featureLevel));
+
+    if (FAILED(hr) || !featureLevel.MaxSupportedFeatureLevel) {
+      Logger::err(str::format("D3D11On12CreateDevice: Minimum required feature level not supported"));
+      return hr;
+    }
+
+    Logger::info(str::format("D3D11On12CreateDevice: Chosen feature level: ", featureLevel.MaxSupportedFeatureLevel));
+
+    Com<ID3D12DXVKInteropDevice> interopDevice;
+
+    if (FAILED(d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast<void**>(&interopDevice)))) {
+      Logger::err("D3D11On12CreateDevice: Device not a vkd3d-proton device.");
+      return E_INVALIDARG;
+    }
+
+    Com<IDXGIAdapter> dxgiAdapter;
+
+    if (FAILED(interopDevice->GetDXGIAdapter(IID_PPV_ARGS(&dxgiAdapter)))) {
+      Logger::err("D3D11On12CreateDevice: Failed to query DXGI adapter.");
+      return E_INVALIDARG;
+    }
+
+    try {
+      // Initialize DXVK instance
+      DxvkInstanceImportInfo instanceInfo = { };
+      DxvkDeviceImportInfo deviceInfo = { };
+      VkPhysicalDevice vulkanAdapter = VK_NULL_HANDLE;
+
+      interopDevice->GetVulkanHandles(&instanceInfo.instance, &vulkanAdapter, &deviceInfo.device);
+
+      uint32_t instanceExtensionCount = 0;
+      interopDevice->GetInstanceExtensions(&instanceExtensionCount, nullptr);
+
+      std::vector<const char*> instanceExtensions(instanceExtensionCount);
+      interopDevice->GetInstanceExtensions(&instanceExtensionCount, instanceExtensions.data());
+
+      instanceInfo.extensionCount = instanceExtensions.size();
+      instanceInfo.extensionNames = instanceExtensions.data();
+
+      Rc<DxvkInstance> dxvkInstance = new DxvkInstance(instanceInfo, 0);
+
+      // Find adapter by physical device handle
+      Rc<DxvkAdapter> dxvkAdapter;
+
+      for (uint32_t i = 0; i < dxvkInstance->adapterCount(); i++) {
+        Rc<DxvkAdapter> curr = dxvkInstance->enumAdapters(i);
+
+        if (curr->handle() == vulkanAdapter)
+          dxvkAdapter = std::move(curr);
+      }
+
+      if (dxvkAdapter == nullptr) {
+        Logger::err("D3D11On12CreateDevice: No matching adapter found");
+        return E_INVALIDARG;
+      }
+
+      interopDevice->GetVulkanQueueInfo(d3d12Queue.ptr(), &deviceInfo.queue, &deviceInfo.queueFamily);
+      interopDevice->GetDeviceFeatures(&deviceInfo.features);
+
+      uint32_t deviceExtensionCount = 0;
+      interopDevice->GetDeviceExtensions(&deviceExtensionCount, nullptr);
+
+      std::vector<const char*> deviceExtensions(deviceExtensionCount);
+      interopDevice->GetDeviceExtensions(&deviceExtensionCount, deviceExtensions.data());
+
+      deviceInfo.extensionCount = deviceExtensions.size();
+      deviceInfo.extensionNames = deviceExtensions.data();
+
+      deviceInfo.queueCallback = [
+        cDevice = interopDevice,
+        cQueue = d3d12Queue
+      ] (bool doLock) {
+        HRESULT hr = doLock
+          ? cDevice->LockCommandQueue(cQueue.ptr())
+          : cDevice->UnlockCommandQueue(cQueue.ptr());
+
+        if (FAILED(hr))
+          Logger::err(str::format("Failed to lock vkd3d-proton device queue: ", hr));
+      };
+
+      Rc<DxvkDevice> dxvkDevice = dxvkAdapter->importDevice(dxvkInstance, deviceInfo);
+
+      // Create and return the actual D3D11 device
+      Com<D3D11DXGIDevice> device = new D3D11DXGIDevice(
+        dxgiAdapter.ptr(), d3d12Device.ptr(), d3d12Queue.ptr(),
+        dxvkInstance, dxvkAdapter, dxvkDevice,
+        featureLevel.MaxSupportedFeatureLevel, Flags);
+
+      Com<ID3D11Device> d3d11Device;
+      device->QueryInterface(__uuidof(ID3D11Device), reinterpret_cast<void**>(&d3d11Device));
+
+      if (ppDevice)
+        *ppDevice = d3d11Device.ref();
+
+      if (ppImmediateContext)
+        d3d11Device->GetImmediateContext(ppImmediateContext);
+
+      if (pChosenFeatureLevel)
+        *pChosenFeatureLevel = d3d11Device->GetFeatureLevel();
+
+      if (!ppDevice && !ppImmediateContext)
+        return S_FALSE;
+
+      return S_OK;
+    } catch (const DxvkError& e) {
+      Logger::err("D3D11On12CreateDevice: Failed to create D3D11 device");
+      return E_FAIL;
+    }
   }
 
 }

src/d3d11/d3d11_on_12.cpp

@@ -0,0 +1,150 @@
+#include "d3d11_context_imm.h"
+#include "d3d11_device.h"
+#include "d3d11_on_12.h"
+
+namespace dxvk {
+
+  D3D11on12Device::D3D11on12Device(
+          D3D11DXGIDevice*        pContainer,
+          D3D11Device*            pDevice,
+          ID3D12Device*           pD3D12Device,
+          ID3D12CommandQueue*     pD3D12Queue)
+  : m_container   (pContainer),
+    m_device      (pDevice),
+    m_d3d12Device (pD3D12Device),
+    m_d3d12Queue  (pD3D12Queue) {
+
+  }
+
+
+  D3D11on12Device::~D3D11on12Device() {
+
+  }
+
+
+  ULONG STDMETHODCALLTYPE D3D11on12Device::AddRef() {
+    return m_container->AddRef();
+  }
+  
+
+  ULONG STDMETHODCALLTYPE D3D11on12Device::Release() {
+    return m_container->Release();
+  }
+  
+
+  HRESULT STDMETHODCALLTYPE D3D11on12Device::QueryInterface(
+          REFIID                  riid,
+          void**                  ppvObject) {
+    return m_container->QueryInterface(riid, ppvObject);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11on12Device::CreateWrappedResource(
+          IUnknown*               pResource12,
+    const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+          D3D12_RESOURCE_STATES   InputState,
+          D3D12_RESOURCE_STATES   OutputState,
+          REFIID                  riid,
+          void**                  ppResource11) {
+    Com<ID3D12DXVKInteropDevice> interopDevice;
+    m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast<void**>(&interopDevice));
+
+    D3D11_ON_12_RESOURCE_INFO info = { };
+    info.InputState = InputState;
+    info.OutputState = OutputState;
+    info.IsWrappedResource = TRUE;
+
+    // 11on12 technically allows importing D3D12 heaps as tile pools,
+    // but we don't support importing sparse resources at this time.
+    if (FAILED(pResource12->QueryInterface(__uuidof(ID3D12Resource), reinterpret_cast<void**>(&info.Resource)))) {
+      Logger::err("D3D11on12Device::CreateWrappedResource: Resource not a valid D3D12 resource");
+      return E_INVALIDARG;
+    }
+
+    // Query Vulkan resource handle and buffer offset as necessary
+    if (FAILED(interopDevice->GetVulkanResourceInfo(info.Resource.ptr(), &info.VulkanHandle, &info.VulkanOffset))) {
+      Logger::err("D3D11on12Device::CreateWrappedResource: Failed to retrieve Vulkan resource info");
+      return E_INVALIDARG;
+    }
+
+    Com<ID3D11Resource> resource;
+    D3D12_RESOURCE_DESC desc = info.Resource->GetDesc();
+
+    if (desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) {
+      D3D11_BUFFER_DESC bufferDesc;
+
+      if (FAILED(D3D11Buffer::GetDescFromD3D12(info.Resource.ptr(), pResourceFlags, &bufferDesc)))
+        return E_INVALIDARG;
+
+      resource = new D3D11Buffer(m_device, &bufferDesc, &info);
+    } else {
+      D3D11_COMMON_TEXTURE_DESC textureDesc;
+
+      if (FAILED(D3D11CommonTexture::GetDescFromD3D12(info.Resource.ptr(), pResourceFlags, &textureDesc)))
+        return E_INVALIDARG;
+
+      switch (desc.Dimension) {
+        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+          resource = new D3D11Texture1D(m_device, &textureDesc, &info);
+          break;
+
+        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+          resource = new D3D11Texture2D(m_device, &textureDesc, &info, nullptr);
+          break;
+
+        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+          resource = new D3D11Texture3D(m_device, &textureDesc, &info);
+          break;
+
+        default:
+          Logger::err("D3D11on12Device::CreateWrappedResource: Unhandled resource dimension");
+          return E_INVALIDARG;
+      }
+    }
+
+    return resource->QueryInterface(riid, ppResource11);
+  }
+
+
+  void STDMETHODCALLTYPE D3D11on12Device::ReleaseWrappedResources(
+          ID3D11Resource* const*  ppResources,
+          UINT                    ResourceCount) {
+    Com<ID3D12DXVKInteropDevice> interopDevice;
+    m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast<void**>(&interopDevice));
+
+    for (uint32_t i = 0; i < ResourceCount; i++) {
+      D3D11_ON_12_RESOURCE_INFO info;
+
+      if (FAILED(GetResource11on12Info(ppResources[i], &info)) || !info.IsWrappedResource) {
+        Logger::warn("D3D11on12Device::ReleaseWrappedResources: Resource not a wrapped resource, skipping");
+        continue;
+      }
+
+      VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
+      interopDevice->GetVulkanImageLayout(info.Resource.ptr(), info.OutputState, &layout);
+      m_device->GetContext()->Release11on12Resource(ppResources[i], layout);
+    }
+  }
+
+
+  void STDMETHODCALLTYPE D3D11on12Device::AcquireWrappedResources(
+          ID3D11Resource* const*  ppResources,
+          UINT                    ResourceCount) {
+    Com<ID3D12DXVKInteropDevice> interopDevice;
+    m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast<void**>(&interopDevice));
+
+    for (uint32_t i = 0; i < ResourceCount; i++) {
+      D3D11_ON_12_RESOURCE_INFO info;
+
+      if (FAILED(GetResource11on12Info(ppResources[i], &info)) || !info.IsWrappedResource) {
+        Logger::warn("D3D11on12Device::AcquireWrappedResources: Resource not a wrapped resource, skipping");
+        continue;
+      }
+
+      VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
+      interopDevice->GetVulkanImageLayout(info.Resource.ptr(), info.InputState, &layout);
+      m_device->GetContext()->Acquire11on12Resource(ppResources[i], layout);
+    }
+  }
+
+}

src/d3d11/d3d11_on_12.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "d3d11_on_12_interfaces.h"
+
+#include "../util/log/log.h"
+
+namespace dxvk {
+
+  class D3D11Device;
+  class D3D11DXGIDevice;
+
+  /**
+   * \brief Resource info for 11on12 resources
+   */
+  struct D3D11_ON_12_RESOURCE_INFO {
+    Com<ID3D12Resource> Resource;
+    UINT64 VulkanHandle = 0;
+    UINT64 VulkanOffset = 0;
+    BOOL IsWrappedResource = FALSE;
+    D3D12_RESOURCE_STATES InputState = D3D12_RESOURCE_STATE_COMMON;
+    D3D12_RESOURCE_STATES OutputState = D3D12_RESOURCE_STATE_COMMON;
+  };
+
+
+  class D3D11on12Device : public ID3D11On12Device {
+
+  public:
+
+    D3D11on12Device(
+            D3D11DXGIDevice*        pContainer,
+            D3D11Device*            pDevice,
+            ID3D12Device*           pD3D12Device,
+            ID3D12CommandQueue*     pD3D12Queue);
+
+    ~D3D11on12Device();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+    
+    ULONG STDMETHODCALLTYPE Release();
+    
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    HRESULT STDMETHODCALLTYPE CreateWrappedResource(
+            IUnknown*               pResource12,
+      const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+            D3D12_RESOURCE_STATES   InputState,
+            D3D12_RESOURCE_STATES   OutputState,
+            REFIID                  riid,
+            void**                  ppResource11);
+
+    void STDMETHODCALLTYPE ReleaseWrappedResources(
+            ID3D11Resource* const*  ppResources,
+            UINT                    ResourceCount);
+
+    void STDMETHODCALLTYPE AcquireWrappedResources(
+            ID3D11Resource* const*  ppResources,
+            UINT                    ResourceCount);
+
+    bool Is11on12Device() const {
+      return m_d3d12Device != nullptr;
+    }
+
+  private:
+
+    D3D11DXGIDevice*        m_container;
+    D3D11Device*            m_device;
+
+    Com<ID3D12Device>       m_d3d12Device;
+    Com<ID3D12CommandQueue> m_d3d12Queue;
+
+  };
+
+}

src/d3d11/d3d11_on_12_interfaces.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "../vulkan/vulkan_loader.h"
+
+#include <d3d11on12.h>
+
+MIDL_INTERFACE("39da4e09-bd1c-4198-9fae-86bbe3be41fd")
+ID3D12DXVKInteropDevice : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetDXGIAdapter(
+          REFIID                      iid,
+          void**                      ppvObject) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetInstanceExtensions(
+          UINT*                       pExtensionCount,
+    const char**                      ppExtensions) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetDeviceExtensions(
+          UINT*                       pExtensionCount,
+    const char**                      ppExtensions) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetDeviceFeatures(
+    const VkPhysicalDeviceFeatures2** ppFeatures) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetVulkanHandles(
+          VkInstance*                 pVkInstance,
+          VkPhysicalDevice*           pVkPhysicalDevice,
+          VkDevice*                   pVkDevice) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetVulkanQueueInfo(
+          ID3D12CommandQueue*         pCommandQueue,
+          VkQueue*                    pVkQueue,
+          UINT32*                     pVkQueueFamily) = 0;
+
+  virtual void STDMETHODCALLTYPE GetVulkanImageLayout(
+          ID3D12Resource*             pResource,
+          D3D12_RESOURCE_STATES       State,
+          VkImageLayout*              pVkLayout) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetVulkanResourceInfo(
+          ID3D12Resource*             pResource,
+          UINT64*                     pVkHandle,
+          UINT64*                     pBufferOffset) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE LockCommandQueue(
+          ID3D12CommandQueue*         pCommandQueue) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE UnlockCommandQueue(
+          ID3D12CommandQueue*         pCommandQueue) = 0;
+
+};
+
+#ifndef _MSC_VER
+__CRT_UUID_DECL(ID3D12DXVKInteropDevice, 0x39da4e09, 0xbd1c, 0x4198, 0x9f,0xae, 0x86,0xbb,0xe3,0xbe,0x41,0xfd)
+#endif

src/d3d11/d3d11_options.cpp

@@ -12,9 +12,8 @@ namespace dxvk {
 #endif
   }
 
-  D3D11Options::D3D11Options(const Config& config, const Rc<DxvkDevice>& device) {
+  D3D11Options::D3D11Options(const Config& config) {
     this->dcSingleUseMode       = config.getOption<bool>("d3d11.dcSingleUseMode", true);
-    this->enableRtOutputNanFixup   = config.getOption<bool>("d3d11.enableRtOutputNanFixup", false);
     this->zeroInitWorkgroupMemory  = config.getOption<bool>("d3d11.zeroInitWorkgroupMemory", false);
     this->forceVolatileTgsmAccess = config.getOption<bool>("d3d11.forceVolatileTgsmAccess", false);
     this->relaxedBarriers       = config.getOption<bool>("d3d11.relaxedBarriers", false);
@@ -22,16 +21,18 @@ namespace dxvk {
     this->maxTessFactor         = config.getOption<int32_t>("d3d11.maxTessFactor", 0);
     this->samplerAnisotropy     = config.getOption<int32_t>("d3d11.samplerAnisotropy", -1);
     this->samplerLodBias        = config.getOption<float>("d3d11.samplerLodBias", 0.0f);
+    this->clampNegativeLodBias  = config.getOption<bool>("d3d11.clampNegativeLodBias", false);
     this->invariantPosition     = config.getOption<bool>("d3d11.invariantPosition", true);
     this->floatControls         = config.getOption<bool>("d3d11.floatControls", true);
+    this->forceSampleRateShading = config.getOption<bool>("d3d11.forceSampleRateShading", false);
     this->disableMsaa           = config.getOption<bool>("d3d11.disableMsaa", false);
     this->enableContextLock     = config.getOption<bool>("d3d11.enableContextLock", false);
     this->deferSurfaceCreation  = config.getOption<bool>("dxgi.deferSurfaceCreation", false);
     this->numBackBuffers        = config.getOption<int32_t>("dxgi.numBackBuffers", 0);
     this->maxFrameLatency       = config.getOption<int32_t>("dxgi.maxFrameLatency", 0);
     this->maxFrameRate          = config.getOption<int32_t>("dxgi.maxFrameRate", 0);
-    this->syncInterval          = config.getOption<int32_t>("dxgi.syncInterval", -1);
-    this->tearFree              = config.getOption<Tristate>("dxgi.tearFree", Tristate::Auto);
+    this->exposeDriverCommandLists = config.getOption<bool>("d3d11.exposeDriverCommandLists", true);
+    this->longMad               = config.getOption<bool>("d3d11.longMad", false);
 
     // Clamp LOD bias so that people don't abuse this in unintended ways
     this->samplerLodBias = dxvk::fclamp(this->samplerLodBias, -2.0f, 1.0f);

src/d3d11/d3d11_options.h

@@ -11,7 +11,7 @@
 namespace dxvk {
 
   struct D3D11Options {
-    D3D11Options(const Config& config, const Rc<DxvkDevice>& device);
+    D3D11Options(const Config& config);
 
     /// Enables speed hack for mapping on deferred contexts
     ///
@@ -20,10 +20,6 @@ namespace dxvk {
     /// than once.
     bool dcSingleUseMode;
 
-    /// Enables workaround to replace NaN render target
-    /// outputs with zero
-    bool enableRtOutputNanFixup;
-
     /// Zero-initialize workgroup memory
     ///
     /// Workargound for games that don't initialize
@@ -67,6 +63,9 @@ namespace dxvk {
     /// Enforces the given LOD bias for all samplers.
     float samplerLodBias;
 
+    /// Clamps negative LOD bias
+    bool clampNegativeLodBias;
+
     /// Declare vertex positions in shaders as invariant
     bool invariantPosition;
 
@@ -77,14 +76,6 @@ namespace dxvk {
     /// Overrides DXGI_SWAP_CHAIN_DESC::BufferCount.
     int32_t numBackBuffers;
 
-    /// Sync interval. Overrides the value
-    /// passed to IDXGISwapChain::Present.
-    int32_t syncInterval;
-
-    /// Tear-free mode if vsync is disabled
-    /// Tearing mode if vsync is enabled
-    Tristate tearFree;
-
     /// Override maximum frame latency if the app specifies
     /// a higher value. May help with frame timing issues.
     int32_t maxFrameLatency;
@@ -103,6 +94,11 @@ namespace dxvk {
     /// for a single window that may interfere with each other.
     bool deferSurfaceCreation;
 
+    /// Enables sample rate shading by interpolating fragment shader
+    /// inputs at the sample location rather than pixel center,
+    /// unless otherwise specified by the application.
+    bool forceSampleRateShading;
+
     /// Forces the sample count of all textures to be 1, and
     /// performs the required shader and resolve fixups.
     bool disableMsaa;
@@ -117,8 +113,16 @@ namespace dxvk {
     /// race conditions.
     bool enableContextLock;
 
+    /// Whether to expose the driver command list feature. Enabled by
+    /// default and generally beneficial, but some games may assume that
+    /// this is not supported when running on an AMD GPU.
+    bool exposeDriverCommandLists;
+
     /// Shader dump path
     std::string shaderDumpPath;
+
+    /// Should we make our Mads a FFma or do it the long way with an FMul and an FAdd?
+    bool longMad;
   };
   
 }

src/d3d11/d3d11_query.cpp

@@ -120,8 +120,11 @@ namespace dxvk {
       }
     }
     
-    Logger::warn("D3D11Query: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11Query), riid)) {
+      Logger::warn("D3D11Query: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_rasterizer.cpp

@@ -38,13 +38,22 @@ namespace dxvk {
     m_state.conservativeMode  = DecodeConservativeRasterizationMode(desc.ConservativeRaster);
     m_state.sampleCount       = VkSampleCountFlags(desc.ForcedSampleCount);
     m_state.flatShading       = VK_FALSE;
+    m_state.lineMode          = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
 
     m_depthBias.depthBiasConstant = float(desc.DepthBias);
     m_depthBias.depthBiasSlope    = desc.SlopeScaledDepthBias;
     m_depthBias.depthBiasClamp    = desc.DepthBiasClamp;
     
-    if (desc.AntialiasedLineEnable)
-      Logger::err("D3D11RasterizerState: Antialiased lines not supported");
+    // Set up line rasterization mode
+    const auto& features = device->GetDXVKDevice()->features();
+
+    if (desc.MultisampleEnable) {
+      if (features.extLineRasterization.rectangularLines)
+        m_state.lineMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT;
+    } else if (desc.AntialiasedLineEnable) {
+      if (features.extLineRasterization.smoothLines)
+        m_state.lineMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT;
+    }
   }
   
   
@@ -74,8 +83,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11RasterizerState::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11RasterizerState), riid)) {
+      Logger::warn("D3D11RasterizerState::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_resource.cpp

@@ -1,14 +1,138 @@
 #include "d3d11_buffer.h"
 #include "d3d11_texture.h"
 #include "d3d11_resource.h"
+#include "d3d11_context_imm.h"
+#include "d3d11_device.h"
 
 #include "../util/util_shared_res.h"
 
 namespace dxvk {
 
+  D3D11DXGIKeyedMutex::D3D11DXGIKeyedMutex(
+          ID3D11Resource* pResource,
+          D3D11Device*    pDevice)
+  : m_resource(pResource),
+    m_device(pDevice) {
+
+    m_supported = m_device->GetDXVKDevice()->features().khrWin32KeyedMutex
+               && m_device->GetDXVKDevice()->vkd()->wine_vkAcquireKeyedMutex != nullptr
+               && m_device->GetDXVKDevice()->vkd()->wine_vkReleaseKeyedMutex != nullptr;
+  }
+
+
+  D3D11DXGIKeyedMutex::~D3D11DXGIKeyedMutex() {
+
+  }
+
+
+  ULONG STDMETHODCALLTYPE D3D11DXGIKeyedMutex::AddRef() {
+    return m_resource->AddRef();
+  }
+
+
+  ULONG STDMETHODCALLTYPE D3D11DXGIKeyedMutex::Release() {
+    return m_resource->Release();
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::QueryInterface(
+          REFIID                  riid,
+          void**                  ppvObject) {
+    return m_resource->QueryInterface(riid, ppvObject);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetPrivateData(
+          REFGUID                 Name,
+          UINT*                   pDataSize,
+          void*                   pData) {
+    return m_resource->GetPrivateData(Name, pDataSize, pData);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::SetPrivateData(
+          REFGUID                 Name,
+          UINT                    DataSize,
+    const void*                   pData) {
+    return m_resource->SetPrivateData(Name, DataSize, pData);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::SetPrivateDataInterface(
+          REFGUID                 Name,
+    const IUnknown*               pUnknown) {
+    return m_resource->SetPrivateDataInterface(Name, pUnknown);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetParent(
+          REFIID                  riid,
+          void**                  ppParent) {
+    return GetDevice(riid, ppParent);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetDevice(
+          REFIID                  riid,
+          void**                  ppDevice) {
+    Com<ID3D11Device> device;
+    m_resource->GetDevice(&device);
+    return device->QueryInterface(riid, ppDevice);
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::AcquireSync(
+          UINT64                  Key,
+          DWORD                   dwMilliseconds) {
+    if (!m_supported) {
+      if (!m_warned) {
+        m_warned = true;
+        Logger::err("D3D11DXGIKeyedMutex::AcquireSync: Not supported");
+      }
+      return S_OK;
+    }
+
+    D3D11CommonTexture* texture = GetCommonTexture(m_resource);
+    Rc<DxvkDevice> dxvkDevice = m_device->GetDXVKDevice();
+
+    VkResult vr = dxvkDevice->vkd()->wine_vkAcquireKeyedMutex(dxvkDevice->handle(), texture->GetImage()->memory().memory(), Key, dwMilliseconds);
+    switch (vr) {
+      case VK_SUCCESS: return S_OK;
+      case VK_TIMEOUT: return WAIT_TIMEOUT;
+      default:         return DXGI_ERROR_INVALID_CALL;
+    }
+  }
+
+  HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::ReleaseSync(
+          UINT64                  Key) {
+    if (!m_supported)
+      return S_OK;
+
+    D3D11CommonTexture* texture = GetCommonTexture(m_resource);
+    Rc<DxvkDevice> dxvkDevice = m_device->GetDXVKDevice();
+
+    {
+      D3D11ImmediateContext* context = m_device->GetContext();
+      D3D10Multithread& multithread = context->GetMultithread();
+      static bool s_errorShown = false;
+
+      if (!multithread.GetMultithreadProtected() && !std::exchange(s_errorShown, true))
+        Logger::warn("D3D11DXGIKeyedMutex::ReleaseSync: Called without context locking enabled.");
+
+      D3D10DeviceLock lock = context->LockContext();
+      context->WaitForResource(texture->GetImage(), DxvkCsThread::SynchronizeAll, D3D11_MAP_READ_WRITE, 0);
+    }
+
+    return dxvkDevice->vkd()->wine_vkReleaseKeyedMutex(dxvkDevice->handle(), texture->GetImage()->memory().memory(), Key) == VK_SUCCESS
+      ? S_OK
+      : DXGI_ERROR_INVALID_CALL;
+  }
+
   D3D11DXGIResource::D3D11DXGIResource(
-          ID3D11Resource*         pResource)
-  : m_resource(pResource) {
+          ID3D11Resource*         pResource,
+          D3D11Device*            pDevice)
+  : m_resource(pResource),
+    m_keyedMutex(pResource, pDevice) {
 
   }
 
@@ -84,9 +208,15 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11DXGIResource::GetSharedHandle(
           HANDLE*                 pSharedHandle) {
     auto texture = GetCommonTexture(m_resource);
-    if (texture == nullptr || pSharedHandle == nullptr || !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED))
+    if (texture == nullptr || pSharedHandle == nullptr ||
+        (texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE))
       return E_INVALIDARG;
 
+    if (!(texture->Desc()->MiscFlags & (D3D11_RESOURCE_MISC_SHARED | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX))) {
+      *pSharedHandle = NULL;
+      return S_OK;
+    }
+
     HANDLE kmtHandle = texture->GetImage()->sharedHandle();
 
     if (kmtHandle == INVALID_HANDLE_VALUE)
@@ -143,8 +273,9 @@ namespace dxvk {
           LPCWSTR                 lpName,
           HANDLE*                 pHandle) {
     auto texture = GetCommonTexture(m_resource);
+    if (pHandle) *pHandle = nullptr;
     if (texture == nullptr || pHandle == nullptr ||
-        !(texture->Desc()->MiscFlags & (D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX | D3D11_RESOURCE_MISC_SHARED_NTHANDLE)))
+        !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE))
       return E_INVALIDARG;
 
     if (lpName)
@@ -155,9 +286,6 @@ namespace dxvk {
     if (handle == INVALID_HANDLE_VALUE)
       return E_INVALIDARG;
 
-    if (texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED)
-      handle = openKmtHandle( handle );
-
     *pHandle = handle;
     return S_OK;
   }
@@ -172,6 +300,36 @@ namespace dxvk {
   }
   
 
+  HRESULT D3D11DXGIResource::GetKeyedMutex(
+          void **ppvObject) {
+    auto texture = GetCommonTexture(m_resource);
+    if (texture == nullptr || !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX))
+      return E_NOINTERFACE;
+    *ppvObject = ref(&m_keyedMutex);
+    return S_OK;
+  }
+
+
+  HRESULT GetResource11on12Info(
+          ID3D11Resource*             pResource,
+          D3D11_ON_12_RESOURCE_INFO*  p11on12Info) {
+    auto buffer   = GetCommonBuffer (pResource);
+    auto texture  = GetCommonTexture(pResource);
+
+    if (buffer != nullptr)
+      *p11on12Info = buffer->Get11on12Info();
+    else if (texture != nullptr)
+      *p11on12Info = texture->Get11on12Info();
+    else
+      return E_INVALIDARG;
+
+    if (p11on12Info->Resource == nullptr)
+      return E_INVALIDARG;
+
+    return S_OK;
+  }
+
+
   HRESULT GetCommonResourceDesc(
           ID3D11Resource*             pResource,
           D3D11_COMMON_RESOURCE_DESC* pDesc) {

src/d3d11/d3d11_resource.h

@@ -22,6 +22,65 @@ namespace dxvk {
   };
   
 
+  /**
+   * \brief IDXGIKeyedMutex implementation
+   */
+  class D3D11DXGIKeyedMutex : public IDXGIKeyedMutex {
+
+  public:
+
+    D3D11DXGIKeyedMutex(
+            ID3D11Resource*         pResource,
+            D3D11Device*            pDevice);
+
+    ~D3D11DXGIKeyedMutex();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+
+    ULONG STDMETHODCALLTYPE Release();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    HRESULT STDMETHODCALLTYPE GetPrivateData(
+            REFGUID                 Name,
+            UINT*                   pDataSize,
+            void*                   pData);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateData(
+            REFGUID                 Name,
+            UINT                    DataSize,
+      const void*                   pData);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
+            REFGUID                 Name,
+      const IUnknown*               pUnknown);
+
+    HRESULT STDMETHODCALLTYPE GetParent(
+            REFIID                  riid,
+            void**                  ppParent);
+
+    HRESULT STDMETHODCALLTYPE GetDevice(
+            REFIID                  riid,
+            void**                  ppDevice);
+
+    HRESULT STDMETHODCALLTYPE AcquireSync(
+            UINT64                  Key,
+            DWORD                   dwMilliseconds);
+
+    HRESULT STDMETHODCALLTYPE ReleaseSync(
+            UINT64                  Key);
+
+  private:
+
+    ID3D11Resource* m_resource;
+    D3D11Device* m_device;
+    bool m_warned = false;
+    bool m_supported = false;
+  };
+
+
   /**
    * \brief IDXGIResource implementation for D3D11 resources
    */
@@ -30,7 +89,8 @@ namespace dxvk {
   public:
     
     D3D11DXGIResource(
-            ID3D11Resource*         pResource);
+            ID3D11Resource*         pResource,
+            D3D11Device*            pDevice);
 
     ~D3D11DXGIResource();
 
@@ -86,13 +146,27 @@ namespace dxvk {
             UINT                    index,
             IDXGISurface2**         ppSurface);
 
+    HRESULT GetKeyedMutex(void **ppvObject);
+
   private:
 
     ID3D11Resource* m_resource;
+    D3D11DXGIKeyedMutex m_keyedMutex;
 
   };
 
 
+  /**
+   * \brief Queries D3D11on12 resource info
+   *
+   * \param [in] pResource The resource to query
+   * \param [out] p11on12Info 11on12 info
+   * \returns \c S_OK on success, or \c E_INVALIDARG
+   */
+  HRESULT GetResource11on12Info(
+          ID3D11Resource*             pResource,
+          D3D11_ON_12_RESOURCE_INFO*  p11on12Info);
+
   /**
    * \brief Queries common resource description
    * 
@@ -261,4 +335,4 @@ namespace dxvk {
 
   };
 
-}
+}

src/d3d11/d3d11_sampler.cpp

@@ -47,9 +47,13 @@ namespace dxvk {
     if (desc.MaxAnisotropy > 16) info.maxAnisotropy = 16.0f;
     
     // Enforce LOD bias specified in the device options
-    if (info.minFilter == VK_FILTER_LINEAR && info.magFilter == VK_FILTER_LINEAR)
+    if (info.minFilter == VK_FILTER_LINEAR && info.magFilter == VK_FILTER_LINEAR) {
       info.mipmapLodBias += device->GetOptions()->samplerLodBias;
 
+      if (device->GetOptions()->clampNegativeLodBias)
+        info.mipmapLodBias = std::max(info.mipmapLodBias, 0.0f);
+    }
+
     // Enforce anisotropy specified in the device options
     int32_t samplerAnisotropyOption = device->GetOptions()->samplerAnisotropy;
 
@@ -86,8 +90,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11SamplerState::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11SamplerState), riid)) {
+      Logger::warn("D3D11SamplerState::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_shader.cpp

@@ -20,8 +20,6 @@ namespace dxvk {
       reinterpret_cast<const char*>(pShaderBytecode),
       BytecodeLength);
     
-    DxbcModule module(reader);
-    
     // If requested by the user, dump both the raw DXBC
     // shader and the compiled SPIR-V module to a file.
     const std::string& dumpPath = pDevice->GetOptions()->shaderDumpPath;
@@ -30,14 +28,21 @@ namespace dxvk {
       reader.store(std::ofstream(str::topath(str::format(dumpPath, "/", name, ".dxbc").c_str()).c_str(),
         std::ios_base::binary | std::ios_base::trunc));
     }
-    
+
+    // Error out if the shader is invalid
+    DxbcModule module(reader);
+    auto programInfo = module.programInfo();
+
+    if (!programInfo)
+      throw DxvkError("Invalid shader binary.");
+
     // Decide whether we need to create a pass-through
     // geometry shader for vertex shader stream output
     bool passthroughShader = pDxbcModuleInfo->xfb != nullptr
-      && (module.programInfo().type() == DxbcProgramType::VertexShader
-       || module.programInfo().type() == DxbcProgramType::DomainShader);
+      && (programInfo->type() == DxbcProgramType::VertexShader
+       || programInfo->type() == DxbcProgramType::DomainShader);
 
-    if (module.programInfo().shaderStage() != pShaderKey->type() && !passthroughShader)
+    if (programInfo->shaderStage() != pShaderKey->type() && !passthroughShader)
       throw DxvkError("Mismatching shader type.");
 
     m_shader = passthroughShader

src/d3d11/d3d11_shader.h

@@ -134,7 +134,11 @@ namespace dxvk {
         return S_OK;
       }
 
-      Logger::warn("D3D11Shader::QueryInterface: Unknown interface query");
+      if (logQueryInterfaceError(__uuidof(D3D11Interface), riid)) {
+        Logger::warn("D3D11Shader::QueryInterface: Unknown interface query");
+        Logger::warn(str::format(riid));
+      }
+
       return E_NOINTERFACE;
     }
     

src/d3d11/d3d11_state_object.cpp

@@ -29,8 +29,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11DeviceContextState::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3DDeviceContextState), riid)) {
+      Logger::warn("D3D11DeviceContextState::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 

src/d3d11/d3d11_swapchain.cpp

@@ -12,6 +12,46 @@ namespace dxvk {
     return uint16_t(65535.0f * x);
   }
 
+  static VkColorSpaceKHR ConvertColorSpace(DXGI_COLOR_SPACE_TYPE colorspace) {
+    switch (colorspace) {
+      case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709:    return VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+      case DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020: return VK_COLOR_SPACE_HDR10_ST2084_EXT;
+      case DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709:    return VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT;
+      default:
+        Logger::warn(str::format("DXGI: ConvertColorSpace: Unknown colorspace ", colorspace));
+        return VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+    }
+  }
+
+  static VkXYColorEXT ConvertXYColor(const UINT16 (&dxgiColor)[2]) {
+    return VkXYColorEXT{ float(dxgiColor[0]) / 50000.0f, float(dxgiColor[1]) / 50000.0f };
+  }
+
+  static float ConvertMaxLuminance(UINT dxgiLuminance) {
+    return float(dxgiLuminance);
+  }
+
+  static float ConvertMinLuminance(UINT dxgiLuminance) {
+    return float(dxgiLuminance) * 0.0001f;
+  }
+
+  static float ConvertLevel(UINT16 dxgiLevel) {
+    return float(dxgiLevel);
+  }
+
+  static VkHdrMetadataEXT ConvertHDRMetadata(const DXGI_HDR_METADATA_HDR10& dxgiMetadata) {
+    VkHdrMetadataEXT vkMetadata = { VK_STRUCTURE_TYPE_HDR_METADATA_EXT };
+    vkMetadata.displayPrimaryRed         = ConvertXYColor(dxgiMetadata.RedPrimary);
+    vkMetadata.displayPrimaryGreen       = ConvertXYColor(dxgiMetadata.GreenPrimary);
+    vkMetadata.displayPrimaryBlue        = ConvertXYColor(dxgiMetadata.BluePrimary);
+    vkMetadata.whitePoint                = ConvertXYColor(dxgiMetadata.WhitePoint);
+    vkMetadata.maxLuminance              = ConvertMaxLuminance(dxgiMetadata.MaxMasteringLuminance);
+    vkMetadata.minLuminance              = ConvertMinLuminance(dxgiMetadata.MinMasteringLuminance);
+    vkMetadata.maxContentLightLevel      = ConvertLevel(dxgiMetadata.MaxContentLightLevel);
+    vkMetadata.maxFrameAverageLightLevel = ConvertLevel(dxgiMetadata.MaxFrameAverageLightLevel);
+    return vkMetadata;
+  }
+
 
   D3D11SwapChain::D3D11SwapChain(
           D3D11DXGIDevice*        pContainer,
@@ -32,7 +72,7 @@ namespace dxvk {
     CreateHud();
 
     if (!pDevice->GetOptions()->deferSurfaceCreation)
-      RecreateSwapChain(false);
+      RecreateSwapChain();
   }
 
 
@@ -58,12 +98,17 @@ namespace dxvk {
     InitReturnPtr(ppvObject);
 
     if (riid == __uuidof(IUnknown)
-     || riid == __uuidof(IDXGIVkSwapChain)) {
+     || riid == __uuidof(IDXGIVkSwapChain)
+     || riid == __uuidof(IDXGIVkSwapChain1)) {
       *ppvObject = ref(this);
       return S_OK;
     }
 
-    Logger::warn("D3D11SwapChain::QueryInterface: Unknown interface query");
+    if (logQueryInterfaceError(__uuidof(IDXGIVkSwapChain), riid)) {
+      Logger::warn("D3D11SwapChain::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -116,12 +161,10 @@ namespace dxvk {
 
   HANDLE STDMETHODCALLTYPE D3D11SwapChain::GetFrameLatencyEvent() {
     HANDLE result = nullptr;
+    HANDLE processHandle = GetCurrentProcess();
 
-    if (!m_processHandle)
-      m_processHandle = GetCurrentProcess();
-
-    if (!DuplicateHandle(m_processHandle, m_frameLatencyEvent,
-        m_processHandle, &result, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+    if (!DuplicateHandle(processHandle, m_frameLatencyEvent,
+        processHandle, &result, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
       Logger::err("DxgiSwapChain::GetFrameLatencyWaitableObject: DuplicateHandle failed");
       return nullptr;
     }
@@ -211,22 +254,13 @@ namespace dxvk {
           UINT                      SyncInterval,
           UINT                      PresentFlags,
     const DXGI_PRESENT_PARAMETERS*  pPresentParameters) {
-    auto options = m_parent->GetOptions();
-
-    if (options->syncInterval >= 0)
-      SyncInterval = options->syncInterval;
-
-    if (!(PresentFlags & DXGI_PRESENT_TEST)) {
-      bool vsync = SyncInterval != 0;
-
-      m_dirty |= vsync != m_vsync;
-      m_vsync  = vsync;
-    }
+    if (!(PresentFlags & DXGI_PRESENT_TEST))
+      m_dirty |= m_presenter->setSyncInterval(SyncInterval) != VK_SUCCESS;
 
     HRESULT hr = S_OK;
 
     if (!m_presenter->hasSwapChain()) {
-      RecreateSwapChain(m_vsync);
+      RecreateSwapChain();
       m_dirty = false;
     }
 
@@ -236,19 +270,29 @@ namespace dxvk {
     if (m_device->getDeviceStatus() != VK_SUCCESS)
       hr = DXGI_ERROR_DEVICE_RESET;
 
-    if ((PresentFlags & DXGI_PRESENT_TEST) || hr != S_OK)
+    if (PresentFlags & DXGI_PRESENT_TEST)
       return hr;
 
+    if (hr != S_OK) {
+      SyncFrameLatency();
+      return hr;
+    }
+
     if (std::exchange(m_dirty, false))
-      RecreateSwapChain(m_vsync);
-    
+      RecreateSwapChain();
+
     try {
-      PresentImage(SyncInterval);
+      hr = PresentImage(SyncInterval);
     } catch (const DxvkError& e) {
       Logger::err(e.message());
       hr = E_FAIL;
     }
 
+    // Ensure to synchronize and release the frame latency semaphore
+    // even if presentation failed with STATUS_OCCLUDED, or otherwise
+    // applications using the semaphore may deadlock. This works because
+    // we do not increment the frame ID in those situations.
+    SyncFrameLatency();
     return hr;
   }
 
@@ -257,7 +301,8 @@ namespace dxvk {
           DXGI_COLOR_SPACE_TYPE     ColorSpace) {
     UINT supportFlags = 0;
 
-    if (ColorSpace == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709)
+    const VkColorSpaceKHR vkColorSpace = ConvertColorSpace(ColorSpace);
+    if (m_presenter->supportsColorSpace(vkColorSpace))
       supportFlags |= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT;
 
     return supportFlags;
@@ -266,7 +311,13 @@ namespace dxvk {
 
   HRESULT STDMETHODCALLTYPE D3D11SwapChain::SetColorSpace(
           DXGI_COLOR_SPACE_TYPE     ColorSpace) {
-    // Ignore, will only ever be sRGB
+    if (!(CheckColorSpaceSupport(ColorSpace) & DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT))
+      return E_INVALIDARG;
+
+    const VkColorSpaceKHR vkColorSpace = ConvertColorSpace(ColorSpace);
+    m_dirty |= vkColorSpace != m_colorspace;
+    m_colorspace = vkColorSpace;
+
     return S_OK;
   }
 
@@ -274,51 +325,63 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11SwapChain::SetHDRMetaData(
     const DXGI_VK_HDR_METADATA*     pMetaData) {
     // For some reason this call always seems to succeed on Windows
-    if (pMetaData->Type == DXGI_HDR_METADATA_TYPE_HDR10)
-      Logger::warn("D3D11: HDR10 metadata not supported");
+    if (pMetaData->Type == DXGI_HDR_METADATA_TYPE_HDR10) {
+      m_hdrMetadata = ConvertHDRMetadata(pMetaData->HDR10);
+      m_dirtyHdrMetadata = true;
+    }
 
     return S_OK;
   }
 
 
-  HRESULT D3D11SwapChain::PresentImage(UINT SyncInterval) {
-    Com<ID3D11DeviceContext> deviceContext = nullptr;
-    m_parent->GetImmediateContext(&deviceContext);
+  void STDMETHODCALLTYPE D3D11SwapChain::GetLastPresentCount(
+          UINT64*                   pLastPresentCount) {
+    *pLastPresentCount = UINT64(m_frameId - DXGI_MAX_SWAP_CHAIN_BUFFERS);
+  }
 
+
+  void STDMETHODCALLTYPE D3D11SwapChain::GetFrameStatistics(
+          DXGI_VK_FRAME_STATISTICS* pFrameStatistics) {
+    std::lock_guard<dxvk::mutex> lock(m_frameStatisticsLock);
+    *pFrameStatistics = m_frameStatistics;
+  }
+
+
+  HRESULT D3D11SwapChain::PresentImage(UINT SyncInterval) {
     // Flush pending rendering commands before
-    auto immediateContext = static_cast<D3D11ImmediateContext*>(deviceContext.ptr());
+    auto immediateContext = m_parent->GetContext();
     immediateContext->EndFrame();
     immediateContext->Flush();
 
-    // Bump our frame id.
-    ++m_frameId;
-    
     for (uint32_t i = 0; i < SyncInterval || i < 1; i++) {
       SynchronizePresent();
 
       if (!m_presenter->hasSwapChain())
-        return DXGI_STATUS_OCCLUDED;
+        return i ? S_OK : DXGI_STATUS_OCCLUDED;
 
       // Presentation semaphores and WSI swap chain image
-      vk::PresenterInfo info = m_presenter->info();
-      vk::PresenterSync sync;
+      PresenterInfo info = m_presenter->info();
+      PresenterSync sync;
 
       uint32_t imageIndex = 0;
 
       VkResult status = m_presenter->acquireNextImage(sync, imageIndex);
 
       while (status != VK_SUCCESS && status != VK_SUBOPTIMAL_KHR) {
-        RecreateSwapChain(m_vsync);
+        RecreateSwapChain();
 
         if (!m_presenter->hasSwapChain())
-          return DXGI_STATUS_OCCLUDED;
+          return i ? S_OK : DXGI_STATUS_OCCLUDED;
         
         info = m_presenter->info();
         status = m_presenter->acquireNextImage(sync, imageIndex);
       }
 
-      // Resolve back buffer if it is multisampled. We
-      // only have to do it only for the first frame.
+      if (m_hdrMetadata && m_dirtyHdrMetadata) {
+        m_presenter->setHdrMetadata(*m_hdrMetadata);
+        m_dirtyHdrMetadata = false;
+      }
+
       m_context->beginRecording(
         m_device->createCommandList());
       
@@ -329,40 +392,45 @@ namespace dxvk {
       if (m_hud != nullptr)
         m_hud->render(m_context, info.format, info.imageExtent);
       
-      if (i + 1 >= SyncInterval)
-        m_context->signal(m_frameLatencySignal, m_frameId);
-
       SubmitPresent(immediateContext, sync, i);
     }
 
-    SyncFrameLatency();
     return S_OK;
   }
 
 
   void D3D11SwapChain::SubmitPresent(
           D3D11ImmediateContext*  pContext,
-    const vk::PresenterSync&      Sync,
-          uint32_t                FrameId) {
+    const PresenterSync&          Sync,
+          uint32_t                Repeat) {
     auto lock = pContext->LockContext();
 
+    // Bump frame ID as necessary
+    if (!Repeat)
+      m_frameId += 1;
+
     // Present from CS thread so that we don't
     // have to synchronize with it first.
     m_presentStatus.result = VK_NOT_READY;
 
     pContext->EmitCs([this,
-      cFrameId     = FrameId,
+      cRepeat      = Repeat,
       cSync        = Sync,
       cHud         = m_hud,
+      cPresentMode = m_presenter->info().presentMode,
+      cFrameId     = m_frameId,
       cCommandList = m_context->endRecording()
     ] (DxvkContext* ctx) {
       cCommandList->setWsiSemaphores(cSync);
-      m_device->submitCommandList(cCommandList);
+      m_device->submitCommandList(cCommandList, nullptr);
 
-      if (cHud != nullptr && !cFrameId)
+      if (cHud != nullptr && !cRepeat)
         cHud->update();
 
-      m_device->presentImage(m_presenter, &m_presentStatus);
+      uint64_t frameId = cRepeat ? 0 : cFrameId;
+
+      m_device->presentImage(m_presenter,
+        cPresentMode, frameId, &m_presentStatus);
     });
 
     pContext->FlushCsChunk();
@@ -374,22 +442,22 @@ namespace dxvk {
     VkResult status = m_device->waitForSubmission(&m_presentStatus);
     
     if (status != VK_SUCCESS)
-      RecreateSwapChain(m_vsync);
+      RecreateSwapChain();
   }
 
 
-  void D3D11SwapChain::RecreateSwapChain(BOOL Vsync) {
+  void D3D11SwapChain::RecreateSwapChain() {
     // Ensure that we can safely destroy the swap chain
     m_device->waitForSubmission(&m_presentStatus);
     m_device->waitForIdle();
 
     m_presentStatus.result = VK_SUCCESS;
+    m_dirtyHdrMetadata = true;
 
-    vk::PresenterDesc presenterDesc;
+    PresenterDesc presenterDesc;
     presenterDesc.imageExtent     = { m_desc.Width, m_desc.Height };
     presenterDesc.imageCount      = PickImageCount(m_desc.BufferCount + 1);
     presenterDesc.numFormats      = PickFormats(m_desc.Format, presenterDesc.formats);
-    presenterDesc.numPresentModes = PickPresentModes(Vsync, presenterDesc.presentModes);
     presenterDesc.fullScreenExclusive = PickFullscreenMode();
 
     VkResult vr = m_presenter->recreateSwapChain(presenterDesc);
@@ -421,27 +489,13 @@ namespace dxvk {
 
 
   void D3D11SwapChain::CreatePresenter() {
-    DxvkDeviceQueue graphicsQueue = m_device->queues().graphics;
-
-    vk::PresenterDevice presenterDevice;
-    presenterDevice.queueFamily   = graphicsQueue.queueFamily;
-    presenterDevice.queue         = graphicsQueue.queueHandle;
-    presenterDevice.adapter       = m_device->adapter()->handle();
-    presenterDevice.features.fullScreenExclusive = m_device->features().extFullScreenExclusive;
-
-    vk::PresenterDesc presenterDesc;
+    PresenterDesc presenterDesc;
     presenterDesc.imageExtent     = { m_desc.Width, m_desc.Height };
     presenterDesc.imageCount      = PickImageCount(m_desc.BufferCount + 1);
     presenterDesc.numFormats      = PickFormats(m_desc.Format, presenterDesc.formats);
-    presenterDesc.numPresentModes = PickPresentModes(false, presenterDesc.presentModes);
     presenterDesc.fullScreenExclusive = PickFullscreenMode();
 
-    m_presenter = new vk::Presenter(
-      m_device->adapter()->vki(),
-      m_device->vkd(),
-      presenterDevice,
-      presenterDesc);
-    
+    m_presenter = new Presenter(m_device, m_frameLatencySignal, presenterDesc);
     m_presenter->setFrameRateLimit(m_parent->GetOptions()->maxFrameRate);
   }
 
@@ -456,7 +510,7 @@ namespace dxvk {
 
 
   void D3D11SwapChain::CreateRenderTargetViews() {
-    vk::PresenterInfo info = m_presenter->info();
+    PresenterInfo info = m_presenter->info();
 
     m_imageViews.clear();
     m_imageViews.resize(info.imageCount);
@@ -490,7 +544,8 @@ namespace dxvk {
       VkImage imageHandle = m_presenter->getImage(i).image;
       
       Rc<DxvkImage> image = new DxvkImage(
-        m_device.ptr(), imageInfo, imageHandle);
+        m_device.ptr(), imageInfo, imageHandle,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
       m_imageViews[i] = new DxvkImageView(
         m_device->vkd(), image, viewInfo);
@@ -570,7 +625,8 @@ namespace dxvk {
       subresources, VK_IMAGE_LAYOUT_UNDEFINED);
 
     m_device->submitCommandList(
-      m_context->endRecording());
+      m_context->endRecording(),
+      nullptr);
   }
 
 
@@ -596,11 +652,17 @@ namespace dxvk {
     // Wait for the sync event so that we respect the maximum frame latency
     m_frameLatencySignal->wait(m_frameId - GetActualFrameLatency());
 
-    if (m_frameLatencyEvent) {
-      m_frameLatencySignal->setCallback(m_frameId, [cFrameLatencyEvent = m_frameLatencyEvent] () {
+    m_frameLatencySignal->setCallback(m_frameId, [this,
+      cFrameId           = m_frameId,
+      cFrameLatencyEvent = m_frameLatencyEvent
+    ] () {
+      if (cFrameLatencyEvent)
         ReleaseSemaphore(cFrameLatencyEvent, 1, nullptr);
-      });
-    }
+
+      std::lock_guard<dxvk::mutex> lock(m_frameStatisticsLock);
+      m_frameStatistics.PresentCount = cFrameId - DXGI_MAX_SWAP_CHAIN_BUFFERS;
+      m_frameStatistics.PresentQPCTime = dxvk::high_resolution_clock::get_counter();
+    });
   }
 
 
@@ -616,7 +678,7 @@ namespace dxvk {
     if (m_frameLatencyCap)
       maxFrameLatency = std::min(maxFrameLatency, m_frameLatencyCap);
 
-    maxFrameLatency = std::min(maxFrameLatency, m_desc.BufferCount + 1);
+    maxFrameLatency = std::min(maxFrameLatency, m_desc.BufferCount);
     return maxFrameLatency;
   }
 
@@ -633,23 +695,23 @@ namespace dxvk {
       
       case DXGI_FORMAT_R8G8B8A8_UNORM:
       case DXGI_FORMAT_B8G8R8A8_UNORM: {
-        pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
-        pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
+        pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_UNORM, m_colorspace };
+        pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_UNORM, m_colorspace };
       } break;
       
       case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
       case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: {
-        pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
-        pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
+        pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_SRGB, m_colorspace };
+        pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_SRGB, m_colorspace };
       } break;
       
       case DXGI_FORMAT_R10G10B10A2_UNORM: {
-        pDstFormats[n++] = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
-        pDstFormats[n++] = { VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
+        pDstFormats[n++] = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, m_colorspace };
+        pDstFormats[n++] = { VK_FORMAT_A2R10G10B10_UNORM_PACK32, m_colorspace };
       } break;
       
       case DXGI_FORMAT_R16G16B16A16_FLOAT: {
-        pDstFormats[n++] = { VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
+        pDstFormats[n++] = { VK_FORMAT_R16G16B16A16_SFLOAT, m_colorspace };
       } break;
     }
 
@@ -657,25 +719,6 @@ namespace dxvk {
   }
 
 
-  uint32_t D3D11SwapChain::PickPresentModes(
-          BOOL                      Vsync,
-          VkPresentModeKHR*         pDstModes) {
-    uint32_t n = 0;
-
-    if (Vsync) {
-      if (m_parent->GetOptions()->tearFree == Tristate::False)
-        pDstModes[n++] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
-      pDstModes[n++] = VK_PRESENT_MODE_FIFO_KHR;
-    } else {
-      if (m_parent->GetOptions()->tearFree != Tristate::True)
-        pDstModes[n++] = VK_PRESENT_MODE_IMMEDIATE_KHR;
-      pDstModes[n++] = VK_PRESENT_MODE_MAILBOX_KHR;
-    }
-
-    return n;
-  }
-
-
   uint32_t D3D11SwapChain::PickImageCount(
           UINT                      Preferred) {
     int32_t option = m_parent->GetOptions()->numBackBuffers;

src/d3d11/d3d11_swapchain.h

@@ -13,7 +13,7 @@ namespace dxvk {
   class D3D11Device;
   class D3D11DXGIDevice;
 
-  class D3D11SwapChain : public ComObject<IDXGIVkSwapChain> {
+  class D3D11SwapChain : public ComObject<IDXGIVkSwapChain1> {
     constexpr static uint32_t DefaultFrameLatency = 1;
   public:
 
@@ -80,6 +80,12 @@ namespace dxvk {
     HRESULT STDMETHODCALLTYPE SetHDRMetaData(
       const DXGI_VK_HDR_METADATA*     pMetaData);
 
+    void STDMETHODCALLTYPE GetLastPresentCount(
+            UINT64*                   pLastPresentCount);
+
+    void STDMETHODCALLTYPE GetFrameStatistics(
+            DXGI_VK_FRAME_STATISTICS* pFrameStatistics);
+
   private:
 
     enum BindingIds : uint32_t {
@@ -97,7 +103,7 @@ namespace dxvk {
     Rc<DxvkDevice>            m_device;
     Rc<DxvkContext>           m_context;
 
-    Rc<vk::Presenter>         m_presenter;
+    Rc<Presenter>             m_presenter;
 
     Rc<DxvkImage>             m_swapImage;
     Rc<DxvkImageView>         m_swapImageView;
@@ -116,22 +122,26 @@ namespace dxvk {
     HANDLE                  m_frameLatencyEvent = nullptr;
     Rc<sync::CallbackFence> m_frameLatencySignal;
 
-    HANDLE                  m_processHandle = nullptr;
-
     bool                    m_dirty = true;
-    bool                    m_vsync = true;
+
+    VkColorSpaceKHR         m_colorspace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+
+    std::optional<VkHdrMetadataEXT> m_hdrMetadata;
+    bool m_dirtyHdrMetadata = true;
+
+    dxvk::mutex               m_frameStatisticsLock;
+    DXGI_VK_FRAME_STATISTICS  m_frameStatistics = { };
 
     HRESULT PresentImage(UINT SyncInterval);
 
     void SubmitPresent(
             D3D11ImmediateContext*  pContext,
-      const vk::PresenterSync&      Sync,
-            uint32_t                FrameId);
+      const PresenterSync&          Sync,
+            uint32_t                Repeat);
 
     void SynchronizePresent();
 
-    void RecreateSwapChain(
-            BOOL                      Vsync);
+    void RecreateSwapChain();
 
     void CreateFrameLatencyEvent();
 
@@ -157,10 +167,6 @@ namespace dxvk {
             DXGI_FORMAT               Format,
             VkSurfaceFormatKHR*       pDstFormats);
     
-    uint32_t PickPresentModes(
-            BOOL                      Vsync,
-            VkPresentModeKHR*         pDstModes);
-    
     uint32_t PickImageCount(
             UINT                      Preferred);
     

src/d3d11/d3d11_texture.cpp

@@ -11,11 +11,13 @@ namespace dxvk {
           ID3D11Resource*             pInterface,
           D3D11Device*                pDevice,
     const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+    const D3D11_ON_12_RESOURCE_INFO*  p11on12Info,
           D3D11_RESOURCE_DIMENSION    Dimension,
           DXGI_USAGE                  DxgiUsage,
           VkImage                     vkImage,
           HANDLE                      hSharedHandle)
-  : m_interface(pInterface), m_device(pDevice), m_dimension(Dimension), m_desc(*pDesc), m_dxgiUsage(DxgiUsage) {
+  : m_interface(pInterface), m_device(pDevice), m_dimension(Dimension), m_desc(*pDesc),
+    m_11on12(p11on12Info ? *p11on12Info : D3D11_ON_12_RESOURCE_INFO()), m_dxgiUsage(DxgiUsage) {
     DXGI_VK_FORMAT_MODE   formatMode   = GetFormatMode();
     DXGI_VK_FORMAT_INFO   formatInfo   = m_device->LookupFormat(m_desc.Format, formatMode);
     DXGI_VK_FORMAT_FAMILY formatFamily = m_device->LookupFamily(m_desc.Format, formatMode);
@@ -46,15 +48,21 @@ namespace dxvk {
     if (hSharedHandle == nullptr)
       hSharedHandle = INVALID_HANDLE_VALUE;
 
-    if (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_NTHANDLE)) {
-      if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX)
-        Logger::warn("D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX: not supported.");
+    const auto sharingFlags = D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_NTHANDLE|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
+
+    if (m_desc.MiscFlags & sharingFlags) {
+      if (pDevice->GetFeatureLevel() < D3D_FEATURE_LEVEL_10_0 ||
+          (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX)) == (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) ||
+          (m_desc.MiscFlags & sharingFlags) == D3D11_RESOURCE_MISC_SHARED_NTHANDLE)
+        throw DxvkError(str::format("D3D11: Cannot create shared texture:",
+          "\n  MiscFlags:  ", m_desc.MiscFlags,
+          "\n  FeatureLevel:  ", pDevice->GetFeatureLevel()));
 
       imageInfo.shared = true;
       imageInfo.sharing.mode = hSharedHandle == INVALID_HANDLE_VALUE ? DxvkSharedHandleMode::Export : DxvkSharedHandleMode::Import;
-      imageInfo.sharing.type = (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED)
-        ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-        : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
+      imageInfo.sharing.type = (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE)
+        ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+        : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
       imageInfo.sharing.handle = hSharedHandle;
     }
 
@@ -203,9 +211,12 @@ namespace dxvk {
     // For some formats, we need to enable sampled and/or
     // render target capabilities if available, but these
     // should in no way affect the default image layout
-    imageInfo.usage |= EnableMetaCopyUsage(imageInfo.format, imageInfo.tiling);
     imageInfo.usage |= EnableMetaPackUsage(imageInfo.format, m_desc.CPUAccessFlags);
-    
+    imageInfo.usage |= EnableMetaCopyUsage(imageInfo.format, imageInfo.tiling);
+
+    for (uint32_t i = 0; i < imageInfo.viewFormatCount; i++)
+      imageInfo.usage |= EnableMetaCopyUsage(imageInfo.viewFormats[i], imageInfo.tiling);
+
     // Check if we can actually create the image
     if (!CheckImageSupport(&imageInfo, imageInfo.tiling)) {
       throw DxvkError(str::format(
@@ -228,10 +239,13 @@ namespace dxvk {
     if (m_mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT)
       memoryProperties = GetMemoryFlags();
     
-    if (vkImage == VK_NULL_HANDLE)
+    if (m_11on12.Resource != nullptr)
+      vkImage = VkImage(m_11on12.VulkanHandle);
+
+    if (!vkImage)
       m_image = m_device->GetDXVKDevice()->createImage(imageInfo, memoryProperties);
     else
-      m_image = m_device->GetDXVKDevice()->createImageFromVkImage(imageInfo, vkImage);
+      m_image = m_device->GetDXVKDevice()->importImage(imageInfo, vkImage, memoryProperties);
 
     if (imageInfo.sharing.mode == DxvkSharedHandleMode::Export)
       ExportImageInfo();
@@ -469,9 +483,60 @@ namespace dxvk {
   }
   
   
+  HRESULT D3D11CommonTexture::GetDescFromD3D12(
+          ID3D12Resource*         pResource,
+    const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+          D3D11_COMMON_TEXTURE_DESC* pTextureDesc) {
+    D3D12_RESOURCE_DESC desc12 = pResource->GetDesc();
+
+    pTextureDesc->Width = desc12.Width;
+    pTextureDesc->Height = desc12.Height;
+
+    if (desc12.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D) {
+      pTextureDesc->Depth = desc12.DepthOrArraySize;
+      pTextureDesc->ArraySize = 1;
+    } else {
+      pTextureDesc->Depth = 1;
+      pTextureDesc->ArraySize = desc12.DepthOrArraySize;
+    }
+
+    pTextureDesc->MipLevels = desc12.MipLevels;
+    pTextureDesc->Format = desc12.Format;
+    pTextureDesc->SampleDesc = desc12.SampleDesc;
+    pTextureDesc->Usage = D3D11_USAGE_DEFAULT;
+    pTextureDesc->BindFlags = 0;
+    pTextureDesc->CPUAccessFlags = 0;
+    pTextureDesc->MiscFlags = 0;
+
+    if (!(desc12.Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE))
+      pTextureDesc->BindFlags |= D3D11_BIND_SHADER_RESOURCE;
+
+    if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
+      pTextureDesc->BindFlags |= D3D11_BIND_RENDER_TARGET;
+
+    if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
+      pTextureDesc->BindFlags |= D3D11_BIND_DEPTH_STENCIL;
+
+    if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
+      pTextureDesc->BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
+
+    if (pResourceFlags) {
+      pTextureDesc->BindFlags = pResourceFlags->BindFlags;
+      pTextureDesc->MiscFlags |= pResourceFlags->MiscFlags;
+      pTextureDesc->CPUAccessFlags = pResourceFlags->CPUAccessFlags;
+    }
+
+    return S_OK;
+  }
+
+
   BOOL D3D11CommonTexture::CheckImageSupport(
     const DxvkImageCreateInfo*  pImageInfo,
           VkImageTiling         Tiling) const {
+    // D3D12 images always use optimal tiling
+    if (m_11on12.Resource != nullptr && Tiling != VK_IMAGE_TILING_OPTIMAL)
+      return FALSE;
+
     DxvkFormatQuery formatQuery = { };
     formatQuery.format = pImageInfo->format;
     formatQuery.type = pImageInfo->type;
@@ -486,7 +551,7 @@ namespace dxvk {
     
     if (!properties)
       return FALSE;
-    
+
     return (pImageInfo->extent.width  <= properties->maxExtent.width)
         && (pImageInfo->extent.height <= properties->maxExtent.height)
         && (pImageInfo->extent.depth  <= properties->maxExtent.depth)
@@ -640,10 +705,10 @@ namespace dxvk {
   void D3D11CommonTexture::ExportImageInfo() {
     HANDLE hSharedHandle;
 
-    if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED)
-      hSharedHandle = openKmtHandle( m_image->sharedHandle() );
-    else
+    if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE)
       hSharedHandle = m_image->sharedHandle();
+    else
+      hSharedHandle = openKmtHandle( m_image->sharedHandle() );
 
     DxvkSharedTextureMetadata metadata;
 
@@ -663,7 +728,7 @@ namespace dxvk {
       Logger::warn("D3D11: Failed to write shared resource info for a texture");
     }
 
-    if ((m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED) && hSharedHandle != INVALID_HANDLE_VALUE)
+    if (hSharedHandle != INVALID_HANDLE_VALUE)
       CloseHandle(hSharedHandle);
   }
   
@@ -1028,12 +1093,13 @@ namespace dxvk {
   //      D 3 D 1 1 T E X T U R E 1 D
   D3D11Texture1D::D3D11Texture1D(
           D3D11Device*                pDevice,
-    const D3D11_COMMON_TEXTURE_DESC*  pDesc)
+    const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+    const D3D11_ON_12_RESOURCE_INFO*  p11on12Info)
   : D3D11DeviceChild<ID3D11Texture1D>(pDevice),
-    m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE1D, 0, VK_NULL_HANDLE, nullptr),
+    m_texture (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE1D, 0, VK_NULL_HANDLE, nullptr),
     m_interop (this, &m_texture),
     m_surface (this, &m_texture),
-    m_resource(this),
+    m_resource(this, pDevice),
     m_d3d10   (this) {
     
   }
@@ -1080,14 +1146,20 @@ namespace dxvk {
        *ppvObject = ref(&m_resource);
        return S_OK;
     }
-    
+
+    if (riid == __uuidof(IDXGIKeyedMutex))
+      return m_resource.GetKeyedMutex(ppvObject);
+
     if (riid == __uuidof(IDXGIVkInteropSurface)) {
       *ppvObject = ref(&m_interop);
       return S_OK;
     }
     
-    Logger::warn("D3D11Texture1D::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D10Texture1D), riid)) {
+      Logger::warn("D3D11Texture1D::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -1127,12 +1199,13 @@ namespace dxvk {
   D3D11Texture2D::D3D11Texture2D(
           D3D11Device*                pDevice,
     const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+    const D3D11_ON_12_RESOURCE_INFO*  p11on12Info,
           HANDLE                      hSharedHandle)
   : D3D11DeviceChild<ID3D11Texture2D1>(pDevice),
-    m_texture   (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, VK_NULL_HANDLE, hSharedHandle),
+    m_texture   (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, VK_NULL_HANDLE, hSharedHandle),
     m_interop   (this, &m_texture),
     m_surface   (this, &m_texture),
-    m_resource  (this),
+    m_resource  (this, pDevice),
     m_d3d10     (this),
     m_swapChain (nullptr) {
   }
@@ -1144,10 +1217,10 @@ namespace dxvk {
           DXGI_USAGE                  DxgiUsage,
           VkImage                     vkImage)
   : D3D11DeviceChild<ID3D11Texture2D1>(pDevice),
-    m_texture   (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, vkImage, nullptr),
+    m_texture   (this, pDevice, pDesc, nullptr, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, vkImage, nullptr),
     m_interop   (this, &m_texture),
     m_surface   (this, &m_texture),
-    m_resource  (this),
+    m_resource  (this, pDevice),
     m_d3d10     (this),
     m_swapChain (nullptr) {
     
@@ -1160,10 +1233,10 @@ namespace dxvk {
     const D3D11_COMMON_TEXTURE_DESC*  pDesc,
           DXGI_USAGE                  DxgiUsage)
   : D3D11DeviceChild<ID3D11Texture2D1>(pDevice),
-    m_texture   (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, VK_NULL_HANDLE, nullptr),
+    m_texture   (this, pDevice, pDesc, nullptr, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, VK_NULL_HANDLE, nullptr),
     m_interop   (this, &m_texture),
     m_surface   (this, &m_texture),
-    m_resource  (this),
+    m_resource  (this, pDevice),
     m_d3d10     (this),
     m_swapChain (pSwapChain) {
     
@@ -1176,27 +1249,24 @@ namespace dxvk {
   
   
   ULONG STDMETHODCALLTYPE D3D11Texture2D::AddRef() {
-    uint32_t refCount = m_refCount++;
+    uint32_t refCount = D3D11DeviceChild<ID3D11Texture2D1>::AddRef();
 
-    if (unlikely(!refCount)) {
-      if (m_swapChain)
+    if (unlikely(m_swapChain != nullptr)) {
+      if (refCount == 1)
         m_swapChain->AddRef();
-
-      AddRefPrivate();
     }
 
-    return refCount + 1;
+    return refCount;
   }
   
 
   ULONG STDMETHODCALLTYPE D3D11Texture2D::Release() {
-    uint32_t refCount = --m_refCount;
+    IUnknown* swapChain = m_swapChain;
+    uint32_t refCount = D3D11DeviceChild<ID3D11Texture2D1>::Release();
 
-    if (unlikely(!refCount)) {
-      if (m_swapChain)
-        m_swapChain->Release();
-
-      ReleasePrivate();
+    if (unlikely(swapChain != nullptr)) {
+      if (refCount == 0)
+        swapChain->Release();
     }
 
     return refCount;
@@ -1240,14 +1310,20 @@ namespace dxvk {
        *ppvObject = ref(&m_resource);
        return S_OK;
     }
+
+    if (riid == __uuidof(IDXGIKeyedMutex))
+      return m_resource.GetKeyedMutex(ppvObject);
     
     if (riid == __uuidof(IDXGIVkInteropSurface)) {
       *ppvObject = ref(&m_interop);
       return S_OK;
     }
     
-    Logger::warn("D3D11Texture2D::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D10Texture2D), riid)) {
+      Logger::warn("D3D11Texture2D::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -1303,11 +1379,12 @@ namespace dxvk {
   //      D 3 D 1 1 T E X T U R E 3 D
   D3D11Texture3D::D3D11Texture3D(
           D3D11Device*                pDevice,
-    const D3D11_COMMON_TEXTURE_DESC*  pDesc)
+    const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+    const D3D11_ON_12_RESOURCE_INFO*  p11on12Info)
   : D3D11DeviceChild<ID3D11Texture3D1>(pDevice),
-    m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, VK_NULL_HANDLE, nullptr),
+    m_texture (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, VK_NULL_HANDLE, nullptr),
     m_interop (this, &m_texture),
-    m_resource(this),
+    m_resource(this, pDevice),
     m_d3d10   (this) {
     
   }
@@ -1347,14 +1424,20 @@ namespace dxvk {
        *ppvObject = ref(&m_resource);
        return S_OK;
     }
-    
+
+    if (riid == __uuidof(IDXGIKeyedMutex))
+      return m_resource.GetKeyedMutex(ppvObject);
+
     if (riid == __uuidof(IDXGIVkInteropSurface)) {
       *ppvObject = ref(&m_interop);
       return S_OK;
     }
     
-    Logger::warn("D3D11Texture3D::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D10Texture3D), riid)) {
+      Logger::warn("D3D11Texture3D::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_texture.h

@@ -7,6 +7,7 @@
 
 #include "d3d11_device_child.h"
 #include "d3d11_interfaces.h"
+#include "d3d11_on_12.h"
 #include "d3d11_resource.h"
 
 namespace dxvk {
@@ -85,6 +86,7 @@ namespace dxvk {
             ID3D11Resource*             pInterface,
             D3D11Device*                pDevice,
       const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+      const D3D11_ON_12_RESOURCE_INFO*  p11on12Info,
             D3D11_RESOURCE_DIMENSION    Dimension,
             DXGI_USAGE                  DxgiUsage,
             VkImage                     vkImage,
@@ -435,6 +437,14 @@ namespace dxvk {
             DXGI_FORMAT         Format,
             UINT                Plane) const;
     
+    /**
+     * \brief Retrieves D3D11on12 resource info
+     * \returns 11on12 resource info
+     */
+    D3D11_ON_12_RESOURCE_INFO Get11on12Info() const {
+      return m_11on12;
+    }
+
     /**
      * \brief Normalizes and validates texture description
      * 
@@ -447,6 +457,19 @@ namespace dxvk {
     static HRESULT NormalizeTextureProperties(
             D3D11_COMMON_TEXTURE_DESC* pDesc);
     
+    /**
+     * \brief Initializes D3D11 texture description from D3D12
+     *
+     * \param [in] pResource D3D12 resource
+     * \param [in] pResourceFlags D3D11 flag overrides
+     * \param [out] pTextureDesc D3D11 buffer description
+     * \returns \c S_OK if the parameters are valid
+     */
+    static HRESULT GetDescFromD3D12(
+            ID3D12Resource*         pResource,
+      const D3D11_RESOURCE_FLAGS*   pResourceFlags,
+            D3D11_COMMON_TEXTURE_DESC* pTextureDesc);
+
   private:
     
     struct MappedBuffer {
@@ -465,6 +488,7 @@ namespace dxvk {
     D3D11Device*                  m_device;
     D3D11_RESOURCE_DIMENSION      m_dimension;
     D3D11_COMMON_TEXTURE_DESC     m_desc;
+    D3D11_ON_12_RESOURCE_INFO     m_11on12;
     D3D11_COMMON_TEXTURE_MAP_MODE m_mapMode;
     DXGI_USAGE                    m_dxgiUsage;
     VkFormat                      m_packedFormat;
@@ -636,7 +660,8 @@ namespace dxvk {
     
     D3D11Texture1D(
             D3D11Device*                pDevice,
-      const D3D11_COMMON_TEXTURE_DESC*  pDesc);
+      const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+      const D3D11_ON_12_RESOURCE_INFO*  p11on12Info);
     
     ~D3D11Texture1D();
     
@@ -682,6 +707,7 @@ namespace dxvk {
     D3D11Texture2D(
             D3D11Device*                pDevice,
       const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+      const D3D11_ON_12_RESOURCE_INFO*  p11on12Info,
             HANDLE                      hSharedHandle);
 
     D3D11Texture2D(
@@ -747,7 +773,8 @@ namespace dxvk {
     
     D3D11Texture3D(
             D3D11Device*                pDevice,
-      const D3D11_COMMON_TEXTURE_DESC*  pDesc);
+      const D3D11_COMMON_TEXTURE_DESC*  pDesc,
+      const D3D11_ON_12_RESOURCE_INFO*  p11on12Info);
     
     ~D3D11Texture3D();
     

src/d3d11/d3d11_video.cpp

@@ -32,8 +32,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11VideoProcessorEnumerator::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorEnumerator), riid)) {
+      Logger::warn("D3D11VideoProcessorEnumerator::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -48,23 +51,47 @@ namespace dxvk {
   HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat(
           DXGI_FORMAT             Format,
           UINT*                   pFlags) {
-    Logger::err("D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat: Stub");
-    return E_NOTIMPL;
+    Logger::err(str::format("D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat: stub, format ", Format));
+
+    if (!pFlags)
+      return E_INVALIDARG;
+
+    *pFlags = D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT | D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT;
+    return S_OK;
   }
 
 
   HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::GetVideoProcessorCaps(
           D3D11_VIDEO_PROCESSOR_CAPS* pCaps) {
-    Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorCaps: Stub");
-    return E_NOTIMPL;
+    Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorCaps: semi-stub");
+
+    if (!pCaps)
+      return E_INVALIDARG;
+
+    *pCaps = {};
+    pCaps->RateConversionCapsCount = 1;
+    pCaps->MaxInputStreams = 52;
+    pCaps->MaxStreamStates = 52;
+    return S_OK;
   }
 
 
   HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps(
           UINT                    TypeIndex,
           D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps) {
-    Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps: Stub");
-    return E_NOTIMPL;
+    Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps: semi-stub");
+    if (!pCaps || TypeIndex)
+      return E_INVALIDARG;
+
+    *pCaps = {};
+    if (m_desc.InputFrameFormat == D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE) {
+      pCaps->ProcessorCaps = D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION;
+    } else {
+      pCaps->ProcessorCaps = D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB;
+      pCaps->PastFrames = 1;
+      pCaps->FutureFrames = 1;
+    }
+    return S_OK;
   }
 
 
@@ -112,8 +139,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11VideoProcessor::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessor), riid)) {
+      Logger::warn("D3D11VideoProcessor::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -223,8 +253,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11VideoProcessorInputView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorInputView), riid)) {
+      Logger::warn("D3D11VideoProcessorInputView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -302,8 +335,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D11VideoProcessorOutputView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorOutputView), riid)) {
+      Logger::warn("D3D11VideoProcessorOutputView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -324,56 +360,8 @@ namespace dxvk {
   D3D11VideoContext::D3D11VideoContext(
           D3D11ImmediateContext*  pContext,
     const Rc<DxvkDevice>&         Device)
-  : m_ctx(pContext) {
-    SpirvCodeBuffer vsCode(d3d11_video_blit_vert);
-    SpirvCodeBuffer fsCode(d3d11_video_blit_frag);
+  : m_ctx(pContext), m_device(Device) {
 
-    const std::array<DxvkBindingInfo, 4> fsBindings = {{
-      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, VK_IMAGE_VIEW_TYPE_MAX_ENUM, VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_UNIFORM_READ_BIT },
-      { VK_DESCRIPTOR_TYPE_SAMPLER,        1, VK_IMAGE_VIEW_TYPE_MAX_ENUM, VK_SHADER_STAGE_FRAGMENT_BIT, 0 },
-      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,  2, VK_IMAGE_VIEW_TYPE_2D,       VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT },
-      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,  3, VK_IMAGE_VIEW_TYPE_2D,       VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT },
-    }};
-
-    DxvkShaderCreateInfo vsInfo;
-    vsInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
-    vsInfo.outputMask = 0x1;
-    m_vs = new DxvkShader(vsInfo, std::move(vsCode));
-
-    DxvkShaderCreateInfo fsInfo;
-    fsInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
-    fsInfo.bindingCount = fsBindings.size();
-    fsInfo.bindings = fsBindings.data();
-    fsInfo.inputMask = 0x1;
-    fsInfo.outputMask = 0x1;
-    m_fs = new DxvkShader(fsInfo, std::move(fsCode));
-
-    DxvkSamplerCreateInfo samplerInfo;
-    samplerInfo.magFilter       = VK_FILTER_LINEAR;
-    samplerInfo.minFilter       = VK_FILTER_LINEAR;
-    samplerInfo.mipmapMode      = VK_SAMPLER_MIPMAP_MODE_NEAREST;
-    samplerInfo.mipmapLodBias   = 0.0f;
-    samplerInfo.mipmapLodMin    = 0.0f;
-    samplerInfo.mipmapLodMax    = 0.0f;
-    samplerInfo.useAnisotropy   = VK_FALSE;
-    samplerInfo.maxAnisotropy   = 1.0f;
-    samplerInfo.addressModeU    = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeV    = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.addressModeW    = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-    samplerInfo.compareToDepth  = VK_FALSE;
-    samplerInfo.compareOp       = VK_COMPARE_OP_ALWAYS;
-    samplerInfo.reductionMode   = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
-    samplerInfo.borderColor     = VkClearColorValue();
-    samplerInfo.usePixelCoord   = VK_FALSE;
-    samplerInfo.nonSeamless     = VK_FALSE;
-    m_sampler = Device->createSampler(samplerInfo);
-
-    DxvkBufferCreateInfo bufferInfo;
-    bufferInfo.size = sizeof(UboData);
-    bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-    bufferInfo.stages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-    bufferInfo.access = VK_ACCESS_UNIFORM_READ_BIT;
-    m_ubo = Device->createBuffer(bufferInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
   }
 
 
@@ -603,7 +591,9 @@ namespace dxvk {
           D3D11_VIDEO_PROCESSOR_OUTPUT_RATE Rate,
           BOOL                            Repeat,
     const DXGI_RATIONAL*                  CustomRate) {
-    Logger::err("D3D11VideoContext::VideoProcessorSetStreamOutputRate: Stub");
+    Logger::err(str::format("D3D11VideoContext::VideoProcessorSetStreamOutputRate: Stub, Rate ", Rate));
+    if (CustomRate)
+      Logger::err(str::format("CustomRate ", CustomRate->Numerator, "/", CustomRate->Denominator));
   }
 
 
@@ -1200,9 +1190,6 @@ namespace dxvk {
       rt.color[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
       ctx->bindRenderTargets(std::move(rt), 0u);
-      ctx->bindShader<VK_SHADER_STAGE_VERTEX_BIT>(Rc<DxvkShader>(m_vs));
-      ctx->bindShader<VK_SHADER_STAGE_FRAGMENT_BIT>(Rc<DxvkShader>(m_fs));
-      ctx->bindResourceBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice(m_ubo));
 
       DxvkInputAssemblyState iaState;
       iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
@@ -1219,6 +1206,8 @@ namespace dxvk {
   void D3D11VideoContext::BlitStream(
     const D3D11VideoProcessorStreamState* pStreamState,
     const D3D11_VIDEO_PROCESSOR_STREAM*   pStream) {
+    CreateResources();
+
     if (pStream->PastFrames || pStream->FutureFrames)
       Logger::err("D3D11VideoContext: Ignoring non-zero PastFrames and FutureFrames");
 
@@ -1273,12 +1262,28 @@ namespace dxvk {
         viewport.height = float(cStreamState.dstRect.bottom) - viewport.y;
       }
 
+      VkExtent3D viewExtent = cViews[0]->mipLevelExtent(0);
+
+      VkRect2D srcRect;
+      srcRect.offset = { 0, 0 };
+      srcRect.extent = { viewExtent.width, viewExtent.height };
+
+      if (cStreamState.srcRectEnabled) {
+        srcRect.offset.x      = cStreamState.srcRect.left;
+        srcRect.offset.y      = cStreamState.srcRect.top;
+        srcRect.extent.width  = cStreamState.srcRect.right - srcRect.offset.x;
+        srcRect.extent.height = cStreamState.srcRect.bottom - srcRect.offset.y;
+      }
+
       UboData uboData = { };
       uboData.colorMatrix[0][0] = 1.0f;
       uboData.colorMatrix[1][1] = 1.0f;
       uboData.colorMatrix[2][2] = 1.0f;
-      uboData.coordMatrix[0][0] = 1.0f;
-      uboData.coordMatrix[1][1] = 1.0f;
+      uboData.coordMatrix[0][0] = float(srcRect.extent.width) / float(viewExtent.width);
+      uboData.coordMatrix[1][1] = float(srcRect.extent.height) / float(viewExtent.height);
+      uboData.coordMatrix[2][0] = float(srcRect.offset.x) / float(viewExtent.width);
+      uboData.coordMatrix[2][1] = float(srcRect.offset.y) / float(viewExtent.height);
+      uboData.srcRect = srcRect;
       uboData.yMin = 0.0f;
       uboData.yMax = 1.0f;
       uboData.isPlanar = cViews[1] != nullptr;
@@ -1296,21 +1301,67 @@ namespace dxvk {
 
       ctx->invalidateBuffer(m_ubo, uboSlice);
       ctx->setViewports(1, &viewport, &scissor);
-      ctx->bindResourceSampler(VK_SHADER_STAGE_FRAGMENT_BIT, 1, Rc<DxvkSampler>(m_sampler));
+
+      ctx->bindShader<VK_SHADER_STAGE_VERTEX_BIT>(Rc<DxvkShader>(m_vs));
+      ctx->bindShader<VK_SHADER_STAGE_FRAGMENT_BIT>(Rc<DxvkShader>(m_fs));
+
+      ctx->bindUniformBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice(m_ubo));
 
       for (uint32_t i = 0; i < cViews.size(); i++)
-        ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 2 + i, Rc<DxvkImageView>(cViews[i]));
+        ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 1 + i, Rc<DxvkImageView>(cViews[i]));
 
       ctx->draw(3, 1, 0, 0);
 
-      ctx->bindResourceSampler(VK_SHADER_STAGE_FRAGMENT_BIT, 1, nullptr);
-
       for (uint32_t i = 0; i < cViews.size(); i++)
-        ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 2 + i, nullptr);
+        ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 1 + i, nullptr);
     });
   }
 
 
+  void D3D11VideoContext::CreateUniformBuffer() {
+    DxvkBufferCreateInfo bufferInfo;
+    bufferInfo.size = sizeof(UboData);
+    bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+    bufferInfo.stages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+    bufferInfo.access = VK_ACCESS_UNIFORM_READ_BIT;
+    m_ubo = m_device->createBuffer(bufferInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+  }
+
+
+  void D3D11VideoContext::CreateShaders() {
+    SpirvCodeBuffer vsCode(d3d11_video_blit_vert);
+    SpirvCodeBuffer fsCode(d3d11_video_blit_frag);
+
+    const std::array<DxvkBindingInfo, 3> fsBindings = {{
+      { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, VK_IMAGE_VIEW_TYPE_MAX_ENUM, VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_UNIFORM_READ_BIT, VK_TRUE },
+      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,  1, VK_IMAGE_VIEW_TYPE_2D,       VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT },
+      { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,  2, VK_IMAGE_VIEW_TYPE_2D,       VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT },
+    }};
+
+    DxvkShaderCreateInfo vsInfo;
+    vsInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+    vsInfo.outputMask = 0x1;
+    m_vs = new DxvkShader(vsInfo, std::move(vsCode));
+
+    DxvkShaderCreateInfo fsInfo;
+    fsInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+    fsInfo.bindingCount = fsBindings.size();
+    fsInfo.bindings = fsBindings.data();
+    fsInfo.inputMask = 0x1;
+    fsInfo.outputMask = 0x1;
+    m_fs = new DxvkShader(fsInfo, std::move(fsCode));
+  }
+
+
+  void D3D11VideoContext::CreateResources() {
+    if (std::exchange(m_resourcesCreated, true))
+      return;
+
+    CreateUniformBuffer();
+    CreateShaders();
+  }
+
+
   void D3D11VideoContext::UnbindResources() {
     m_ctx->EmitCs([] (DxvkContext* ctx) {
       ctx->bindRenderTargets(DxvkRenderTargets(), 0u);
@@ -1318,7 +1369,7 @@ namespace dxvk {
       ctx->bindShader<VK_SHADER_STAGE_VERTEX_BIT>(nullptr);
       ctx->bindShader<VK_SHADER_STAGE_FRAGMENT_BIT>(nullptr);
 
-      ctx->bindResourceBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice());
+      ctx->bindUniformBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice());
     });
   }
 

src/d3d11/d3d11_video.h

@@ -584,19 +584,22 @@ namespace dxvk {
     struct alignas(16) UboData {
       float colorMatrix[3][4];
       float coordMatrix[3][2];
+      VkRect2D srcRect;
       float yMin, yMax;
       VkBool32 isPlanar;
     };
 
-    D3D11ImmediateContext* m_ctx;
+    D3D11ImmediateContext*  m_ctx;
 
-    Rc<DxvkSampler> m_sampler;
-    Rc<DxvkShader> m_vs;
-    Rc<DxvkShader> m_fs;
-    Rc<DxvkBuffer> m_ubo;
+    Rc<DxvkDevice>          m_device;
+    Rc<DxvkShader>          m_vs;
+    Rc<DxvkShader>          m_fs;
+    Rc<DxvkBuffer>          m_ubo;
 
     VkExtent2D m_dstExtent = { 0u, 0u };
 
+    bool m_resourcesCreated = false;
+
     void ApplyColorMatrix(float pDst[3][4], const float pSrc[3][4]);
 
     void ApplyYCbCrMatrix(float pColorMatrix[3][4], bool UseBt709);
@@ -608,6 +611,12 @@ namespace dxvk {
       const D3D11VideoProcessorStreamState* pStreamState,
       const D3D11_VIDEO_PROCESSOR_STREAM*   pStream);
 
+    void CreateUniformBuffer();
+
+    void CreateShaders();
+
+    void CreateResources();
+
     void UnbindResources();
 
   };

src/d3d11/d3d11_view_dsv.cpp

@@ -126,12 +126,15 @@ namespace dxvk {
     if (riid == __uuidof(ID3D10DeviceChild)
      || riid == __uuidof(ID3D10View)
      || riid == __uuidof(ID3D10DepthStencilView)) {
-      *ppvObject = ref(this);
+      *ppvObject = ref(&m_d3d10);
       return S_OK;
     }
     
-    Logger::warn("D3D11DepthStencilView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11DepthStencilView), riid)) {
+      Logger::warn("D3D11DepthStencilView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_view_dsv.h

@@ -77,6 +77,10 @@ namespace dxvk {
       return mask;
     }
 
+    DXGI_FORMAT GetViewFormat() const {
+      return m_desc.Format;
+    }
+
     D3D10DepthStencilView* GetD3D10Iface() {
       return &m_d3d10;
     }

src/d3d11/d3d11_view_rtv.cpp

@@ -137,12 +137,15 @@ namespace dxvk {
     if (riid == __uuidof(ID3D10DeviceChild)
      || riid == __uuidof(ID3D10View)
      || riid == __uuidof(ID3D10RenderTargetView)) {
-      *ppvObject = ref(this);
+      *ppvObject = ref(&m_d3d10);
       return S_OK;
     }
     
-    Logger::warn("D3D11RenderTargetView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11RenderTargetView), riid)) {
+      Logger::warn("D3D11RenderTargetView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   

src/d3d11/d3d11_view_srv.cpp

@@ -205,12 +205,15 @@ namespace dxvk {
      || riid == __uuidof(ID3D10View)
      || riid == __uuidof(ID3D10ShaderResourceView)
      || riid == __uuidof(ID3D10ShaderResourceView1)) {
-      *ppvObject = ref(this);
+      *ppvObject = ref(&m_d3d10);
       return S_OK;
     }
     
-    Logger::warn("D3D11ShaderResourceView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11ShaderResourceView), riid)) {
+      Logger::warn("D3D11ShaderResourceView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -295,7 +298,7 @@ namespace dxvk {
         D3D11_BUFFER_DESC bufferDesc;
         static_cast<D3D11Buffer*>(pResource)->GetDesc(&bufferDesc);
         
-        if (bufferDesc.MiscFlags == D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) {
+        if (bufferDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) {
           pDesc->Format              = DXGI_FORMAT_UNKNOWN;
           pDesc->ViewDimension       = D3D11_SRV_DIMENSION_BUFFER;
           pDesc->Buffer.FirstElement = 0;

src/d3d11/d3d11_view_uav.cpp

@@ -44,7 +44,7 @@ namespace dxvk {
       }
       
       if (pDesc->Buffer.Flags & (D3D11_BUFFER_UAV_FLAG_APPEND | D3D11_BUFFER_UAV_FLAG_COUNTER))
-        m_counterBuffer = CreateCounterBuffer();
+        m_counterView = CreateCounterBufferView();
       
       // Populate view info struct
       m_info.Buffer.Offset = viewInfo.rangeOffset;
@@ -59,9 +59,11 @@ namespace dxvk {
       DxvkImageViewCreateInfo viewInfo;
       viewInfo.format  = formatInfo.Format;
       viewInfo.aspect  = formatInfo.Aspect;
-      viewInfo.swizzle = formatInfo.Swizzle;
       viewInfo.usage   = VK_IMAGE_USAGE_STORAGE_BIT;
-      
+
+      if (!util::isIdentityMapping(formatInfo.Swizzle))
+        Logger::warn(str::format("UAV format ", pDesc->Format, " has non-identity swizzle, but UAV swizzles are not supported"));
+
       switch (pDesc->ViewDimension) {
         case D3D11_UAV_DIMENSION_TEXTURE1D:
           viewInfo.type      = VK_IMAGE_VIEW_TYPE_1D;
@@ -145,8 +147,11 @@ namespace dxvk {
       return S_OK;
     }
     
-    Logger::warn("D3D11UnorderedAccessView::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(ID3D11UnorderedAccessView), riid)) {
+      Logger::warn("D3D11UnorderedAccessView::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
   
@@ -209,7 +214,7 @@ namespace dxvk {
         D3D11_BUFFER_DESC bufferDesc;
         static_cast<D3D11Buffer*>(pResource)->GetDesc(&bufferDesc);
         
-        if (bufferDesc.MiscFlags == D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) {
+        if (bufferDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) {
           pDesc->Format              = DXGI_FORMAT_UNKNOWN;
           pDesc->ViewDimension       = D3D11_UAV_DIMENSION_BUFFER;
           pDesc->Buffer.FirstElement = 0;
@@ -427,7 +432,7 @@ namespace dxvk {
   }
 
 
-  Rc<DxvkBuffer> D3D11UnorderedAccessView::CreateCounterBuffer() {
+  Rc<DxvkBufferView> D3D11UnorderedAccessView::CreateCounterBufferView() {
     Rc<DxvkDevice> device = m_parent->GetDXVKDevice();
 
     DxvkBufferCreateInfo info;
@@ -441,7 +446,15 @@ namespace dxvk {
                 | VK_ACCESS_TRANSFER_READ_BIT
                 | VK_ACCESS_SHADER_WRITE_BIT
                 | VK_ACCESS_SHADER_READ_BIT;
-    return device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+    Rc<DxvkBuffer> buffer = device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+    DxvkBufferViewCreateInfo viewInfo;
+    viewInfo.format = VK_FORMAT_UNDEFINED;
+    viewInfo.rangeOffset = 0;
+    viewInfo.rangeLength = sizeof(uint32_t);
+
+    return device->createBufferView(buffer, viewInfo);
   }
   
 }

src/d3d11/d3d11_view_uav.h

@@ -57,10 +57,8 @@ namespace dxvk {
       return m_imageView;
     }
     
-    DxvkBufferSlice GetCounterSlice() const {
-      return m_counterBuffer != nullptr
-        ? DxvkBufferSlice(m_counterBuffer)
-        : DxvkBufferSlice();
+    Rc<DxvkBufferView> GetCounterView() const {
+      return m_counterView;
     }
     
     static HRESULT GetDescFromResource(
@@ -85,9 +83,9 @@ namespace dxvk {
     D3D11_VK_VIEW_INFO                m_info;
     Rc<DxvkBufferView>                m_bufferView;
     Rc<DxvkImageView>                 m_imageView;
-    Rc<DxvkBuffer>                    m_counterBuffer;
+    Rc<DxvkBufferView>                m_counterView;
 
-    Rc<DxvkBuffer> CreateCounterBuffer();
+    Rc<DxvkBufferView> CreateCounterBufferView();
     
   };
   

src/d3d11/meson.build

@@ -2,9 +2,6 @@ d3d11_res = wrc_generator.process('version.rc')
 
 dxgi_common_src = [
   '../dxgi/dxgi_format.cpp',
-  '../dxgi/dxgi_monitor.cpp',
-  '../dxgi/dxgi_surface.cpp',
-  '../dxgi/dxgi_swapchain.cpp',
 ]
 
 d3d10_src = [
@@ -45,6 +42,7 @@ d3d11_src = [
   'd3d11_input_layout.cpp',
   'd3d11_interop.cpp',
   'd3d11_main.cpp',
+  'd3d11_on_12.cpp',
   'd3d11_options.cpp',
   'd3d11_query.cpp',
   'd3d11_rasterizer.cpp',
@@ -71,15 +69,18 @@ d3d11_shaders = files([
 d3d11_ld_args      = []
 d3d11_link_depends = []
 
-if platform != 'windows'
+if platform == 'windows'
+  d3d11_dxgi_dep = lib_dxgi
+else
   d3d11_ld_args      += [ '-Wl,--version-script', join_paths(meson.current_source_dir(), 'd3d11.sym') ]
   d3d11_link_depends += files('d3d11.sym')
+  d3d11_dxgi_dep = dxgi_dep
 endif
 
 d3d11_dll = shared_library('d3d11'+dll_ext, dxgi_common_src + d3d11_src + d3d10_src,
     glsl_generator.process(d3d11_shaders), d3d11_res,
   name_prefix         : dxvk_name_prefix,
-  dependencies        : [ dxgi_dep, dxbc_dep, dxvk_dep ],
+  dependencies        : [ d3d11_dxgi_dep, dxbc_dep, dxvk_dep ],
   include_directories : dxvk_include_path,
   install             : true,
   vs_module_defs      : 'd3d11'+def_spec_ext,

src/d3d11/shaders/d3d11_video_blit_frag.frag

@@ -1,5 +1,7 @@
 #version 450
 
+#extension GL_EXT_samplerless_texture_functions : require
+
 // Can't use matrix types here since even a two-row
 // matrix will be padded to 16 bytes per column for
 // absolutely no reason
@@ -11,6 +13,8 @@ uniform ubo_t {
   vec2 coord_matrix_c1;
   vec2 coord_matrix_c2;
   vec2 coord_matrix_c3;
+  uvec2 src_offset;
+  uvec2 src_extent;
   float y_min;
   float y_max;
   bool is_planar;
@@ -19,9 +23,8 @@ uniform ubo_t {
 layout(location = 0) in vec2 i_texcoord;
 layout(location = 0) out vec4 o_color;
 
-layout(set = 0, binding = 1) uniform sampler s_sampler;
-layout(set = 0, binding = 2) uniform texture2D s_inputY;
-layout(set = 0, binding = 3) uniform texture2D s_inputCbCr;
+layout(set = 0, binding = 1) uniform texture2D s_inputY;
+layout(set = 0, binding = 2) uniform texture2D s_inputCbCr;
 
 void main() {
   // Transform input texture coordinates to
@@ -31,25 +34,61 @@ void main() {
     coord_matrix_c2,
     coord_matrix_c3);
 
-  vec2 coord = coord_matrix * vec3(i_texcoord, 1.0f);
-
-  // Fetch source image color
-  vec4 color = vec4(0.0f, 0.0f, 0.0f, 1.0f);
-
-  if (is_planar) {
-    color.g  = texture(sampler2D(s_inputY,    s_sampler), coord).r;
-    color.rb = texture(sampler2D(s_inputCbCr, s_sampler), coord).gr;
-    color.g  = clamp((color.g - y_min) / (y_max - y_min), 0.0f, 1.0f);
-  } else {
-    color = texture(sampler2D(s_inputY, s_sampler), coord);
-  }
-
-  // Color space transformation
+  // Load color space transform
   mat3x4 color_matrix = mat3x4(
     color_matrix_r1,
     color_matrix_r2,
     color_matrix_r3);
 
-  o_color.rgb = vec4(color.rgb, 1.0f) * color_matrix;
-  o_color.a = color.a;
+  // Compute actual pixel coordinates to sample. We filter
+  // manually in order to avoid bleeding from pixels outside
+  // the source rectangle.
+  vec2 abs_size_y = vec2(textureSize(s_inputY, 0));
+  vec2 abs_size_c = vec2(textureSize(s_inputCbCr, 0));
+
+  vec2 coord = coord_matrix * vec3(i_texcoord, 1.0f);
+  coord -= 0.5f / abs_size_y;
+
+  vec2 size_factor = abs_size_c / abs_size_y;
+
+  vec2 src_lo = vec2(src_offset);
+  vec2 src_hi = vec2(src_offset + src_extent - 1u);
+
+  vec2 abs_coord = coord * abs_size_y;
+  vec2 fract_coord = fract(clamp(abs_coord, src_lo, src_hi));
+
+  vec4 accum = vec4(0.0f, 0.0f, 0.0f, 0.0f);
+
+  for (int i = 0; i < 4; i++) {
+    ivec2 offset = ivec2(i & 1, i >> 1);
+
+    // Compute exact pixel coordinates for the current
+    // iteration and clamp it to the source rectangle.
+    vec2 fetch_coord = clamp(abs_coord + vec2(offset), src_lo, src_hi);
+
+    // Fetch actual pixel color in source color space
+    vec4 color;
+
+    if (is_planar) {
+      color.g  = texelFetch(s_inputY, ivec2(fetch_coord), 0).r;
+      color.rb = texelFetch(s_inputCbCr, ivec2(fetch_coord * size_factor), 0).gr;
+      color.g  = clamp((color.g - y_min) / (y_max - y_min), 0.0f, 1.0f);
+      color.a = 1.0f;
+    } else {
+      color = texelFetch(s_inputY, ivec2(fetch_coord), 0);
+    }
+
+    // Transform color space before accumulation
+    color.rgb = vec4(color.rgb, 1.0f) * color_matrix;
+
+    // Filter and accumulate final pixel color
+    vec2 factor = fract_coord;
+
+    if (offset.x == 0) factor.x = 1.0f - factor.x;
+    if (offset.y == 0) factor.y = 1.0f - factor.y;
+
+    accum += factor.x * factor.y * color;
+  }
+
+  o_color = accum;
 }

src/d3d9/d3d9.def

@@ -25,3 +25,6 @@ EXPORTS
   DXVK_UnRegisterAnnotation @28258 NONAME
 
   Direct3D9ForceHybridEnumeration @16 NONAME PRIVATE
+  
+  Direct3DCreate9On12 @20
+  Direct3DCreate9On12Ex @21

src/d3d9/d3d9.sym

@@ -18,6 +18,8 @@
     DXVK_RegisterAnnotation;
     DXVK_UnRegisterAnnotation;
     Direct3D9ForceHybridEnumeration;
+    Direct3DCreate9On12;
+    Direct3DCreate9On12Ex;
 
   local:
     *;

src/d3d9/d3d9_adapter.cpp

@@ -162,6 +162,9 @@ namespace dxvk {
     if (mapping.FormatSrgb  == VK_FORMAT_UNDEFINED && srgb)
       return D3DERR_NOTAVAILABLE;
 
+    if (RType == D3DRTYPE_CUBETEXTURE && mapping.Aspect != VK_IMAGE_ASPECT_COLOR_BIT)
+      return D3DERR_NOTAVAILABLE;
+
     if (RType == D3DRTYPE_VERTEXBUFFER || RType == D3DRTYPE_INDEXBUFFER)
       return D3D_OK;
 
@@ -224,11 +227,15 @@ namespace dxvk {
     if (!IsDepthFormat(DepthStencilFormat))
       return D3DERR_NOTAVAILABLE;
 
+    auto dsfMapping = ConvertFormatUnfixed(DepthStencilFormat);
+    if (dsfMapping.FormatColor == VK_FORMAT_UNDEFINED)
+      return D3DERR_NOTAVAILABLE;
+
     if (RenderTargetFormat == dxvk::D3D9Format::NULL_FORMAT)
       return D3D_OK;
 
-    auto mapping = ConvertFormatUnfixed(RenderTargetFormat);
-    if (mapping.FormatColor == VK_FORMAT_UNDEFINED)
+    auto rtfMapping = ConvertFormatUnfixed(RenderTargetFormat);
+    if (rtfMapping.FormatColor == VK_FORMAT_UNDEFINED)
       return D3DERR_NOTAVAILABLE;
 
     return D3D_OK;
@@ -529,7 +536,7 @@ namespace dxvk {
     // Max Vertex Blend Matrices
     pCaps->MaxVertexBlendMatrices    = 4;
     // Max Vertex Blend Matrix Index
-    pCaps->MaxVertexBlendMatrixIndex = 8;
+    pCaps->MaxVertexBlendMatrixIndex = 0;
     // Max Point Size
     pCaps->MaxPointSize              = 256.0f;
     // Max Primitive Count
@@ -788,7 +795,8 @@ namespace dxvk {
       // Fix up the D3DFORMAT to match what we are enumerating
       mode.Format = static_cast<D3DFORMAT>(Format);
 
-      m_modes.push_back(mode);
+      if (std::count(m_modes.begin(), m_modes.end(), mode) == 0)
+        m_modes.push_back(mode);
     }
 
     // Sort display modes by width, height and refresh rate,

src/d3d9/d3d9_annotation.h

@@ -2,8 +2,11 @@
 
 #include "d3d9_device.h"
 #include "d3d9_include.h"
+
 #include "../dxvk/dxvk_annotation.h"
 
+#include "../util/thread.h"
+
 #include <atomic>
 #include <mutex>
 #include <vector>
@@ -43,7 +46,7 @@ namespace dxvk {
 
     std::atomic<bool> m_shouldAnnotate;
 
-    std::mutex m_mutex;
+    dxvk::mutex m_mutex;
     std::vector<IDXVKUserDefinedAnnotation*> m_annotations;
 
     // Provide our own event depth as we

src/d3d9/d3d9_bridge.cpp

@@ -0,0 +1,111 @@
+
+#include "d3d9_device.h"
+#include "d3d9_interface.h"
+#include "d3d9_bridge.h"
+#include "d3d9_swapchain.h"
+#include "d3d9_surface.h"
+
+namespace dxvk {
+
+  DxvkD3D8Bridge::DxvkD3D8Bridge(D3D9DeviceEx* pDevice)
+    : m_device(pDevice) {
+  }
+
+  DxvkD3D8Bridge::~DxvkD3D8Bridge() {
+  }
+
+  ULONG STDMETHODCALLTYPE DxvkD3D8Bridge::AddRef() {
+    return m_device->AddRef();
+  }
+
+  ULONG STDMETHODCALLTYPE DxvkD3D8Bridge::Release() {
+    return m_device->Release();
+  }
+
+  HRESULT STDMETHODCALLTYPE DxvkD3D8Bridge::QueryInterface(
+          REFIID  riid,
+          void** ppvObject) {
+    return m_device->QueryInterface(riid, ppvObject);
+  }
+
+  void DxvkD3D8Bridge::SetAPIName(const char* name) {
+    m_device->m_implicitSwapchain->SetApiName(name);
+  }
+
+  void DxvkD3D8Bridge::SetD3D8CompatibilityMode(const bool compatMode) {
+    m_device->SetD3D8CompatibilityMode(compatMode);
+  }
+
+  HRESULT DxvkD3D8Bridge::UpdateTextureFromBuffer(
+        IDirect3DSurface9*  pDestSurface,
+        IDirect3DSurface9*  pSrcSurface,
+        const RECT*         pSrcRect,
+        const POINT*        pDestPoint) {
+    auto lock = m_device->LockDevice();
+
+    D3D9Surface* dst = static_cast<D3D9Surface*>(pDestSurface);
+    D3D9Surface* src = static_cast<D3D9Surface*>(pSrcSurface);
+
+    if (unlikely(dst == nullptr || src == nullptr))
+      return D3DERR_INVALIDCALL;
+
+    D3D9CommonTexture* srcTextureInfo = src->GetCommonTexture();
+    D3D9CommonTexture* dstTextureInfo = dst->GetCommonTexture();
+
+    VkOffset3D srcOffset = { 0u, 0u, 0u };
+    VkOffset3D dstOffset = { 0u, 0u, 0u };
+    VkExtent3D texLevelExtent = srcTextureInfo->GetExtentMip(src->GetSubresource());
+    VkExtent3D extent = texLevelExtent;
+
+    srcOffset = { pSrcRect->left,
+                  pSrcRect->top,
+                  0u };
+
+    extent = { uint32_t(pSrcRect->right - pSrcRect->left), uint32_t(pSrcRect->bottom - pSrcRect->top), 1 };
+
+    // TODO: Validate extents like in D3D9DeviceEx::UpdateSurface
+
+    dstOffset = { pDestPoint->x,
+                  pDestPoint->y,
+                  0u };
+
+
+    m_device->UpdateTextureFromBuffer(
+      srcTextureInfo, dstTextureInfo,
+      src->GetSubresource(), dst->GetSubresource(),
+      srcOffset, extent, dstOffset
+    );
+
+    dstTextureInfo->SetNeedsReadback(dst->GetSubresource(), true);
+
+    if (dstTextureInfo->IsAutomaticMip())
+      m_device->MarkTextureMipsDirty(dstTextureInfo);
+    
+    return D3D_OK;
+  }
+
+  DxvkD3D8InterfaceBridge::DxvkD3D8InterfaceBridge(D3D9InterfaceEx* pObject)
+    : m_interface(pObject) {
+  }
+
+  DxvkD3D8InterfaceBridge::~DxvkD3D8InterfaceBridge() {
+  }
+
+  ULONG STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::AddRef() {
+    return m_interface->AddRef();
+  }
+
+  ULONG STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::Release() {
+    return m_interface->Release();
+  }
+
+  HRESULT STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::QueryInterface(
+          REFIID  riid,
+          void** ppvObject) {
+    return m_interface->QueryInterface(riid, ppvObject);
+  }
+
+  const Config* DxvkD3D8InterfaceBridge::GetConfig() const {
+    return &m_interface->GetInstance()->config();
+  }
+}

src/d3d9/d3d9_bridge.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include <windows.h>
+#include "../util/config/config.h"
+
+#include "../vulkan/vulkan_loader.h"
+
+/**
+ * The D3D9 bridge allows D3D8 to access DXVK internals.
+ * For Vulkan interop without needing DXVK internals, see d3d9_interop.h.
+ * 
+ * NOTE: You must include "d3d9_include.h" or "d3d8_include.h" before this header.
+ */
+
+/**
+ * \brief D3D9 device interface for D3D8 interop
+ */
+MIDL_INTERFACE("D3D9D3D8-42A9-4C1E-AA97-BEEFCAFE2000")
+IDxvkD3D8Bridge : public IUnknown {
+
+  // D3D8 keeps D3D9 objects contained in a namespace.
+  #ifdef DXVK_D3D9_NAMESPACE
+    using IDirect3DSurface9 = d3d9::IDirect3DSurface9;
+  #endif
+
+  /**
+   * \brief Changes the API name displayed on the HUD
+   * 
+   * \param [in] name The new API name 
+   */
+  virtual void SetAPIName(const char* name) = 0;
+
+  /**
+   * \brief Enables or disables D3D9-specific device features and validations
+   * 
+   * \param [in] compatibility state
+   */
+  virtual void SetD3D8CompatibilityMode(const bool compatMode) = 0;
+
+  /**
+   * \brief Updates a D3D9 surface from a D3D9 buffer
+   * 
+   * \param [in] pDestSurface Destination surface (typically in VRAM)
+   * \param [in] pSrcSurface  Source surface (typically in system memory)
+   * \param [in] pSrcRect     Source rectangle
+   * \param [in] pDestPoint   Destination (top-left) point
+   */
+  virtual HRESULT UpdateTextureFromBuffer(
+      IDirect3DSurface9*        pDestSurface,
+      IDirect3DSurface9*        pSrcSurface,
+      const RECT*               pSrcRect,
+      const POINT*              pDestPoint) = 0;
+};
+
+/**
+ * \brief D3D9 instance interface for D3D8 interop
+ */
+MIDL_INTERFACE("D3D9D3D8-A407-773E-18E9-CAFEBEEF3000")
+IDxvkD3D8InterfaceBridge : public IUnknown {
+  /**
+   * \brief Retrieves the DXVK configuration
+   * 
+   * \returns The DXVK Config object
+   */
+  virtual const dxvk::Config* GetConfig() const = 0;
+};
+
+#ifndef _MSC_VER
+__CRT_UUID_DECL(IDxvkD3D8Bridge, 0xD3D9D3D8, 0x42A9, 0x4C1E, 0xAA, 0x97, 0xBE, 0xEF, 0xCA, 0xFE, 0x20, 0x00);
+__CRT_UUID_DECL(IDxvkD3D8InterfaceBridge, 0xD3D9D3D8, 0xA407, 0x773E, 0x18, 0xE9, 0xCA, 0xFE, 0xBE, 0xEF, 0x30, 0x00);
+#endif
+
+namespace dxvk {
+
+  class D3D9DeviceEx;
+  class D3D9InterfaceEx;
+
+  class DxvkD3D8Bridge : public IDxvkD3D8Bridge {
+  public:
+    DxvkD3D8Bridge(D3D9DeviceEx* pDevice);
+    ~DxvkD3D8Bridge();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID  riid,
+            void** ppvObject);
+
+    void SetAPIName(const char* name);
+    void SetD3D8CompatibilityMode(const bool compatMode);
+
+    HRESULT UpdateTextureFromBuffer(
+        IDirect3DSurface9*        pDestSurface,
+        IDirect3DSurface9*        pSrcSurface,
+        const RECT*               pSrcRect,
+        const POINT*              pDestPoint);
+
+  private:
+    D3D9DeviceEx* m_device;
+  };
+
+  class DxvkD3D8InterfaceBridge : public IDxvkD3D8InterfaceBridge {
+  public:
+    DxvkD3D8InterfaceBridge(D3D9InterfaceEx* pObject);
+    ~DxvkD3D8InterfaceBridge();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID  riid,
+            void** ppvObject);
+
+    const Config* GetConfig() const;
+    
+  protected:
+    D3D9InterfaceEx* m_interface;
+  };
+}

src/d3d9/d3d9_buffer.cpp

@@ -29,8 +29,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D9VertexBuffer::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(IDirect3DVertexBuffer9), riid)) {
+      Logger::warn("D3D9VertexBuffer::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 
@@ -86,8 +89,11 @@ namespace dxvk {
       return S_OK;
     }
 
-    Logger::warn("D3D9IndexBuffer::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(IDirect3DIndexBuffer9), riid)) {
+      Logger::warn("D3D9IndexBuffer::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 

src/d3d9/d3d9_common_buffer.cpp

@@ -20,6 +20,11 @@ namespace dxvk {
       m_dirtyRange = D3D9Range(0, m_desc.Size);
   }
 
+  D3D9CommonBuffer::~D3D9CommonBuffer() {
+    if (m_desc.Pool == D3DPOOL_DEFAULT)
+      m_parent->DecrementLosableCounter();
+  }
+
 
   HRESULT D3D9CommonBuffer::Lock(
           UINT   OffsetToLock,
@@ -57,6 +62,32 @@ namespace dxvk {
     }
   }
 
+  
+  D3D9_COMMON_BUFFER_MAP_MODE D3D9CommonBuffer::DetermineMapMode(const D3D9Options* options) const {
+    if (m_desc.Pool != D3DPOOL_DEFAULT)
+      return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER;
+
+    // CSGO keeps vertex buffers locked across multiple frames and writes to it. It uses them for drawing without unlocking first.
+    // Tests show that D3D9 DEFAULT + USAGE_DYNAMIC behaves like a directly mapped buffer even when unlocked.
+    // DEFAULT + WRITEONLY does not behave like a directly mapped buffer EXCEPT if its locked at the moment.
+    // That's annoying to implement so we just always directly map DEFAULT + WRITEONLY.
+    if (!(m_desc.Usage & (D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY)))
+      return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER;
+
+    // Tests show that DISCARD does not work for pure SWVP devices.
+    // So force staging buffer path to avoid stalls.
+    // Dark Romance: Vampire in Love also expects draws to be synchronous
+    // and breaks if we respect NOOVERWRITE.
+    // D&D Temple of Elemental Evil breaks if we respect DISCARD. 
+    if (m_parent->CanOnlySWVP())
+      return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER;
+
+    if (!options->allowDirectBufferMapping)
+      return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER;
+
+    return D3D9_COMMON_BUFFER_MAP_MODE_DIRECT;
+  }
+
 
   Rc<DxvkBuffer> D3D9CommonBuffer::CreateBuffer() const {
     DxvkBufferCreateInfo  info;
@@ -103,7 +134,8 @@ namespace dxvk {
       memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
     }
 
-    if (memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT && m_parent->GetOptions()->apitraceMode) {
+    if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && m_parent->GetOptions()->cachedDynamicBuffers) {
+      memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
       memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                   |  VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
     }

src/d3d9/d3d9_common_buffer.h

@@ -78,6 +78,8 @@ namespace dxvk {
             D3D9DeviceEx*      pDevice,
       const D3D9_BUFFER_DESC*  pDesc);
 
+    ~D3D9CommonBuffer();
+
     HRESULT Lock(
             UINT   OffsetToLock,
             UINT   SizeToLock,
@@ -89,11 +91,7 @@ namespace dxvk {
     /**
     * \brief Determine the mapping mode of the buffer, (ie. direct mapping or backed)
     */
-    inline D3D9_COMMON_BUFFER_MAP_MODE DetermineMapMode(const D3D9Options* options) const {
-      return (m_desc.Pool == D3DPOOL_DEFAULT && (m_desc.Usage & (D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY)) && options->allowDirectBufferMapping)
-        ? D3D9_COMMON_BUFFER_MAP_MODE_DIRECT
-        : D3D9_COMMON_BUFFER_MAP_MODE_BUFFER;
-    }
+    D3D9_COMMON_BUFFER_MAP_MODE DetermineMapMode(const D3D9Options* options) const;
 
     /**
     * \brief Get the mapping mode of the buffer, (ie. direct mapping or backed)
@@ -127,7 +125,12 @@ namespace dxvk {
 
     template <D3D9_COMMON_BUFFER_TYPE Type>
     inline DxvkBufferSlice GetBufferSlice(VkDeviceSize offset, VkDeviceSize length) const {
-      return DxvkBufferSlice(GetBuffer<Type>(), offset, length);
+     if (likely(length && offset < m_desc.Size)) {
+        return DxvkBufferSlice(GetBuffer<Type>(), offset,
+          std::min<VkDeviceSize>(m_desc.Size - offset, length));
+     }
+
+      return DxvkBufferSlice();
     }
 
     inline DxvkBufferSliceHandle AllocMapSlice() {
@@ -208,6 +211,10 @@ namespace dxvk {
         : DxvkCsThread::SynchronizeAll;
     }
 
+    bool IsSysmemDynamic() const {
+      return m_desc.Pool == D3DPOOL_SYSTEMMEM && (m_desc.Usage & D3DUSAGE_DYNAMIC) != 0;
+    }
+
   private:
 
     Rc<DxvkBuffer> CreateBuffer() const;
@@ -227,7 +234,7 @@ namespace dxvk {
 
     D3D9DeviceEx*               m_parent;
     const D3D9_BUFFER_DESC      m_desc;
-    DWORD                       m_mapFlags;
+    DWORD                       m_mapFlags = 0;
     bool                        m_needsReadback = false;
     D3D9_COMMON_BUFFER_MAP_MODE m_mapMode;
 

src/d3d9/d3d9_common_texture.cpp

@@ -22,18 +22,21 @@ namespace dxvk {
                     ? D3D9Format::D32
                     : D3D9Format::X8R8G8B8;
 
+    m_exposedMipLevels = m_desc.MipLevels;
+
+    if (m_desc.Usage & D3DUSAGE_AUTOGENMIPMAP)
+      m_exposedMipLevels = 1;
+
     for (uint32_t i = 0; i < m_dirtyBoxes.size(); i++) {
       AddDirtyBox(nullptr, i);
     }
 
-    if (m_desc.Pool != D3DPOOL_DEFAULT) {
-      const uint32_t subresources = CountSubresources();
-      for (uint32_t i = 0; i < subresources; i++) {
-        SetNeedsUpload(i, true);
-      }
-      if (pSharedHandle) {
-        throw DxvkError("D3D9: Incompatible pool type for texture sharing.");
-      }
+    if (m_desc.Pool != D3DPOOL_DEFAULT && pSharedHandle) {
+      throw DxvkError("D3D9: Incompatible pool type for texture sharing.");
+    }
+
+    if (IsPoolManaged(m_desc.Pool)) {
+      SetAllNeedUpload();
     }
 
     m_mapping = pDevice->LookupFormat(m_desc.Format);
@@ -88,11 +91,6 @@ namespace dxvk {
       m_data = m_device->GetAllocator()->Alloc(m_totalSize);
     else if (m_mapMode != D3D9_COMMON_TEXTURE_MAP_MODE_NONE && m_desc.Pool != D3DPOOL_DEFAULT)
       CreateBuffer(false);
-
-    m_exposedMipLevels = m_desc.MipLevels;
-
-    if (m_desc.Usage & D3DUSAGE_AUTOGENMIPMAP)
-      m_exposedMipLevels = 1;
   }
 
 
@@ -101,6 +99,9 @@ namespace dxvk {
       m_device->ChangeReportedMemory(m_size);
 
     m_device->RemoveMappedTexture(this);
+
+    if (m_desc.Pool == D3DPOOL_DEFAULT)
+      m_device->DecrementLosableCounter();
   }
 
 
@@ -117,6 +118,7 @@ namespace dxvk {
 
   HRESULT D3D9CommonTexture::NormalizeTextureProperties(
           D3D9DeviceEx*             pDevice,
+          D3DRESOURCETYPE           ResourceType,
           D3D9_COMMON_TEXTURE_DESC* pDesc) {
     auto* options = pDevice->GetOptions();
 
@@ -130,6 +132,11 @@ namespace dxvk {
         options->disableA8RT)
       return D3DERR_INVALIDCALL;
 
+    // Cube textures with depth formats are not supported on any native
+    // driver, and allowing them triggers a broken code path in Gothic 3.
+    if (ResourceType == D3DRTYPE_CUBETEXTURE && mapping.Aspect != VK_IMAGE_ASPECT_COLOR_BIT)
+      return D3DERR_INVALIDCALL;
+
     // If the mapping is invalid then lets return invalid
     // Some edge cases:
     // NULL format does not map to anything, but should succeed
@@ -241,13 +248,21 @@ namespace dxvk {
     const VkExtent3D mipExtent = util::computeMipLevelExtent(
       GetExtent(), MipLevel);
 
+    VkExtent3D blockSize = formatInfo->blockSize;
+    uint32_t elementSize = formatInfo->elementSize;
+    if (unlikely(formatInfo->flags.test(DxvkFormatFlag::MultiPlane))) {
+      // D3D9 doesn't allow specifying the plane when locking a texture.
+      // So the subsampled planes inherit the pitch of the first plane.
+      // That means the size is the size of plane 0 * plane count
+      elementSize = formatInfo->planes[0].elementSize;
+      blockSize = { formatInfo->planes[0].blockSize.width, formatInfo->planes[0].blockSize.height, 1u };
+    }
+
     const VkExtent3D blockCount = util::computeBlockCount(
-      mipExtent, formatInfo->blockSize);
+      mipExtent, blockSize);
 
-    const uint32_t planeCount = m_mapping.ConversionFormatInfo.PlaneCount;
-
-    return std::min(planeCount, 2u)
-         * align(formatInfo->elementSize * blockCount.width, 4)
+    return std::min(GetPlaneCount(), 2u)
+         * align(elementSize * blockCount.width, 4)
          * blockCount.height
          * blockCount.depth;
   }
@@ -359,7 +374,7 @@ namespace dxvk {
     if (!CheckImageSupport(&imageInfo, imageInfo.tiling)) {
       throw DxvkError(str::format(
         "D3D9: Cannot create texture:",
-        "\n  Type:    ", std::hex, ResourceType,
+        "\n  Type:    0x", std::hex, ResourceType, std::dec,
         "\n  Format:  ", m_desc.Format,
         "\n  Extent:  ", m_desc.Width,
                     "x", m_desc.Height,
@@ -367,8 +382,8 @@ namespace dxvk {
         "\n  Samples: ", m_desc.MultiSample,
         "\n  Layers:  ", m_desc.ArraySize,
         "\n  Levels:  ", m_desc.MipLevels,
-        "\n  Usage:   ", std::hex, m_desc.Usage,
-        "\n  Pool:    ", std::hex, m_desc.Pool));
+        "\n  Usage:   0x", std::hex, m_desc.Usage, std::dec,
+        "\n  Pool:    0x", std::hex, m_desc.Pool, std::dec));
     }
 
     return m_device->GetDXVKDevice()->createImage(imageInfo, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
@@ -678,4 +693,13 @@ namespace dxvk {
     return DxvkBufferSlice(GetBuffer(), m_memoryOffset[Subresource], GetMipSize(Subresource));
   }
 
+  
+  uint32_t D3D9CommonTexture::GetPlaneCount() const {
+    const DxvkFormatInfo* formatInfo = m_mapping.FormatColor != VK_FORMAT_UNDEFINED
+      ? lookupFormatInfo(m_mapping.FormatColor)
+      : m_device->UnsupportedFormatInfo(m_desc.Format);
+
+    return vk::getPlaneCount(formatInfo->aspectMask);
+  }
+
 }

src/d3d9/d3d9_common_texture.h

@@ -179,11 +179,14 @@ namespace dxvk {
      * Fills in undefined values and validates the texture
      * parameters. Any error returned by this method should
      * be forwarded to the application.
+     * \param [in] pDevice D3D9 device
+     * \param [in] ResourceType Resource type
      * \param [in,out] pDesc Texture description
      * \returns \c S_OK if the parameters are valid
      */
     static HRESULT NormalizeTextureProperties(
             D3D9DeviceEx*              pDevice,
+            D3DRESOURCETYPE            ResourceType,
             D3D9_COMMON_TEXTURE_DESC*  pDesc);
 
     /**
@@ -307,14 +310,16 @@ namespace dxvk {
       return util::computeMipLevelExtent(GetExtent(), MipLevel);
     }
 
-    bool MarkHazardous() {
-      return std::exchange(m_hazardous, true);
+    bool MarkTransitionedToHazardLayout() {
+      return std::exchange(m_transitionedToHazardLayout, true);
     }
 
     D3DRESOURCETYPE GetType() {
       return m_type;
     }
 
+    uint32_t GetPlaneCount() const;
+
     const D3D9_VK_FORMAT_MAPPING& GetMapping() { return m_mapping; }
 
     void SetLocked(UINT Subresource, bool value) { m_locked.set(Subresource, value); }
@@ -338,7 +343,7 @@ namespace dxvk {
     }
 
     VkImageLayout DetermineRenderTargetLayout(VkImageLayout hazardLayout) const {
-      if (unlikely(m_hazardous))
+      if (unlikely(m_transitionedToHazardLayout))
         return hazardLayout;
 
       return m_image != nullptr &&
@@ -348,18 +353,16 @@ namespace dxvk {
     }
 
     VkImageLayout DetermineDepthStencilLayout(bool write, bool hazardous, VkImageLayout hazardLayout) const {
-      VkImageLayout layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-
-      if (unlikely(hazardous)) {
-        layout = write
-          ? hazardLayout
-          : VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
-      }
+      if (unlikely(m_transitionedToHazardLayout))
+        return hazardLayout;
 
       if (unlikely(m_image->info().tiling != VK_IMAGE_TILING_OPTIMAL))
-        layout = VK_IMAGE_LAYOUT_GENERAL;
+        return VK_IMAGE_LAYOUT_GENERAL;
 
-      return layout;
+      if (unlikely(hazardous && !write))
+        return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
+
+      return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     }
 
     Rc<DxvkImageView> CreateView(
@@ -370,7 +373,15 @@ namespace dxvk {
     D3D9SubresourceBitset& GetUploadBitmask() { return m_needsUpload; }
 
     void SetAllNeedUpload() {
-      m_needsUpload.setAll();
+      if (likely(!IsAutomaticMip())) {
+        m_needsUpload.setAll();
+      } else {
+        for (uint32_t a = 0; a < m_desc.ArraySize; a++) {
+          for (uint32_t m = 0; m < ExposedMipLevels(); m++) {
+            SetNeedsUpload(CalcSubresource(a, m), true);
+          }
+        }
+      }
     }
     void SetNeedsUpload(UINT Subresource, bool upload) { m_needsUpload.set(Subresource, upload); }
     bool NeedsUpload(UINT Subresource) const { return m_needsUpload.get(Subresource); }
@@ -380,7 +391,7 @@ namespace dxvk {
     void SetNeedsMipGen(bool value) { m_needsMipGen = value; }
     bool NeedsMipGen() const { return m_needsMipGen; }
 
-    DWORD ExposedMipLevels() { return m_exposedMipLevels; }
+    DWORD ExposedMipLevels() const { return m_exposedMipLevels; }
 
     void SetMipFilter(D3DTEXTUREFILTERTYPE filter) { m_mipFilter = filter; }
     D3DTEXTUREFILTERTYPE GetMipFilter() const { return m_mipFilter; }
@@ -502,7 +513,7 @@ namespace dxvk {
 
     int64_t                       m_size = 0;
 
-    bool                          m_hazardous = false;
+    bool                          m_transitionedToHazardLayout = false;
 
     D3D9ColorView                 m_sampleView;
 

src/d3d9/d3d9_constant_buffer.cpp

@@ -13,7 +13,7 @@ namespace dxvk {
           DxsoProgramType       ShaderStage,
           DxsoConstantBuffers   BufferType,
           VkDeviceSize          Size)
-  : D3D9ConstantBuffer(pDevice, GetShaderStage(ShaderStage),
+  : D3D9ConstantBuffer(pDevice, getBufferUsage(pDevice, ShaderStage, BufferType), GetShaderStage(ShaderStage),
       computeResourceSlotId(ShaderStage, DxsoBindingType::ConstantBuffer, BufferType),
       Size) {
 
@@ -22,11 +22,13 @@ namespace dxvk {
 
   D3D9ConstantBuffer::D3D9ConstantBuffer(
           D3D9DeviceEx*         pDevice,
+          VkBufferUsageFlags    Usage,
           VkShaderStageFlags    Stages,
           uint32_t              ResourceSlot,
           VkDeviceSize          Size)
   : m_device    (pDevice)
   , m_binding   (ResourceSlot)
+  , m_usage     (Usage)
   , m_stages    (Stages)
   , m_size      (Size)
   , m_align     (getAlignment(pDevice->GetDXVKDevice())) {
@@ -65,7 +67,7 @@ namespace dxvk {
       cOffset   = m_offset,
       cLength   = size
     ] (DxvkContext* ctx) {
-      ctx->bindResourceBufferRange(cStages, cBinding, cOffset, cLength);
+      ctx->bindUniformBufferRange(cStages, cBinding, cOffset, cLength);
     });
 
     void* mapPtr = reinterpret_cast<char*>(m_slice.mapPtr) + m_offset;
@@ -98,12 +100,15 @@ namespace dxvk {
     // in the backend, so set both STORAGE and UNIFORM usage/access.
     DxvkBufferCreateInfo bufferInfo;
     bufferInfo.size   = align(m_size, m_align);
-    bufferInfo.usage  = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
-                      | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-    bufferInfo.access = VK_ACCESS_UNIFORM_READ_BIT
-                      | VK_ACCESS_SHADER_READ_BIT;
+    bufferInfo.usage  = m_usage;
+    bufferInfo.access = 0;
     bufferInfo.stages = util::pipelineStages(m_stages);
 
+    if (m_usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
+      bufferInfo.access |= VK_ACCESS_UNIFORM_READ_BIT;
+    if (m_usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
+      bufferInfo.access |= VK_ACCESS_SHADER_READ_BIT;
+
     VkMemoryPropertyFlags memoryFlags
       = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
       | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
@@ -118,7 +123,7 @@ namespace dxvk {
       cBinding  = m_binding,
       cSlice    = DxvkBufferSlice(m_buffer)
     ] (DxvkContext* ctx) mutable {
-      ctx->bindResourceBuffer(cStages, cBinding, std::move(cSlice));
+      ctx->bindUniformBuffer(cStages, cBinding, std::move(cSlice));
     });
   }
 
@@ -130,4 +135,21 @@ namespace dxvk {
       device->properties().extRobustness2.robustUniformBufferAccessSizeAlignment);
   }
 
+
+  VkBufferUsageFlags D3D9ConstantBuffer::getBufferUsage(
+          D3D9DeviceEx*         pDevice,
+          DxsoProgramType       ShaderStage,
+          DxsoConstantBuffers   BufferType) {
+    VkBufferUsageFlags result = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+
+    // We won't always need this, but the only buffer that
+    // this applies to is so large that it will not matter.
+    if (pDevice->CanSWVP()
+     && ShaderStage == DxsoProgramType::VertexShader
+     && BufferType == DxsoConstantBuffers::VSConstantBuffer)
+      result |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+
+    return result;
+  }
+
 }

src/d3d9/d3d9_constant_buffer.h

@@ -29,6 +29,7 @@ namespace dxvk {
 
     D3D9ConstantBuffer(
             D3D9DeviceEx*         pDevice,
+            VkBufferUsageFlags    Usage,
             VkShaderStageFlags    Stages,
             uint32_t              ResourceSlot,
             VkDeviceSize          Size);
@@ -66,6 +67,7 @@ namespace dxvk {
     D3D9DeviceEx*         m_device  = nullptr;
 
     uint32_t              m_binding = 0u;
+    VkBufferUsageFlags    m_usage   = 0u;
     VkShaderStageFlags    m_stages  = 0u;
     VkDeviceSize          m_size    = 0ull;
     VkDeviceSize          m_align   = 0ull;
@@ -78,6 +80,11 @@ namespace dxvk {
 
     VkDeviceSize getAlignment(const Rc<DxvkDevice>& device) const;
 
+    static VkBufferUsageFlags getBufferUsage(
+            D3D9DeviceEx*         pDevice,
+            DxsoProgramType       ShaderStage,
+            DxsoConstantBuffers   BufferType);
+
   };
 
 }

src/d3d9/d3d9_cursor.cpp

@@ -16,7 +16,11 @@ namespace dxvk {
 
 
   BOOL D3D9Cursor::ShowCursor(BOOL bShow) {
-    ::SetCursor(bShow ? m_hCursor : nullptr);
+    if (likely(m_hCursor != nullptr))
+      ::SetCursor(bShow ? m_hCursor : nullptr);
+    else
+      Logger::debug("D3D9Cursor::ShowCursor: Software cursor not implemented.");
+    
     return std::exchange(m_visible, bShow);
   }
 
@@ -63,4 +67,4 @@ namespace dxvk {
   }
 #endif
 
-}
+}

src/d3d9/d3d9_device.h

@@ -28,12 +28,17 @@
 
 #include "d3d9_spec_constants.h"
 #include "d3d9_interop.h"
+#include "d3d9_on_12.h"
 
+#include <cstdint>
 #include <unordered_set>
+#include "d3d9_bridge.h"
+
 #include <vector>
 #include <type_traits>
 #include <unordered_map>
 
+#include "../util/util_flush.h"
 #include "../util/util_lru.h"
 
 namespace dxvk {
@@ -61,6 +66,8 @@ namespace dxvk {
     DirtyInputLayout,
     DirtyViewportScissor,
     DirtyMultiSampleState,
+    DirtyVertexBuffers,
+    DirtyIndexBuffer,
 
     DirtyFogState,
     DirtyFogColor,
@@ -87,6 +94,12 @@ namespace dxvk {
 
   using D3D9DeviceFlags = Flags<D3D9DeviceFlag>;
 
+  enum class D3D9DeviceLostState {
+    Ok = 0,
+    Lost = 1,
+    NotReset = 2,
+  };
+
   struct D3D9DrawInfo {
     uint32_t vertexCount;
     uint32_t instanceCount;
@@ -117,8 +130,10 @@ namespace dxvk {
     constexpr static VkDeviceSize StagingBufferSize = 4ull << 20;
 
     friend class D3D9SwapChainEx;
+    friend struct D3D9WindowContext;
     friend class D3D9ConstantBuffer;
     friend class D3D9UserDefinedAnnotation;
+    friend class DxvkD3D8Bridge;
     friend D3D9VkInteropDevice;
   public:
 
@@ -751,6 +766,24 @@ namespace dxvk {
     HRESULT UnlockBuffer(
             D3D9CommonBuffer*       pResource);
 
+    /**
+     * @brief Uploads data from D3DPOOL_SYSMEM + D3DUSAGE_DYNAMIC buffers and binds the temporary buffers.
+     * 
+     * @param FirstVertexIndex The first vertex
+     * @param NumVertices The number of vertices that are accessed. If this is 0, the vertex buffer binding will not be modified.
+     * @param FirstIndex The first index
+     * @param NumIndices The number of indices that will be drawn. If this is 0, the index buffer binding will not be modified.
+     */
+    void UploadDynamicSysmemBuffers(
+            UINT&                   FirstVertexIndex,
+            UINT                    NumVertices,
+            UINT&                   FirstIndex,
+            UINT                    NumIndices,
+            INT&                    BaseVertexIndex,
+            bool*                   pDynamicVBOs,
+            bool*                   pDynamicIBO);
+    
+
     void SetupFPU();
 
     int64_t DetermineInitialTextureMemory();
@@ -760,6 +793,7 @@ namespace dxvk {
     void SynchronizeCsThread(uint64_t SequenceNumber);
 
     void Flush();
+    void FlushAndSync9On12();
 
     void EndFrame();
 
@@ -767,6 +801,9 @@ namespace dxvk {
 
     void UpdateActiveRTs(uint32_t index);
 
+    template <uint32_t Index>
+    void UpdateAnyColorWrites(bool has);
+
     void UpdateActiveTextures(uint32_t index, DWORD combinedUsage);
 
     void UpdateActiveHazardsRT(uint32_t rtMask);
@@ -800,7 +837,7 @@ namespace dxvk {
     inline bool IsAlphaToCoverageEnabled() {
       const bool alphaTest = m_state.renderStates[D3DRS_ALPHATESTENABLE] != 0;
 
-      return m_amdATOC || (m_nvATOC && alphaTest);
+      return (m_amdATOC || (m_nvATOC && alphaTest)) && m_flags.test(D3D9DeviceFlag::ValidSampleMask);
     }
 
     inline bool IsDepthBiasEnabled() {
@@ -868,6 +905,10 @@ namespace dxvk {
 
     void MarkTextureBindingDirty(IDirect3DBaseTexture9* texture);
 
+    HRESULT STDMETHODCALLTYPE SetRenderTargetInternal(
+            DWORD              RenderTargetIndex,
+            IDirect3DSurface9* pRenderTarget);
+
     D3D9DrawInfo GenerateDrawInfo(
       D3DPRIMITIVETYPE PrimitiveType,
       UINT             PrimitiveCount,
@@ -875,7 +916,7 @@ namespace dxvk {
     
     uint32_t GetInstanceCount() const;
 
-    void PrepareDraw(D3DPRIMITIVETYPE PrimitiveType);
+    void PrepareDraw(D3DPRIMITIVETYPE PrimitiveType, bool UploadVBOs, bool UploadIBOs);
 
     template <DxsoProgramType ShaderStage>
     void BindShader(
@@ -909,7 +950,7 @@ namespace dxvk {
     void SetVertexBoolBitfield(uint32_t idx, uint32_t mask, uint32_t bits);
     void SetPixelBoolBitfield (uint32_t idx, uint32_t mask, uint32_t bits);
 
-    void FlushImplicit(BOOL StrongHint);
+    void ConsiderFlush(GpuFlushType FlushType);
 
     bool ChangeReportedMemory(int64_t delta) {
       if (IsExtended())
@@ -933,7 +974,7 @@ namespace dxvk {
     const D3D9ConstantLayout& GetVertexConstantLayout() { return m_vsLayout; }
     const D3D9ConstantLayout& GetPixelConstantLayout()  { return m_psLayout; }
 
-    HRESULT ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters);
+    void ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters);
     HRESULT ResetSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode);
 
     HRESULT InitialReset(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode);
@@ -950,6 +991,37 @@ namespace dxvk {
     void TouchMappedTexture(D3D9CommonTexture* pTexture);
     void RemoveMappedTexture(D3D9CommonTexture* pTexture);
 
+    bool IsD3D8Compatible() const {
+      return m_isD3D8Compatible;
+    }
+
+    void SetD3D8CompatibilityMode(bool compatMode) {
+      if (compatMode)
+        Logger::info("The D3D9 device is now operating in D3D8 compatibility mode.");
+
+      m_isD3D8Compatible = compatMode;
+    }
+
+    // Device Lost
+    bool IsDeviceLost() const {
+      return m_deviceLostState != D3D9DeviceLostState::Ok;
+    }
+
+    void NotifyFullscreen(HWND window, bool fullscreen);
+    void NotifyWindowActivated(HWND window, bool activated);
+
+    void IncrementLosableCounter() {
+      m_losableResourceCounter++;
+    }
+
+    void DecrementLosableCounter() {
+      m_losableResourceCounter--;
+    }
+
+    bool CanOnlySWVP() const {
+      return m_behaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING;
+    }
+
   private:
 
     DxvkCsChunkRef AllocCsChunk() {
@@ -957,12 +1029,15 @@ namespace dxvk {
       return DxvkCsChunkRef(chunk, &m_csChunkPool);
     }
 
-    template<typename Cmd>
+    template<bool AllowFlush = true, typename Cmd>
     void EmitCs(Cmd&& command) {
       if (unlikely(!m_csChunk->push(command))) {
         EmitCsChunk(std::move(m_csChunk));
-
         m_csChunk = AllocCsChunk();
+
+        if constexpr (AllowFlush)
+          ConsiderFlush(GpuFlushType::ImplicitWeakHint);
+
         m_csChunk->push(command);
       }
     }
@@ -976,10 +1051,18 @@ namespace dxvk {
       }
     }
 
-    bool CanSWVP() {
+    bool CanSWVP() const {
       return m_behaviorFlags & (D3DCREATE_MIXED_VERTEXPROCESSING | D3DCREATE_SOFTWARE_VERTEXPROCESSING);
     }
 
+    // Device Reset detection for D3D9SwapChainEx::Present
+    bool IsDeviceReset() {
+      return std::exchange(m_deviceHasBeenReset, false);
+    }
+
+    template <bool Synchronize9On12>
+    void ExecuteFlush();
+
     void DetermineConstantLayouts(bool canSWVP);
 
     D3D9BufferSlice AllocUPBuffer(VkDeviceSize size);
@@ -1004,7 +1087,7 @@ namespace dxvk {
     }
 
     inline uint32_t GetUPBufferSize(uint32_t vertexCount, uint32_t stride) {
-      return (vertexCount - 1) * stride + std::max(m_state.vertexDecl->GetSize(), stride);
+      return (vertexCount - 1) * stride + std::max(m_state.vertexDecl->GetSize(0), stride);
     }
 
     inline void FillUPVertexBuffer(void* buffer, const void* userData, uint32_t dataSize, uint32_t bufferSize) {
@@ -1093,13 +1176,13 @@ namespace dxvk {
           return D3DERR_INVALIDCALL;
 
         if constexpr (ConstantType == D3D9ConstantType::Float) {
-          const float* source = set.fConsts[StartRegister].data;
+          const float* source = set->fConsts[StartRegister].data;
           const size_t size   = Count * sizeof(Vector4);
 
           std::memcpy(pConstantData, source, size);
         }
         else if constexpr (ConstantType == D3D9ConstantType::Int) {
-          const int*  source = set.iConsts[StartRegister].data;
+          const int*  source = set->iConsts[StartRegister].data;
           const size_t size  = Count * sizeof(Vector4i);
 
           std::memcpy(pConstantData, source, size);
@@ -1112,7 +1195,7 @@ namespace dxvk {
 
             const uint32_t bit         = (1u << bitIdx);
 
-            bool constValue = set.bConsts[arrayIdx] & bit;
+            bool constValue = set->bConsts[arrayIdx] & bit;
             pConstantData[i] = constValue ? TRUE : FALSE;
           }
         }
@@ -1162,11 +1245,38 @@ namespace dxvk {
 
     uint64_t GetCurrentSequenceNumber();
 
+    /**
+     * @brief Get the swapchain that was used the most recently for presenting
+     * Has to be externally synchronized.
+     * 
+     * @return D3D9SwapChainEx* Swapchain
+     */
+    D3D9SwapChainEx* GetMostRecentlyUsedSwapchain() {
+      return m_mostRecentlyUsedSwapchain;
+    }
+
+    /**
+     * @brief Set the swapchain that was used the most recently for presenting
+     * Has to be externally synchronized.
+     * 
+     * @param swapchain Swapchain
+     */
+    void SetMostRecentlyUsedSwapchain(D3D9SwapChainEx* swapchain) {
+      m_mostRecentlyUsedSwapchain = swapchain;
+    }
+
+    /**
+     * @brief Reset the most recently swapchain back to the implicit one
+     * Has to be externally synchronized.
+     */
+    void ResetMostRecentlyUsedSwapchain() {
+      m_mostRecentlyUsedSwapchain = m_implicitSwapchain.ptr();
+    }
+
     Com<D3D9InterfaceEx>            m_parent;
     D3DDEVTYPE                      m_deviceType;
     HWND                            m_window;
     WORD                            m_behaviorFlags;
-    D3DPRESENT_PARAMETERS           m_presentParams;
 
     D3D9Adapter*                    m_adapter;
     Rc<DxvkDevice>                  m_dxvkDevice;
@@ -1245,14 +1355,16 @@ namespace dxvk {
     uint32_t                        m_dirtySamplerStates = 0;
     uint32_t                        m_dirtyTextures      = 0;
 
-    uint32_t                        m_boundRTs = 0;
+    uint32_t                        m_boundRTs        : 4;
+    uint32_t                        m_anyColorWrites  : 4;
+    uint32_t                        m_activeRTsWhichAreTextures : 4;
+    uint32_t                        m_alphaSwizzleRTs : 4;
+    uint32_t                        m_lastHazardsRT   : 4;
 
-    uint32_t                        m_activeRTs              = 0;
-    uint32_t                        m_activeRTTextures       = 0;
-    uint32_t                        m_activeDSTextures       = 0;
+    uint32_t                        m_activeTextureRTs       = 0;
+    uint32_t                        m_activeTextureDSs       = 0;
     uint32_t                        m_activeHazardsRT        = 0;
     uint32_t                        m_activeHazardsDS        = 0;
-    uint32_t                        m_alphaSwizzleRTs        = 0;
     uint32_t                        m_activeTextures         = 0;
     uint32_t                        m_activeTexturesToUpload = 0;
     uint32_t                        m_activeTexturesToGen    = 0;
@@ -1267,7 +1379,6 @@ namespace dxvk {
     uint32_t                        m_fetch4        = 0;
 
     uint32_t                        m_lastHazardsDS = 0;
-    uint32_t                        m_lastHazardsRT = 0;
     uint32_t                        m_lastSamplerTypesFF = 0;
 
     D3D9SpecializationInfo          m_specInfo = D3D9SpecializationInfo();
@@ -1276,14 +1387,17 @@ namespace dxvk {
     D3D9ShaderMasks                 m_psShaderMasks = FixedFunctionMask;
 
     bool                            m_isSWVP;
-    bool                            m_amdATOC         = false;
-    bool                            m_nvATOC          = false;
-    bool                            m_ffZTest         = false;
+    bool                            m_isD3D8Compatible = false;
+    bool                            m_amdATOC          = false;
+    bool                            m_nvATOC           = false;
+    bool                            m_ffZTest          = false;
     
     VkImageLayout                   m_hazardLayout = VK_IMAGE_LAYOUT_GENERAL;
 
     bool                            m_usingGraphicsPipelines = false;
+    bool                            m_deviceHasBeenReset = false;
 
+    DxvkDepthBiasRepresentation     m_depthBiasRepresentation = { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, false };
     float                           m_depthBiasScale  = 0.0f;
 
     uint32_t                        m_robustSSBOAlignment     = 1;
@@ -1305,23 +1419,37 @@ namespace dxvk {
     D3D9ViewportInfo                m_viewportInfo;
 
     DxvkCsChunkPool                 m_csChunkPool;
-    dxvk::high_resolution_clock::time_point m_lastFlush
-      = dxvk::high_resolution_clock::now();
     DxvkCsThread                    m_csThread;
     DxvkCsChunkRef                  m_csChunk;
     uint64_t                        m_csSeqNum = 0ull;
-    bool                            m_csIsBusy = false;
+
+    Rc<sync::Fence>                 m_submissionFence;
+    uint64_t                        m_submissionId = 0ull;
+    DxvkSubmitStatus                m_submitStatus;
+
+    uint64_t                        m_flushSeqNum = 0ull;
+    GpuFlushTracker                 m_flushTracker;
 
     std::atomic<int64_t>            m_availableMemory = { 0 };
     std::atomic<int32_t>            m_samplerCount    = { 0 };
 
-    Direct3DState9                  m_state;
+    D3D9DeviceLostState             m_deviceLostState          = D3D9DeviceLostState::Ok;
+    HWND                            m_fullscreenWindow         = NULL;
+    std::atomic<uint32_t>           m_losableResourceCounter   = { 0 };
+
+    D3D9SwapChainEx*                m_mostRecentlyUsedSwapchain = nullptr;
 
 #ifdef D3D9_ALLOW_UNMAPPING
     lru_list<D3D9CommonTexture*>    m_mappedTextures;
 #endif
 
+    // m_state should be declared last (i.e. freed first), because it
+    // references objects that can call back into the device when freed.
+    Direct3DState9                  m_state;
+
     D3D9VkInteropDevice             m_d3d9Interop;
+    D3D9On12                        m_d3d9On12;
+    DxvkD3D8Bridge                  m_d3d8Bridge;
   };
 
 }

src/d3d9/d3d9_fixed_function.cpp

@@ -14,6 +14,7 @@ namespace dxvk {
 
   D3D9FixedFunctionOptions::D3D9FixedFunctionOptions(const D3D9Options* options) {
     invariantPosition = options->invariantPosition;
+    forceSampleRateShading = options->forceSampleRateShading;
   }
 
   uint32_t DoFixedFunctionFog(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, const D3D9FogContext& fogCtx) {
@@ -335,7 +336,7 @@ namespace dxvk {
   }
 
 
-  uint32_t SetupRenderStateBlock(SpirvModule& spvModule, uint32_t count) {
+  uint32_t SetupRenderStateBlock(SpirvModule& spvModule) {
     uint32_t floatType = spvModule.defFloatType(32);
     uint32_t uintType  = spvModule.defIntType(32, 0);
     uint32_t vec3Type  = spvModule.defVectorType(floatType, 3);
@@ -356,7 +357,7 @@ namespace dxvk {
       floatType,
     }};
 
-    uint32_t rsStruct = spvModule.defStructTypeUnique(count, rsMembers.data());
+    uint32_t rsStruct = spvModule.defStructTypeUnique(rsMembers.size(), rsMembers.data());
     uint32_t rsBlock = spvModule.newVar(
       spvModule.defPointerType(rsStruct, spv::StorageClassPushConstant),
       spv::StorageClassPushConstant);
@@ -368,9 +369,6 @@ namespace dxvk {
 
     uint32_t memberIdx = 0;
     auto SetMemberName = [&](const char* name, uint32_t offset) {
-      if (memberIdx >= count)
-        return;
-
       spvModule.setDebugMemberName   (rsStruct, memberIdx, name);
       spvModule.memberDecorateOffset (rsStruct, memberIdx, offset);
       memberIdx++;
@@ -422,6 +420,7 @@ namespace dxvk {
     binding.resourceBinding = getSpecConstantBufferSlot();
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_UNIFORM_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     bindings.push_back(binding);
 
     return specBlock;
@@ -779,8 +778,6 @@ namespace dxvk {
     uint32_t              m_inputMask = 0u;
     uint32_t              m_outputMask = 0u;
     uint32_t              m_flatShadingMask = 0u;
-    uint32_t              m_pushConstOffset = 0u;
-    uint32_t              m_pushConstSize = 0u;
 
     DxsoProgramType       m_programType;
     D3D9FFShaderKeyVS     m_vsKey;
@@ -890,8 +887,8 @@ namespace dxvk {
     info.inputMask = m_inputMask;
     info.outputMask = m_outputMask;
     info.flatShadingInputs = m_flatShadingMask;
-    info.pushConstOffset = m_pushConstOffset;
-    info.pushConstSize = m_pushConstSize;
+    info.pushConstStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
+    info.pushConstSize = sizeof(D3D9RenderStateInfo);
 
     return new DxvkShader(info, m_module.compile());
   }
@@ -933,10 +930,16 @@ namespace dxvk {
 
     uint32_t ptr = m_module.newVar(ptrType, storageClass);
 
-    if (builtin == spv::BuiltInMax)
+    if (builtin == spv::BuiltInMax) {
       m_module.decorateLocation(ptr, slot);
-    else
+
+      if (isPS() && input && m_options.forceSampleRateShading) {
+        m_module.enableCapability(spv::CapabilitySampleRateShading);
+        m_module.decorate(ptr, spv::DecorationSample);
+      }
+    } else {
       m_module.decorateBuiltIn(ptr, builtin);
+    }
 
     bool diffuseOrSpec = semantic == DxsoSemantic{ DxsoUsage::Color, 0 }
                       || semantic == DxsoSemantic{ DxsoUsage::Color, 1 };
@@ -1094,19 +1097,30 @@ namespace dxvk {
     m_module.opStore(m_vs.out.NORMAL, outNrm);
 
     for (uint32_t i = 0; i < caps::TextureStageCount; i++) {
-      uint32_t inputIndex = (m_vsKey.Data.Contents.TexcoordIndices >> (i * 3)) & 0b111;
-      uint32_t inputFlags = (m_vsKey.Data.Contents.TexcoordFlags   >> (i * 3)) & 0b111;
+      uint32_t inputIndex = (m_vsKey.Data.Contents.TexcoordIndices     >> (i * 3)) & 0b111;
+      uint32_t inputFlags = (m_vsKey.Data.Contents.TexcoordFlags       >> (i * 3)) & 0b111;
+      uint32_t texcoordCount = (m_vsKey.Data.Contents.TexcoordDeclMask >> (inputIndex * 3)) & 0b111;
 
       uint32_t transformed;
 
       const uint32_t wIndex = 3;
 
       uint32_t flags = (m_vsKey.Data.Contents.TransformFlags >> (i * 3)) & 0b111;
-      uint32_t count = flags;
+      uint32_t count;
       switch (inputFlags) {
         default:
         case (DXVK_TSS_TCI_PASSTHRU >> TCIOffset):
           transformed = m_vs.in.TEXCOORD[inputIndex & 0xFF];
+          // flags is actually the number of elements that get passed
+          // to the rasterizer.
+          count = flags;
+          if (texcoordCount) {
+            // Clamp by the number of elements in the texcoord input.
+            if (!count || count > texcoordCount)
+              count = texcoordCount;
+          }
+          else
+            flags = D3DTTFF_DISABLE;
           break;
 
         case (DXVK_TSS_TCI_CAMERASPACENORMAL >> TCIOffset):
@@ -1365,20 +1379,7 @@ namespace dxvk {
 
 
   void D3D9FFShaderCompiler::setupRenderStateInfo() {
-    uint32_t count;
-
-    if (m_programType == DxsoProgramType::PixelShader) {
-      m_pushConstOffset = 0;
-      m_pushConstSize   = offsetof(D3D9RenderStateInfo, pointSize);
-      count = 5;
-    }
-    else {
-      m_pushConstOffset = offsetof(D3D9RenderStateInfo, pointSize);
-      m_pushConstSize   = sizeof(float) * 6;
-      count = 11;
-    }
-
-    m_rsBlock = SetupRenderStateBlock(m_module, count);
+    m_rsBlock = SetupRenderStateBlock(m_module);
   }
 
 
@@ -1570,6 +1571,7 @@ namespace dxvk {
     binding.resourceBinding = bindingId;
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_UNIFORM_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     m_bindings.push_back(binding);
   }
 
@@ -1609,6 +1611,7 @@ namespace dxvk {
     binding.resourceBinding = bindingId;
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_SHADER_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     m_bindings.push_back(binding);
   }
 
@@ -1788,10 +1791,10 @@ namespace dxvk {
             texcoord, texcoord, texcoordCnt, indices.data());
 
           uint32_t projIdx = m_fsKey.Stages[i].Contents.ProjectedCount;
-          if (projIdx == 0)
-            projIdx = texcoordCnt;
-          else
-            projIdx--;
+          if (projIdx == 0 || projIdx > texcoordCnt) {
+            projIdx = 4; // Always use w if ProjectedCount is 0.
+          }
+          --projIdx;
 
           uint32_t projValue = 0;
 
@@ -2220,6 +2223,7 @@ namespace dxvk {
     binding.resourceBinding = bindingId;
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_UNIFORM_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     m_bindings.push_back(binding);
 
     // Load constants
@@ -2307,6 +2311,7 @@ namespace dxvk {
     binding.resourceBinding = bindingId;
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_UNIFORM_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     m_bindings.push_back(binding);
   }
 
@@ -2346,6 +2351,7 @@ namespace dxvk {
     binding.resourceBinding = bindingId;
     binding.viewType        = VK_IMAGE_VIEW_TYPE_MAX_ENUM;
     binding.access          = VK_ACCESS_UNIFORM_READ_BIT;
+    binding.uboSet          = VK_TRUE;
     m_bindings.push_back(binding);
 
     // Declare output array for clip distances

src/d3d9/d3d9_fixed_function.h

@@ -49,6 +49,7 @@ namespace dxvk {
     D3D9FixedFunctionOptions(const D3D9Options* options);
 
     bool invariantPosition;
+    bool forceSampleRateShading;
   };
 
   // Returns new oFog if VS
@@ -58,7 +59,7 @@ namespace dxvk {
   void DoFixedFunctionAlphaTest(SpirvModule& spvModule, const D3D9AlphaTestContext& ctx);
 
   // Returns a render state block
-  uint32_t SetupRenderStateBlock(SpirvModule& spvModule, uint32_t count);
+  uint32_t SetupRenderStateBlock(SpirvModule& spvModule);
 
   struct D3D9PointSizeInfoVS {
     uint32_t defaultValue;

src/d3d9/d3d9_format.cpp

@@ -132,7 +132,7 @@ namespace dxvk {
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,
           VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A },
-        { D3D9ConversionFormat_L6V5U5, 1u,
+        { D3D9ConversionFormat_L6V5U5,
         // Convert -> float (this is a mixed snorm and unorm type)
           VK_FORMAT_R16G16B16A16_SFLOAT } };
 
@@ -142,7 +142,7 @@ namespace dxvk {
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,
           VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_ONE },
-        { D3D9ConversionFormat_X8L8V8U8, 1u,
+        { D3D9ConversionFormat_X8L8V8U8,
         // Convert -> float (this is a mixed snorm and unorm type)
           VK_FORMAT_R16G16B16A16_SFLOAT } };
 
@@ -164,7 +164,7 @@ namespace dxvk {
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,
           VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A },
-        { D3D9ConversionFormat_A2W10V10U10, 1u,
+        { D3D9ConversionFormat_A2W10V10U10,
         // Convert -> float (this is a mixed snorm and unorm type)
           VK_FORMAT_R16G16B16A16_SFLOAT } };
 
@@ -174,17 +174,17 @@ namespace dxvk {
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G,
           VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_ONE },
-        { D3D9ConversionFormat_W11V11U10, 1u,
+        { D3D9ConversionFormat_W11V11U10,
         // can't use B10G11R11 bc this is a snorm type
           VK_FORMAT_R16G16B16A16_SNORM } };
 
       case D3D9Format::UYVY: return {
-        VK_FORMAT_B8G8R8A8_UNORM,
+        VK_FORMAT_G8B8G8R8_422_UNORM,
         VK_FORMAT_UNDEFINED,
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
           VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY },
-        { D3D9ConversionFormat_UYVY, 1u }
+        { D3D9ConversionFormat_UYVY, VK_FORMAT_B8G8R8A8_UNORM }
       };
 
       case D3D9Format::R8G8_B8G8: return {
@@ -193,12 +193,12 @@ namespace dxvk {
         VK_IMAGE_ASPECT_COLOR_BIT };
 
       case D3D9Format::YUY2: return {
-        VK_FORMAT_B8G8R8A8_UNORM,
+        VK_FORMAT_G8B8G8R8_422_UNORM,
         VK_FORMAT_UNDEFINED,
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
           VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY },
-        { D3D9ConversionFormat_YUY2, 1u }
+        { D3D9ConversionFormat_YUY2, VK_FORMAT_B8G8R8A8_UNORM }
       };
 
       case D3D9Format::G8R8_G8B8: return {
@@ -410,21 +410,21 @@ namespace dxvk {
           VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R }};
 
       case D3D9Format::NV12: return {
-        VK_FORMAT_R8_UNORM,
+        VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
         VK_FORMAT_UNDEFINED,
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
           VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY },
-        { D3D9ConversionFormat_NV12, 2u, VK_FORMAT_B8G8R8A8_UNORM }
+        { D3D9ConversionFormat_NV12, VK_FORMAT_B8G8R8A8_UNORM }
       };
 
       case D3D9Format::YV12: return {
-        VK_FORMAT_R8_UNORM,
+        VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
         VK_FORMAT_UNDEFINED,
         VK_IMAGE_ASPECT_COLOR_BIT,
         { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
           VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY },
-        { D3D9ConversionFormat_YV12, 3u, VK_FORMAT_B8G8R8A8_UNORM }
+        { D3D9ConversionFormat_YV12, VK_FORMAT_B8G8R8A8_UNORM }
       };
 
       case D3D9Format::RAWZ: return {}; // Unsupported
@@ -438,7 +438,11 @@ namespace dxvk {
   D3D9VkFormatTable::D3D9VkFormatTable(
     const Rc<DxvkAdapter>& adapter,
     const D3D9Options&     options) {
-    m_dfSupport = options.supportDFFormats;
+
+    const auto& props = adapter->deviceProperties();
+    uint32_t vendorId  = options.customVendorId == -1 ? props.vendorID : uint32_t(options.customVendorId);
+
+    m_dfSupport = options.supportDFFormats && DxvkGpuVendor(vendorId) != DxvkGpuVendor::Nvidia;
     m_x4r4g4b4Support = options.supportX4R4G4B4;
     m_d32supportFinal = options.supportD32;
 

src/d3d9/d3d9_format.h

@@ -143,7 +143,6 @@ namespace dxvk {
 
   struct D3D9_CONVERSION_FORMAT_INFO {
     D3D9ConversionFormat FormatType     = D3D9ConversionFormat_None;
-    uint32_t             PlaneCount     = 1;
     VkFormat             FormatColor    = VK_FORMAT_UNDEFINED;
     VkFormat             FormatSrgb     = VK_FORMAT_UNDEFINED;
   };

src/d3d9/d3d9_format_helpers.cpp

@@ -134,7 +134,7 @@ namespace dxvk {
     info.stage = VK_SHADER_STAGE_COMPUTE_BIT;
     info.bindingCount = bindings.size();
     info.bindings = bindings.data();
-    info.pushConstOffset = 0;
+    info.pushConstStages = VK_SHADER_STAGE_COMPUTE_BIT;
     info.pushConstSize = sizeof(VkExtent2D);
 
     return new DxvkShader(info, std::move(code));
@@ -142,7 +142,7 @@ namespace dxvk {
 
 
   void D3D9FormatHelper::FlushInternal() {
-    m_context->flushCommandList();
+    m_context->flushCommandList(nullptr);
     
     m_transferCommands = 0;
   }

src/d3d9/d3d9_include.h

@@ -12,9 +12,9 @@
 
 //for some reason we need to specify __declspec(dllexport) for MinGW
 #if defined(__WINE__) || !defined(_WIN32)
-#define DLLEXPORT __attribute__((visibility("default")))
+  #define DLLEXPORT __attribute__((visibility("default")))
 #else
-#define DLLEXPORT
+  #define DLLEXPORT
 #endif
 
 
@@ -40,55 +40,68 @@
 
 // Missed definitions in Wine/MinGW.
 
-#ifndef D3DPRESENT_BACK_BUFFERS_MAX_EX
-#define D3DPRESENT_BACK_BUFFERS_MAX_EX 30
-#endif
-
-#ifndef D3DSI_OPCODE_MASK
-#define D3DSI_OPCODE_MASK 0x0000FFFF
-#endif
-
-#ifndef D3DSP_TEXTURETYPE_MASK
-#define D3DSP_TEXTURETYPE_MASK 0x78000000
-#endif
-
-#ifndef D3DUSAGE_AUTOGENMIPMAP
-#define D3DUSAGE_AUTOGENMIPMAP 0x00000400L
-#endif
-
-#ifndef D3DSP_DCL_USAGE_MASK
-#define D3DSP_DCL_USAGE_MASK 0x0000000f
-#endif
-
-#ifndef D3DSP_OPCODESPECIFICCONTROL_MASK
-#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000
-#endif
-
-#ifndef D3DSP_OPCODESPECIFICCONTROL_SHIFT
-#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16
-#endif
-
-#ifndef D3DCURSOR_IMMEDIATE_UPDATE
-#define D3DCURSOR_IMMEDIATE_UPDATE             0x00000001L
-#endif
-
 #ifndef D3DPRESENT_FORCEIMMEDIATE
 #define D3DPRESENT_FORCEIMMEDIATE              0x00000100L
 #endif
 
+#ifndef D3DSWAPEFFECT_COPY_VSYNC
+#define D3DSWAPEFFECT_COPY_VSYNC 4
+#endif
+
 // MinGW headers are broken. Who'dve guessed?
 #ifndef _MSC_VER
 typedef struct _D3DDEVINFO_RESOURCEMANAGER
 {
   char dummy;
 } D3DDEVINFO_RESOURCEMANAGER, * LPD3DDEVINFO_RESOURCEMANAGER;
-
-#ifndef __WINE__
-extern "C" WINUSERAPI WINBOOL WINAPI SetProcessDPIAware(VOID);
-#endif
 #endif
 
 // This is the managed pool on D3D9Ex, it's just hidden!
 #define D3DPOOL_MANAGED_EX D3DPOOL(6)
 
 using D3D9VertexElements = std::vector<D3DVERTEXELEMENT9>;
+
+/////////////////////
+// D3D9On12 content
+/////////////////////
+
+#include <d3d12.h>
+
+#define MAX_D3D9ON12_QUEUES 2
+
+struct D3D9ON12_ARGS {
+  BOOL Enable9On12;
+  IUnknown* pD3D12Device;
+  IUnknown* ppD3D12Queues[MAX_D3D9ON12_QUEUES];
+  UINT NumQueues;
+  UINT NodeMask;
+};
+
+extern "C" {
+
+  // Ordinal 20
+  typedef IDirect3D9* (WINAPI* PFN_Direct3DCreate9On12)(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count);
+  IDirect3D9* WINAPI Direct3DCreate9On12(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count);
+
+  // Ordinal 21
+  typedef HRESULT(WINAPI* PFN_Direct3DCreate9On12Ex)(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count, IDirect3D9Ex** output);
+  HRESULT WINAPI Direct3DCreate9On12Ex(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count, IDirect3D9Ex** output);
+
+}
+
+MIDL_INTERFACE("e7fda234-b589-4049-940d-8878977531c8")
+IDirect3DDevice9On12 : public IUnknown {
+
+  virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** object) = 0;
+  virtual ULONG STDMETHODCALLTYPE AddRef() = 0;
+  virtual ULONG STDMETHODCALLTYPE Release() = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetD3D12Device(REFIID riid, void** object) = 0;
+  virtual HRESULT STDMETHODCALLTYPE UnwrapUnderlyingResource(IDirect3DResource9* resource, ID3D12CommandQueue* command_queue, REFIID riid, void** object) = 0;
+  virtual HRESULT STDMETHODCALLTYPE ReturnUnderlyingResource(IDirect3DResource9* resource, UINT num_sync, UINT64* signal_values, ID3D12Fence** fences) = 0;
+};
+
+#ifndef _MSC_VER
+__CRT_UUID_DECL(IDirect3DDevice9On12,      0xe7fda234,0xb589,0x4049,0x94,0x0d,0x88,0x78,0x97,0x75,0x31,0xc8);
+#endif
+

src/d3d9/d3d9_initializer.cpp

@@ -153,7 +153,7 @@ namespace dxvk {
 
 
   void D3D9Initializer::FlushInternal() {
-    m_context->flushCommandList();
+    m_context->flushCommandList(nullptr);
     
     m_transferCommands = 0;
     m_transferMemory   = 0;

src/d3d9/d3d9_interface.cpp

@@ -3,13 +3,19 @@
 #include "d3d9_monitor.h"
 #include "d3d9_caps.h"
 #include "d3d9_device.h"
+#include "d3d9_bridge.h"
+
+#include "../util/util_singleton.h"
 
 #include <algorithm>
 
 namespace dxvk {
 
+  Singleton<DxvkInstance> g_dxvkInstance;
+
   D3D9InterfaceEx::D3D9InterfaceEx(bool bExtended)
-    : m_instance    ( new DxvkInstance() )
+    : m_instance    ( g_dxvkInstance.acquire(DxvkInstanceFlag::ClientApiIsD3D9) )
+    , m_d3d8Bridge  ( this )
     , m_extended    ( bExtended ) 
     , m_d3d9Options ( nullptr, m_instance->config() )
     , m_d3d9Interop ( this ) {
@@ -64,6 +70,11 @@ namespace dxvk {
   }
 
 
+  D3D9InterfaceEx::~D3D9InterfaceEx() {
+    g_dxvkInstance.release();
+  }
+
+
   HRESULT STDMETHODCALLTYPE D3D9InterfaceEx::QueryInterface(REFIID riid, void** ppvObject) {
     if (ppvObject == nullptr)
       return E_POINTER;
@@ -77,13 +88,21 @@ namespace dxvk {
       return S_OK;
     }
 
+    if (riid == __uuidof(IDxvkD3D8InterfaceBridge)) {
+      *ppvObject = ref(&m_d3d8Bridge);
+      return S_OK;
+    }
+
     if (riid == __uuidof(ID3D9VkInteropInterface)) {
       *ppvObject = ref(&m_d3d9Interop);
       return S_OK;
     }
 
-    Logger::warn("D3D9InterfaceEx::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
+    if (logQueryInterfaceError(__uuidof(IDirect3D9), riid)) {
+      Logger::warn("D3D9InterfaceEx::QueryInterface: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
     return E_NOINTERFACE;
   }
 

src/d3d9/d3d9_interface.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "d3d9_adapter.h"
+#include "d3d9_bridge.h"
 #include "d3d9_interop.h"
 
 #include "../dxvk/dxvk_instance.h"
@@ -20,6 +21,8 @@ namespace dxvk {
 
     D3D9InterfaceEx(bool bExtended);
 
+    ~D3D9InterfaceEx();
+
     HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
 
     HRESULT STDMETHODCALLTYPE RegisterSoftwareDevice(void* pInitializeFunction);
@@ -138,6 +141,8 @@ namespace dxvk {
 
     Rc<DxvkInstance>              m_instance;
 
+    DxvkD3D8InterfaceBridge       m_d3d8Bridge;
+
     bool                          m_extended;
 
     D3D9Options                   m_d3d9Options;

src/d3d9/d3d9_interfaces.h

@@ -196,12 +196,42 @@ ID3D9VkInteropDevice : public IUnknown {
           DWORD                MapFlags) = 0;
 };
 
-#ifdef _MSC_VER
-struct __declspec(uuid("3461a81b-ce41-485b-b6b5-fcf08ba6a6bd")) ID3D9VkInteropInterface;
-struct __declspec(uuid("d56344f5-8d35-46fd-806d-94c351b472c1")) ID3D9VkInteropTexture;
-struct __declspec(uuid("2eaa4b89-0107-4bdb-87f7-0f541c493ce0")) ID3D9VkInteropDevice;
-#else
+/**
+ * \brief D3D9 current output metadata
+ */
+struct D3D9VkExtOutputMetadata {
+  float RedPrimary[2];
+  float GreenPrimary[2];
+  float BluePrimary[2];
+  float WhitePoint[2];
+  float MinLuminance;
+  float MaxLuminance;
+  float MaxFullFrameLuminance;
+};
+
+/**
+ * \brief D3D9 extended swapchain
+ */
+MIDL_INTERFACE("13776e93-4aa9-430a-a4ec-fe9e281181d5")
+ID3D9VkExtSwapchain : public IUnknown {
+  virtual BOOL STDMETHODCALLTYPE CheckColorSpaceSupport(
+          VkColorSpaceKHR           ColorSpace) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE SetColorSpace(
+          VkColorSpaceKHR           ColorSpace) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE SetHDRMetaData(
+    const VkHdrMetadataEXT          *pHDRMetadata) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetCurrentOutputDesc(
+          D3D9VkExtOutputMetadata   *pOutputDesc) = 0;
+
+  virtual void STDMETHODCALLTYPE UnlockAdditionalFormats() = 0;
+};
+
+#ifndef _MSC_VER
 __CRT_UUID_DECL(ID3D9VkInteropInterface,   0x3461a81b,0xce41,0x485b,0xb6,0xb5,0xfc,0xf0,0x8b,0xa6,0xa6,0xbd);
 __CRT_UUID_DECL(ID3D9VkInteropTexture,     0xd56344f5,0x8d35,0x46fd,0x80,0x6d,0x94,0xc3,0x51,0xb4,0x72,0xc1);
 __CRT_UUID_DECL(ID3D9VkInteropDevice,      0x2eaa4b89,0x0107,0x4bdb,0x87,0xf7,0x0f,0x54,0x1c,0x49,0x3c,0xe0);
+__CRT_UUID_DECL(ID3D9VkExtSwapchain,       0x13776e93,0x4aa9,0x430a,0xa4,0xec,0xfe,0x9e,0x28,0x11,0x81,0xd5);
 #endif