[dxvk] Fix clear after late resolve

Needed for defrag.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,14 +7,9 @@ assignees: ''
 
 ---
 
-Please describe your issue as accurately as possible. If you run into a problem with a binary release, make sure to test with latest `master` as well.
+Please describe your issue as accurately as possible.
 
-**Important:** When reporting an issue with a specific game or application, such as crashes or rendering issues, please include log files and, if possible, a D3D11/D3D9 Apitrace (see https://github.com/apitrace/apitrace) so that the issue can be reproduced.
-In order to create a trace for **D3D11/D3D10**: Run `wine apitrace.exe trace -a dxgi YOURGAME.exe`.
-In order to create a trace for **D3D9**: Follow https://github.com/Joshua-Ashton/d9vk/wiki/Making-a-Trace.
-Preferably record the trace on Windows, or wined3d if possible.
-
-**Reports with no log files will be ignored.**
+If you use Windows, please check the following page: https://github.com/doitsujin/dxvk/wiki/Windows
 
 ### Software information
 Name of the game, settings used etc.
@@ -28,7 +23,9 @@ Name of the game, settings used etc.
 ### Apitrace file(s)
 - Put a link here
 
+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/artifacts.yml

@@ -0,0 +1,83 @@
+name: Artifacts (Package)
+
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  artifacts-mingw-w64:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      id: checkout-code
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Setup problem matcher
+      uses: Joshua-Ashton/gcc-problem-matcher@v3
+
+    - name: Build release
+      id: build-release
+      uses: Joshua-Ashton/arch-mingw-github-action@v8
+      with:
+        command: |
+          export VERSION_NAME="${GITHUB_REF##*/}-${GITHUB_SHA##*/}"
+          ./package-release.sh ${VERSION_NAME} build --no-package
+          echo "VERSION_NAME=${VERSION_NAME}" >> $GITHUB_ENV
+
+    - name: Upload artifacts
+      id: upload-artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: dxvk-win-${{ env.VERSION_NAME }}
+        path: build/dxvk-${{ env.VERSION_NAME }}
+        if-no-files-found: error
+
+  artifacts-steamrt-sniper:
+    runs-on: ubuntu-latest
+    container: registry.gitlab.steamos.cloud/steamrt/sniper/sdk:beta
+
+    steps:
+    - name: Checkout code
+      id: checkout-code
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Setup problem matcher
+      uses: Joshua-Ashton/gcc-problem-matcher@v3
+
+    - name: Build release
+      id: build-release
+      shell: bash
+      run: |
+        export VERSION_NAME="${GITHUB_REF##*/}-${GITHUB_SHA##*/}"
+        ./package-native.sh ${VERSION_NAME} build
+        echo "VERSION_NAME=${VERSION_NAME}" >> $GITHUB_ENV
+
+    - name: Upload artifacts
+      id: upload-artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: dxvk-native-${{ env.VERSION_NAME }}
+        path: build/dxvk-native-${{ env.VERSION_NAME }}.tar.gz
+        if-no-files-found: error
+
+  merge-artifacts:
+    runs-on: ubuntu-latest
+    needs: [artifacts-mingw-w64, artifacts-steamrt-sniper]
+    steps:
+      - name: Get version
+        id: get-version
+        shell: bash
+        run: |
+          echo "VERSION_NAME=${GITHUB_REF##*/}-${GITHUB_SHA##*/}" >> $GITHUB_ENV
+
+      - name: Merge Artifacts
+        uses: actions/upload-artifact/merge@v4
+        with:
+          name: dxvk-${{ env.VERSION_NAME }}
+          pattern: dxvk*
+          delete-merged: true

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

@@ -0,0 +1,81 @@
+name: Test Builds on Windows
+
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  build-set-windows:
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout code
+      id: checkout-code
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Setup glslangValidator
+      shell: pwsh
+      run: |
+        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
+      run: pip install meson
+
+    - name: Find Visual Studio
+      shell: pwsh
+      run: |
+        $installationPath = Get-VSSetupInstance `
+          | Select-VSSetupInstance -Require Microsoft.VisualStudio.Workload.NativeDesktop -Latest `
+          | Select-Object -ExpandProperty InstallationPath
+        Write-Output "VSDEVCMD=${installationPath}\Common7\Tools\VsDevCmd.bat" `
+          | Out-File -FilePath "${Env:GITHUB_ENV}" -Append
+
+    - name: Download D3D8 SDK Headers
+      shell: pwsh
+      run: |
+        Invoke-WebRequest -URI https://raw.githubusercontent.com/NovaRain/DXSDK_Collection/master/DXSDK_Aug2007/Include/d3d8.h -OutFile include/d3d8.h
+        Invoke-WebRequest -URI https://raw.githubusercontent.com/NovaRain/DXSDK_Collection/master/DXSDK_Aug2007/Include/d3d8types.h -OutFile include/d3d8types.h
+        Invoke-WebRequest -URI https://raw.githubusercontent.com/NovaRain/DXSDK_Collection/master/DXSDK_Aug2007/Include/d3d8caps.h -OutFile include/d3d8caps.h
+        
+    - name: Get version
+      id: get-version
+      shell: bash
+      run: |
+        echo "VERSION_NAME=${GITHUB_REF##*/}-${GITHUB_SHA##*/}" >> $GITHUB_ENV
+
+    - name: Build MSVC x86
+      shell: pwsh
+      run: |
+        & "${Env:COMSPEC}" /s /c "`"${Env:VSDEVCMD}`" -arch=x86 -host_arch=x64 -no_logo && set" `
+          | % { , ($_ -Split '=', 2) } `
+          | % { [System.Environment]::SetEnvironmentVariable($_[0], $_[1]) }
+        meson --buildtype release --backend vs2022 build-msvc-x86
+        msbuild -m build-msvc-x86/dxvk.sln
+
+    - name: Build MSVC x64
+      shell: pwsh
+      run: |
+        & "${Env:COMSPEC}" /s /c "`"${Env:VSDEVCMD}`" -arch=x64 -host_arch=x64 -no_logo && set" `
+          | % { , ($_ -Split '=', 2) } `
+          | % { [System.Environment]::SetEnvironmentVariable($_[0], $_[1]) }
+        meson --buildtype release --backend vs2022 build-msvc-x64
+        msbuild -m build-msvc-x64/dxvk.sln
+
+    - name: Prepare artifacts
+      shell: pwsh
+      run: |
+        mkdir artifacts\x32
+        ls -Path build-msvc-x86\src -Include *.dll,*.pdb -Recurse
+          | cp -Destination (Join-Path -Path (pwd) -ChildPath artifacts\x32)
+        mkdir artifacts\x64
+        ls -Path build-msvc-x64\src -Include *.dll,*.pdb -Recurse
+          | cp -Destination (Join-Path -Path (pwd) -ChildPath artifacts\x64)
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: dxvk-${{ env.VERSION_NAME }}-msvc-output
+        path: artifacts\*

.gitlab-ci.yml

@@ -1,8 +0,0 @@
-dxvk:
-  script:
-    - chmod +x package-release.sh
-    - ./package-release.sh release build --no-package
-  artifacts:
-    name: "dxvk-${CI_COMMIT_REF_NAME}.${CI_COMMIT_SHA}"
-    paths:
-    - build/dxvk-release

.gitmodules

@@ -0,0 +1,13 @@
+[submodule "include/native/directx"]
+	path = include/native/directx
+	url = https://github.com/Joshua-Ashton/mingw-directx-headers
+[submodule "include/vulkan"]
+	path = include/vulkan
+	url = https://github.com/KhronosGroup/Vulkan-Headers
+[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,7 @@
-                  Copyright (c) 2017-2020 Philip Rebohle
-                  Copyright (c) 2019-2020 Joshua Ashton
+                  Copyright (c) 2017 Philip Rebohle
+                  Copyright (c) 2019 Joshua Ashton
+                  Copyright (c) 2019 Robin Kertels
+                  Copyright (c) 2023 Jeffrey Ellison
 
                           zlib/libpng license
 

README.md

@@ -1,39 +1,129 @@
 # DXVK
 
-A Vulkan-based translation layer for Direct3D 9/10/11 which allows running 3D applications on Linux using Wine.
+A Vulkan-based translation layer for Direct3D 8/9/10/11 which allows running 3D applications on Linux using Wine.
 
 For the current status of the project, please refer to the [project wiki](https://github.com/doitsujin/dxvk/wiki).
 
+The most recent development builds can be found [here](https://github.com/doitsujin/dxvk/actions/workflows/artifacts.yml?query=branch%3Amaster).
+
+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 `native` DLL overrides for `d3d8`, `d3d9`, `d3d10core`, `d3d11` and `dxgi` under the Libraries tab.
 
+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.
-- `--with-d3d10`: Install the `d3d10{_1}.dll` helper libraries.
-- `--without-dxgi`: Do not install DXVK's DXGI implementation and use the one provided by wine instead. This is necessary for both vkd3d and DXVK to work within the same wine prefix.
-
-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.
+
+#### DLL dependencies 
+Listed below are the DLL requirements for using DXVK with any single API.
+
+- d3d8: `d3d8.dll` and `d3d9.dll`
+- d3d9: `d3d9.dll`
+- d3d10: `d3d10core.dll`, `d3d11.dll` and `dxgi.dll`
+- d3d11: `d3d11.dll` and `dxgi.dll`
+
+### 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.**
+
+### 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.
+- `fps`: Shows the current frame rate.
+- `frametimes`: Shows a frame time graph.
+- `submissions`: Shows the number of command buffers submitted per frame.
+- `drawcalls`: Shows the number of draw calls and render passes per frame.
+- `pipelines`: Shows the total number of graphics and compute pipelines.
+- `descriptors`: Shows the number of descriptor pools and descriptor sets.
+- `memory`: Shows the amount of device memory allocated and used.
+- `allocations`: Shows detailed memory chunk suballocation info.
+- `gpuload`: Shows estimated GPU load. May be inaccurate.
+- `version`: Shows DXVK version.
+- `api`: Shows the D3D feature level used by the application.
+- `cs`: Shows worker thread statistics.
+- `compiler`: Shows shader compiler activity
+- `samplers`: Shows the current number of sampler pairs used *[D3D9 Only]*
+- `ffshaders`: Shows the current number of shaders generated from fixed function state *[D3D9 Only]*
+- `swvp`: Shows whether or not the device is running in software vertex processing mode *[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.
+
+### 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.
+
+### Frame rate limit
+The `DXVK_FRAME_RATE` environment variable can be used to limit the frame rate. A value of `0` uncaps the frame rate, while any positive value will limit rendering to the given number of frames per second. Alternatively, the configuration file can be used.
+
+### Device filter
+Some applications do not provide a method to select a different GPU. In that case, DXVK can be forced to use a given device:
+- `DXVK_FILTER_DEVICE_NAME="Device Name"` Selects devices with a matching Vulkan device name, which can be retrieved with tools such as `vulkaninfo`. Matches on substrings, so "VEGA" or "AMD RADV VEGA10" is supported if the full device name is "AMD RADV VEGA10 (LLVM 9.0.0)", for example. If the substring matches more than one device, the first device matched will be used.
+
+**Note:** If the device filter is configured incorrectly, it may filter out all devices and applications will be unable to create a D3D device.
+
+### 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_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.
+
+### 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.
+
+The following environment variables can be used to control the cache:
+- `DXVK_STATE_CACHE`: Controls the state cache. The following values are supported:
+  - `disable`: Disables the cache entirely.
+  - `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`
+
 ## Build instructions
 
+In order to pull in all submodules that are needed for building, clone the repository using the following command:
+```
+git clone --recursive https://github.com/doitsujin/dxvk.git
+```
+
 ### Requirements:
-- [wine 3.10](https://www.winehq.org/) or newer
-- [Meson](https://mesonbuild.com/) build system (at least version 0.46)
-- [Mingw-w64](http://mingw-w64.org/) compiler and headers (at least version 8.0)
+- [wine 7.1](https://www.winehq.org/) or newer
+- [Meson](https://mesonbuild.com/) build system (at least version 0.58)
+- [Mingw-w64](https://www.mingw-w64.org) compiler and headers (at least version 10.0)
 - [glslang](https://github.com/KhronosGroup/glslang) compiler
 
 ### Building DLLs
@@ -57,69 +147,47 @@ ninja install
 ```
 # 64-bit build. For 32-bit builds, replace
 # build-win64.txt with build-win32.txt
-meson --cross-file build-win64.txt --buildtype release --prefix /your/dxvk/directory build.w64
+meson setup --cross-file build-win64.txt --buildtype release --prefix /your/dxvk/directory build.w64
 cd build.w64
 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.
+The D3D8, D3D9, D3D10, D3D11 and DXGI DLLs will be located in `/your/dxvk/directory/bin`.
 
-### 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.**
-
-### 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.
-- `fps`: Shows the current frame rate.
-- `frametimes`: Shows a frame time graph.
-- `submissions`: Shows the number of command buffers submitted per frame.
-- `drawcalls`: Shows the number of draw calls and render passes per frame.
-- `pipelines`: Shows the total number of graphics and compute pipelines.
-- `memory`: Shows the amount of device memory allocated and used.
-- `gpuload`: Shows estimated GPU load. May be inaccurate.
-- `version`: Shows DXVK version.
-- `api`: Shows the D3D feature level used by the application.
-- `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`)
-
-Additionally, `DXVK_HUD=1` has the same effect as `DXVK_HUD=devinfo,fps`, and `DXVK_HUD=full` enables all available HUD elements.
-
-### Device filter
-Some applications do not provide a method to select a different GPU. In that case, DXVK can be forced to use a given device:
-- `DXVK_FILTER_DEVICE_NAME="Device Name"` Selects devices with a matching Vulkan device name, which can be retrieved with tools such as `vulkaninfo`. Matches on substrings, so "VEGA" or "AMD RADV VEGA10" is supported if the full device name is "AMD RADV VEGA10 (LLVM 9.0.0)", for example. If the substring matches more than one device, the first device matched will be used.
-
-**Note:** If the device filter is configured incorrectly, it may filter out all devices and applications will be unable to create a D3D device.
-
-### 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.
-
-The following environment variables can be used to control the cache:
-- `DXVK_STATE_CACHE=0` Disables the state cache.
-- `DXVK_STATE_CACHE_PATH=/some/directory` Specifies a directory where to put the cache files. Defaults to the current working directory of the application.
-
-### 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.
-
-## Troubleshooting
+### Build troubleshooting
 DXVK requires threading support from your mingw-w64 build environment. If you
-are missing this, you may see "error: 'mutex' is not a member of 'std'". 
+are missing this, you may see "error: ‘std::cv_status’ has not been declared"
+or similar threading related errors.
 
 On Debian and Ubuntu, this can be resolved by using the posix alternate, which
 supports threading. For example, choose the posix alternate from these
-commands (use i686 for 32-bit):
+commands:
 ```
 update-alternatives --config x86_64-w64-mingw32-gcc
 update-alternatives --config x86_64-w64-mingw32-g++
+update-alternatives --config i686-w64-mingw32-gcc
+update-alternatives --config i686-w64-mingw32-g++
 ```
 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 `SDL3`, `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 @@
-1.7.3
+2.5.3

VP_DXVK_requirements.json

@@ -0,0 +1,415 @@
+{
+    "$schema": "https://schema.khronos.org/vulkan/profiles-0.8.1-224.json#",
+    "capabilities": {
+        "vulkan10requirements": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "robustBufferAccess": true
+                }
+            }
+        },
+        "vulkan11requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan11Features": {
+                    "multiview": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan11Properties": {
+                    "maxMultiviewViewCount": 6,
+                    "maxMultiviewInstanceIndex": 134217727
+                }
+            }
+        },
+        "vulkan12requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan12Features": {
+                    "uniformBufferStandardLayout": true,
+                    "subgroupBroadcastDynamicId": true,
+                    "imagelessFramebuffer": true,
+                    "separateDepthStencilLayouts": true,
+                    "hostQueryReset": true,
+                    "timelineSemaphore": true,
+                    "shaderSubgroupExtendedTypes": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan12Properties": {
+                    "maxTimelineSemaphoreValueDifference": 2147483647
+                }
+            }
+        },
+        "vulkan13requirements": {
+            "features": {
+                "VkPhysicalDeviceVulkan12Features": {
+                    "vulkanMemoryModel": true,
+                    "vulkanMemoryModelDeviceScope": true,
+                    "bufferDeviceAddress": true
+                },
+                "VkPhysicalDeviceVulkan13Features": {
+                    "robustImageAccess": true,
+                    "shaderTerminateInvocation": true,
+                    "shaderZeroInitializeWorkgroupMemory": true,
+                    "synchronization2": true,
+                    "shaderIntegerDotProduct": true,
+                    "maintenance4": true,
+                    "pipelineCreationCacheControl": true,
+                    "subgroupSizeControl": true,
+                    "computeFullSubgroups": true,
+                    "shaderDemoteToHelperInvocation": true,
+                    "inlineUniformBlock": true,
+                    "dynamicRendering": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceVulkan13Properties": {
+                    "maxBufferSize": 1073741824,
+                    "maxInlineUniformBlockSize": 256,
+                    "maxPerStageDescriptorInlineUniformBlocks": 4,
+                    "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks": 4,
+                    "maxDescriptorSetInlineUniformBlocks": 4,
+                    "maxDescriptorSetUpdateAfterBindInlineUniformBlocks": 4,
+                    "maxInlineUniformTotalSize": 4
+                }
+            }
+        },
+        "d3d9_baseline": {
+            "extensions": {
+                "VK_EXT_robustness2": 1
+            },
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "geometryShader": true,
+                    "imageCubeArray": true,
+                    "depthClamp": true,
+                    "depthBiasClamp": true,
+                    "fillModeNonSolid": true,
+                    "sampleRateShading": true,
+                    "shaderClipDistance": true,
+                    "shaderCullDistance": true,
+                    "textureCompressionBC": true,
+                    "occlusionQueryPrecise": true,
+                    "independentBlend": true,
+                    "fullDrawIndexUint32": true,
+
+                    "shaderImageGatherExtended": true
+                },
+                "VkPhysicalDeviceVulkan12Features": {
+                    "samplerMirrorClampToEdge": true
+                },
+                "VkPhysicalDeviceRobustness2FeaturesEXT": {
+                    "nullDescriptor": true,
+                    "robustBufferAccess2": true
+                }
+            }
+        },
+        "d3d9_optional": {
+            "extensions": {
+                "VK_EXT_memory_priority": 1,
+                "VK_EXT_vertex_attribute_divisor": 1,
+                "VK_EXT_depth_clip_enable": 1,
+                "VK_EXT_custom_border_color": 1,
+                "VK_EXT_attachment_feedback_loop_layout": 1,
+                "VK_EXT_non_seamless_cube_map": 1
+            },
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "depthBounds": true,
+                    "vertexPipelineStoresAndAtomics": true,
+                    "pipelineStatisticsQuery": true,
+                    "samplerAnisotropy": true
+                },
+                "VkPhysicalDeviceMemoryPriorityFeaturesEXT": {
+                    "memoryPriority": true
+                },
+                "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT": {
+                    "vertexAttributeInstanceRateDivisor": true,
+                    "vertexAttributeInstanceRateZeroDivisor": true
+                },
+                "VkPhysicalDeviceDepthClipEnableFeaturesEXT": {
+                    "depthClipEnable": true
+                },
+                "VkPhysicalDeviceCustomBorderColorFeaturesEXT": {
+                    "customBorderColors": true,
+                    "customBorderColorWithoutFormat": true
+                },
+                "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT": {
+                    "attachmentFeedbackLoopLayout": true
+                },
+                "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT": {
+                    "nonSeamlessCubeMap": true
+                }
+            }
+        },
+        "d3d11_baseline": {
+            "extensions": {
+                "VK_EXT_robustness2": 1,
+                "VK_EXT_transform_feedback": 1
+            },
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "depthBiasClamp": true,
+                    "depthClamp": true,
+                    "dualSrcBlend": true,
+                    "fillModeNonSolid": true,
+                    "fullDrawIndexUint32": true,
+                    "geometryShader": true,
+                    "imageCubeArray": true,
+                    "independentBlend": true,
+                    "multiViewport": true,
+                    "occlusionQueryPrecise": true,
+                    "sampleRateShading": true,
+                    "shaderClipDistance": true,
+                    "shaderCullDistance": true,
+                    "shaderImageGatherExtended": true,
+                    "textureCompressionBC": true
+                },
+                "VkPhysicalDeviceVulkan11Features": {
+                    "shaderDrawParameters": true
+                },
+                "VkPhysicalDeviceVulkan12Features": {
+                    "samplerMirrorClampToEdge": true
+                },
+                "VkPhysicalDeviceRobustness2FeaturesEXT": {
+                    "nullDescriptor": true,
+                    "robustBufferAccess2": true
+                },
+                "VkPhysicalDeviceTransformFeedbackFeaturesEXT": {
+                    "transformFeedback": true,
+                    "geometryStreams": true
+                }
+            }
+        },
+        "d3d11_baseline_optional":{
+            "extensions": {
+                "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_swapchain_colorspace": 1,
+                "VK_EXT_hdr_metadata": 1
+            },
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "depthBounds": true,
+                    "pipelineStatisticsQuery": true,
+                    "logicOp": true,
+                    "samplerAnisotropy": true
+                },
+                "VkPhysicalDeviceMemoryPriorityFeaturesEXT": {
+                    "memoryPriority": true
+                },
+                "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT": {
+                    "vertexAttributeInstanceRateDivisor": true,
+                    "vertexAttributeInstanceRateZeroDivisor": true
+                },
+                "VkPhysicalDeviceCustomBorderColorFeaturesEXT": {
+                    "customBorderColors": true,
+                    "customBorderColorWithoutFormat": true
+                },
+                "VkPhysicalDeviceDepthClipEnableFeaturesEXT": {
+                    "depthClipEnable": true
+                }
+            }
+        },
+        "d3d11_level11_0": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "drawIndirectFirstInstance": true,
+                    "fragmentStoresAndAtomics": true,
+                    "multiDrawIndirect": true,
+                    "tessellationShader": true
+                }
+            }
+        },
+        "d3d11_level11_0_optional": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "shaderFloat64": true,
+                    "shaderInt64": true
+                }
+            }
+        },
+        "d3d11_level11_1": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "logicOp": true,
+                    "vertexPipelineStoresAndAtomics": true
+                }
+            }
+        },
+        "d3d11_level12_0": {
+            "features": {
+                "VkPhysicalDeviceFeatures": {
+                    "shaderResourceResidency": true,
+                    "shaderResourceMinLod": true,
+                    "sparseBinding": true,
+                    "sparseResidencyBuffer": true,
+                    "sparseResidencyAliased": true,
+                    "sparseResidencyImage2D": true
+                },
+                "VkPhysicalDeviceVulkan12Features": {
+                    "samplerFilterMinmax": true
+                }
+            },
+            "properties": {
+                "VkPhysicalDeviceProperties": {
+                    "sparseProperties": {
+                        "residencyStandard2DBlockShape": true,
+                        "residencyAlignedMipSize": false,
+                        "residencyNonResidentStrict": true
+                    }
+                }
+            }
+        }
+    },
+    "profiles": {
+        "VP_DXVK_d3d9_baseline": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D9 Baseline profile",
+            "description": "DXVK for D3D9 minimum requirements",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d9_baseline"
+            ]
+        },
+        "VP_DXVK_d3d9_optimal": {
+            "version": 1,
+            "api-version": "1.3.224",
+            "label": "DXVK D3D9 Optimal profile",
+            "description": "DXVK for D3D9 including optional capabilities",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d9_baseline",
+                "d3d9_optional"
+            ]
+        },
+        "VP_DXVK_d3d10_level_10_1_baseline": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D10 Level 10.1 Baseline profile",
+            "description": "DXVK for D3D10 Feature Level 10.1 minimum requirements",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d11_baseline"
+            ]
+        },
+        "VP_DXVK_d3d11_level_11_0_baseline": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D11 Level 11.0 Baseline profile",
+            "description": "DXVK for D3D11 Feature Level 11.0 minimum requirements",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d11_baseline",
+                "d3d11_level11_0"
+            ]
+        },
+        "VP_DXVK_d3d11_level_11_1_baseline": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D11 Level 11.1 Baseline profile",
+            "description": "DXVK for D3D11 Feature Level 11.1 minimum requirements",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d11_baseline",
+                "d3d11_level11_0",
+                "d3d11_level11_1"
+            ]
+        },
+        "VP_DXVK_d3d11_level_11_1_optimal": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D11 Level 11.1 Optimal profile",
+            "description": "DXVK for D3D11 Feature Level 11.1 including optional capabilities",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d11_baseline",
+                "d3d11_baseline_optional",
+                "d3d11_level11_0",
+                "d3d11_level11_0_optional",
+                "d3d11_level11_1"
+            ]
+        },
+        "VP_DXVK_d3d11_level_12_0_optimal": {
+            "version": 1,
+            "api-version": "1.3.204",
+            "label": "DXVK D3D11 Level 12.0 Optimal profile",
+            "description": "DXVK for D3D11 Feature Level 12.0 including optional capabilities",
+            "capabilities": [
+                "vulkan10requirements",
+                "vulkan11requirements",
+                "vulkan12requirements",
+                "vulkan13requirements",
+                "d3d11_baseline",
+                "d3d11_baseline_optional",
+                "d3d11_level11_0",
+                "d3d11_level11_0_optional",
+                "d3d11_level11_1",
+                "d3d11_level12_0"
+            ]
+        }
+    },
+    "contributors": {
+        "Philip Rebohle": {
+            "company": "Valve"
+        },
+        "Joshua Ashton": {
+            "company": "Valve"
+        },
+        "Pierre-Loup A. Griffais": {
+            "company": "Valve"
+        },
+        "Georg Lehmann": {
+            "company": "DXVK"
+        },
+        "Christophe Riccio": {
+            "company": "LunarG"
+        }
+    },
+    "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",
+            "author": "Christophe Riccio",
+            "comment": "Factorize history and contributors sections using schema 0.8.1"
+        },
+        {
+            "revision": 2,
+            "date": "2022-08-30",
+            "author": "Philip Rebohle",
+            "comment": "Add VP_DXVK_d3d11_level_12_0_optimal profile"
+        },
+        {
+            "revision": 1,
+            "date": "2022-08-22",
+            "author": "Christophe Riccio",
+            "comment": "Initial revision"
+        }
+    ]
+}

build-win32.txt

@@ -3,12 +3,9 @@ c = 'i686-w64-mingw32-gcc'
 cpp = 'i686-w64-mingw32-g++'
 ar = 'i686-w64-mingw32-ar'
 strip = 'i686-w64-mingw32-strip'
+windres = 'i686-w64-mingw32-windres'
 
 [properties]
-c_args=['-msse', '-msse2']
-cpp_args=['-msse', '-msse2']
-c_link_args = ['-static', '-static-libgcc']
-cpp_link_args = ['-static', '-static-libgcc', '-static-libstdc++']
 needs_exe_wrapper = true
 
 [host_machine]

build-win64.txt

@@ -3,10 +3,9 @@ c = 'x86_64-w64-mingw32-gcc'
 cpp = 'x86_64-w64-mingw32-g++'
 ar = 'x86_64-w64-mingw32-ar'
 strip = 'x86_64-w64-mingw32-strip'
+windres = 'x86_64-w64-mingw32-windres'
 
 [properties]
-c_link_args = ['-static', '-static-libgcc']
-cpp_link_args = ['-static', '-static-libgcc', '-static-libstdc++']
 needs_exe_wrapper = true
 
 [host_machine]

buildenv.h.in

@@ -0,0 +1,6 @@
+#pragma once
+
+#define DXVK_TARGET "@BUILD_TARGET@"
+#define DXVK_COMPILER "@BUILD_COMPILER@"
+#define DXVK_COMPILER_VERSION "@BUILD_COMPILER_VERSION@"
+

dxvk.conf

@@ -1,3 +1,56 @@
+# Device filter. Only exposes devices whose Vulkan device name contains
+# the given string. May be useful to force an application to run on a
+# specific GPU, but not applications launched by that application.
+
+# dxvk.deviceFilter = ""
+
+
+# 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
+
+
+# Expose support for dcomp swap chains with a dummy window.
+#
+# This is not a valid implementation of DirectComposition swapchains,
+# however some games may rely on this functionality to be present while
+# others may require swap chain creation to fail.
+#
+# Supported values: True, False
+
+# dxgi.enableDummyCompositionSwapchain = False
+
+
+# Allows the Vulkan driver to opt-in to exclusive full-screen mode on
+# Windows. Certain features, such as variable refresh rate or HDR, will
+# not work without this setting, however enabling it will break certain
+# games that use additional GDI windows, and it will also break alt+tab.
+#
+# This setting has no effect on non-Windows platforms.
+#
+# Supported values: True, False
+
+# dxvk.allowFse = False
+
+
+# Enables Unreal Engine 4 HDR workarounds for games that do not follow
+# the standard -Win64-Shipping.exe naming scheme. May be needed to avoid
+# crashes in D3D11 games on HDR-enabled systems due to statically linked
+# AMDAGS.
+# 
+# Supported values: True, False
+
+# dxgi.enableUe4Workarounds = False
+
+
 # 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,
@@ -19,6 +72,61 @@
 # d3d9.maxFrameLatency = 0
 
 
+# Enables frame rate limiter. The main purpose of this is to work around
+# bugs in games that have physics or other simulation tied to their frame
+# rate, but do not provide their own limiter.
+#
+# Supported values
+# -1: Always disables the limiter
+#  0: Default behaviour. Limits the frame rate to the selected display
+#     refresh rate when vertical synchronization is enabled if the
+#     actual display mode does not match the game's one.
+#  n: Limit to n frames per second.
+
+# dxgi.maxFrameRate = 0
+# d3d9.maxFrameRate = 0
+
+
+# Controls latency sleep and Nvidia Reflex support.
+#
+# Supported values:
+# - Auto: By default, DXVK only supports latency sleep in D3D11 games that
+#         use Reflex if the graphics driver supports VK_NV_low_latency2,
+#         and if dxvk-nvapi is enabled in Proton.
+# - True: Enables built-in latency reduction based on internal timings.
+#         This assumes that input sampling for any given frame happens after
+#         the D3D9 or DXGI Present call returns; games that render and present
+#         asynchronously will not behave as intended.
+#         Similarly, this will not have any effect in games with built-in frame
+#         rate limiters, or if an external limiter (such as MangoHud) is used.
+#         In some games, enabling this may reduce performance or lead to less
+#         consistent frame pacing.
+#         The implementation will either use VK_NV_low_latency2 if supported
+#         by the driver, or a custom algorithm.
+# - False: Disable Reflex support as well as built-in latency reduction.
+  
+# dxvk.latencySleep = Auto
+
+
+# Tolerance for the latency sleep heuristic, in microseconds. Higher values
+# increase latency, but may lead to better frame pacing in some cases. Does
+# not have any effect if NV_low_latency2 is used.
+#
+# Supported values: Any non-negative number
+
+# dxvk.latencyTolerance = 1000
+
+
+# Disables the use of VK_NV_low_latency2. This will make Reflex unavailable
+# in games, and if dxvk.latencySleep is set to True, a custom algorithm will
+# be used for latency control. By default, the extension will not be used in
+# 32-bit applications due to driver issues.
+#
+# Supported values: Auto, True, False
+
+# dxvk.disableNvLowLatency2 = Auto
+
+
 # Override PCI vendor and device IDs reported to the application. Can
 # cause the app to adjust behaviour depending on the selected values.
 #
@@ -31,18 +139,51 @@
 # d3d9.customVendorId = 0000
 
 
-# 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.
+# Override the reported device description
 #
-# Supported values: True, False
+# Supported values: Any string.
 
-# dxgi.nvapiHack = True
+# dxgi.customDeviceDesc = ""
+# d3d9.customDeviceDesc = ""
 
 
+# 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: Auto, True, False
+
+# 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.
 
@@ -50,14 +191,6 @@
 # dxgi.maxSharedMemory = 0
 
 
-# Override back buffer count for the Vulkan swap chain.
-# Setting this to 0 or less will have no effect.
-#
-# Supported values: Any number greater than or equal to 2.
-
-# dxgi.numBackBuffers = 0
-
-
 # Overrides synchronization interval (Vsync) for presentation.
 # Setting this to 0 disables vertical synchronization entirely.
 # A positive value 'n' will enable Vsync and repeat the same
@@ -65,14 +198,14 @@
 #
 # Supported values: Any non-negative number
 
-# dxgi.syncInterval   = -1
+# dxgi.syncInterval = -1
 # d3d9.presentInterval = -1
 
 
+# Controls tearing behaviour with regards to in-game Vsync settings.
+#
 # True enables the mailbox present mode in case regular Vsync is disabled.
-# This should avoid tearing, but may be unsupported on some systems
-# or require setting dxgi.numBackBuffers to a higher value in order
-# to work properly. 
+# This eliminates tearing, but may be unsupported on some systems.
 #
 # False enables the relaxed fifo present mode in case regular Vsync is enabled.
 # This should result in tearing but reduce stutter if FPS are too low,
@@ -82,35 +215,26 @@
 #
 # Supported values: Auto, True, False
 
-# dxgi.tearFree = Auto
-# d3d9.tearFree = Auto
+# dxvk.tearFree = Auto
 
 
-# Performs range check on dynamically indexed constant buffers in shaders.
-# This may be needed to work around a certain type of game bug, but may
-# also introduce incorrect behaviour.
+# Controls tiler optimizations. Enabling these will alter the behaviour of
+# submission heuristics and enables some non-default behaviour in DXVK.
+# This option is only intended to be changed for performance testing and
+# debugging purposes.
 #
-# Supported values: True, False
+# Supported values: Auto, True, False
 
-# d3d11.constantBufferRangeCheck = False
-
-
-# Assume single-use mode for command lists created on deferred contexts.
-# This may need to be disabled for some applications to avoid rendering
-# issues, which may come at a significant performance cost.
-#
-# Supported values: True, False
-
-# d3d11.dcSingleUseMode = True
+# dxvk.tilerMode = Auto
 
 
 # Override the maximum feature level that a D3D11 device can be created
 # with. Setting this to a higher value may allow some applications to run
 # that would otherwise fail to create a D3D11 device.
 #
-# Supported values: 9_1, 9_2, 9_3, 10_0, 10_1, 11_0, 11_1
+# Supported values: 9_1, 9_2, 9_3, 10_0, 10_1, 11_0, 11_1, 12_0, 12_1
 
-# d3d11.maxFeatureLevel = 11_1
+# d3d11.maxFeatureLevel = 12_1
 
 
 # Overrides the maximum allowed tessellation factor. This can be used to
@@ -122,15 +246,27 @@
 
 
 # Enables relaxed pipeline barriers around UAV writes.
-# 
-# This may improve performance in some games, but may also introduce
-# rendering issues. Please don't report bugs with the option enabled.
+#
+# Ignores write-after-write hazards in compute shaders, and all UAV
+# hazards in graphics shaders. This may improve performance in some
+# games, but may also introduce rendering issues. Please don't report
+# bugs with the option enabled.
 #
 # Supported values: True, False
 
 # d3d11.relaxedBarriers = False
 
 
+# Enables relaxed UAV pipeline barriers in graphics shaders only.
+#
+# Similar to the relaxedBarriers option, except it does not apply to
+# compute UAVs. Please do not report bugs with this option enabled.
+#
+# Supported values: True, False
+
+# d3d11.relaxedGraphicsBarriers = False
+
+
 # Overrides anisotropic filtering for all samplers. Set this to a positive
 # value to enable AF for all samplers in the game, or to 0 in order to
 # disable AF entirely. Negative values will have no effect.
@@ -138,7 +274,27 @@
 # Supported values: Any number between 0 and 16
 
 # d3d11.samplerAnisotropy = -1
-# d3d9.samplerAnisotropy  = -1
+# d3d9.samplerAnisotropy = -1
+
+
+# Changes the mipmap LOD bias for all samplers. The given number will be
+# added to the LOD bias provided by the application, rather than replacing
+# it entirely. Positive values will reduce texture detail, while negative
+# values may increase sharpness at the cost of shimmer.
+#
+# 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
@@ -146,16 +302,26 @@
 #
 # Supported values: True, False
 
-# d3d11.invariantPosition = False
-# d3d9.invariantPosition = False
+# d3d11.invariantPosition = True
+# d3d9.invariantPosition = True
 
 
-# Replaces NaN outputs from fragment shaders with zeroes for floating
-# point render target. Used in some games to prevent artifacting.
+# 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.enableRtOutputNanFixup = 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.
+#
+# Supported values: True, False
+
+# d3d11.disableMsaa = False
 
 
 # Clears workgroup memory in compute shaders to zero. Some games don't do
@@ -166,10 +332,92 @@
 # d3d11.zeroWorkgroupMemory = False
 
 
+# Forces insertion of memory barriers after writes to group-shared memory in
+# compute shaders. This is only intended to be used as a workaround for games
+# that don't properly synchronize access to groupshard variables, and may have
+# a negative performance impact as it prevents compiler optimizations.
+#
+# Supported values: True, False
+
+# d3d11.forceVolatileTgsmAccess = False
+
+
+# Forces insertion of full memory and control barriers after accessing any
+# read-write UAV inside compute shaders. This is only intended to be used as
+# a workaround for games that do not synchronize access to coherent UAVs,
+# and will likely have a negative performance impact.
+#
+# Supported values: True, False
+
+# d3d11.forceComputeUavBarriers = False
+
+
+# Clears mapped memory to zero when suballocated memory is freed. This will
+# drastically increase CPU overhead and should only be used as a last resort
+# if a game does not properly initialize mapped buffers on its own.
+#
+# Supported values: True, False
+
+# dxvk.zeroMappedMemory = False
+
+
+# Allocates dynamic resources with the given set of bind flags 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: Any combination of the following:
+# - v: Vertex buffers
+# - i: Index buffers
+# - c: Constant buffers
+# - r: Shader resources
+# - a: All dynamic resources
+
+# d3d11.cachedDynamicResources = ""
+
+
+# Force-enables the D3D11 context lock via the ID3D10Multithread
+# interface. This may be useful to debug race conditions.
+#
+# Supported values: True, False
+
+# 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
+
+
+# Reproducible Command Stream
+#
+# Ensure that for the same D3D commands the output VK commands
+# don't change between runs. Useful for comparative benchmarking,
+# can negatively affect performance and can break some games
+# that don't use queries correctly.
+#
+# Supported values:
+# - True/False
+
+# d3d11.reproducibleCommandStream = False
+# d3d9.reproducibleCommandStream = False
+
+
 # Sets number of pipeline compiler threads.
 # 
+# If the graphics pipeline library feature is enabled, the given
+# number of threads will be used for shader compilation. Some of
+# these threads will be reserved for high-priority work.
+#
 # Supported values:
-# - 0 to automatically determine the number of threads to use
+# - 0 to use all available CPU cores
 # - any positive number to enforce the thread count
 
 # dxvk.numCompilerThreads = 0
@@ -190,19 +438,47 @@
 # dxvk.useRawSsbo = Auto
 
 
-# Toggles early discard.
-# 
-# Uses subgroup operations to determine whether it is safe to
-# discard fragments before the end of a fragment shader. This
-# is enabled by default on all drivers except RADV and Nvidia.
-# Enabling this may improve or degrade performance depending
-# on the game and hardware, or cause other issues.
-# 
+# Controls graphics pipeline library behaviour
+#
+# Can be used to change VK_EXT_graphics_pipeline_library usage for
+# debugging purpose. Doing so will likely result in increased stutter
+# or degraded performance.
+#
 # Supported values:
-# - Auto: Don't change the default
-# - True, False: Always enable / disable
+# - Auto: Enable if supported, and compile optimized pipelines in the background
+# - True: Enable if supported, but do not compile optimized pipelines
+# - False: Always disable the feature
 
-# dxvk.useEarlyDiscard = Auto
+# dxvk.enableGraphicsPipelineLibrary = Auto
+
+
+# Controls pipeline lifetime tracking
+#
+# If enabled, pipeline libraries will be freed aggressively in order
+# save memory and address space. Has no effect if graphics pipeline
+# libraries are not supported or disabled.
+#
+# Supported values:
+# - Auto: Enable tracking for 32-bit applications only
+# - True: Always enable tracking
+# - False: Always disable tracking
+
+# dxvk.trackPipelineLifetime = Auto
+
+
+# Controls memory defragmentation
+#
+# By default, DXVK will try to defragment video memory if there is a
+# significant amount of memory wasted, or if the allocation budget of
+# the application is exceeded. This option is provided solely for
+# debug purposes.
+#
+# Supported values:
+# - True: Enable defragmentation
+# - Auto: Enable defragmentation, except on blocked drivers
+# - False: Disable defragmentation
+
+# dxvk.enableMemoryDefrag = Auto
 
 
 # Sets enabled HUD elements
@@ -220,6 +496,7 @@
 # capabilities that the applicatation queries.
 # 
 # Supported values:
+# - 0: Fixed-function only
 # - 1: Shader Model 1
 # - 2: Shader Model 2
 # - 3: Shader Model 3
@@ -227,17 +504,6 @@
 # d3d9.shaderModel = 3
 
 
-# Evict Managed on Unlock
-# 
-# Decides whether we should evict managed resources from
-# system memory when they are unlocked entirely.
-#
-# Supported values:
-# - True, False: Always enable / disable
-
-# d3d9.evictManagedOnUnlock = False
-
-
 # DPI Awareness
 # 
 # Decides whether we should call SetProcessDPIAware on device
@@ -290,55 +556,210 @@
 # Value in Megabytes
 #
 # Supported values:
-# - Any int32_t
+# - Max Available Memory: Any int32_t
+# - Memory Tracking Testing: True, False
 
 # d3d9.maxAvailableMemory = 4096
+# d3d9.memoryTrackTest = False
 
 
 # Force enable/disable floating point quirk emulation
-# 
+#
 # Force toggle anything * 0 emulation
-# Tristate
+# Setting it to True will use a faster but less accurate approach that works for most games.
 # Supported values:
-# - True/False
+# - True: Use a faster but less accurate approach. Good enough for most games
+# - False: Disable float emulation completely
+# - Strict: Use a slower but more correct approach. Necessary for some games
+# - Auto: DXVK will pick automatically
 
-# d3d9.floatEmulation = 
+# d3d9.floatEmulation = Auto
 
 
-# Enable dialog box mode
-#
-# Changes the default state of dialog box mode.
-# *Disables* exclusive fullscreen when enabled.
-#
-# Supported values:
-# - True, False: Always enable / disable
-
-# d3d9.enableDialogMode = False
-
 # Overrides the application's MSAA level on the swapchain
 # 
 # Supported values: -1 (application) and 0 to 16 (user override)
 
-# d3d9.forceSwapchainMSAA  = -1
+# d3d9.forceSwapchainMSAA = -1
 
 
-# Long Mad
+# Device Local Constant Buffers
 #
-# Should we make our Mads a FFma or do it the long way with an FMul and an FAdd?
-# This solves some rendering bugs in games that have z-pass shaders which
-# don't match entirely to the regular vertex shader in this way.
+# Enables using device local, host accessible memory for constant buffers in D3D9.
+# This tends to actually be slower for some reason on AMD,
+# and the exact same performance on NVIDIA.
 #
 # Supported values:
 # - True/False
 
-# d3d9.longMad = False
+# d3d9.deviceLocalConstantBuffers = False
 
-# Alpha Test Wiggle Room
+# Support DF formats
 #
-# Workaround for games using alpha test == 1.0, etc due to wonky interpolation or
-# misc. imprecision on some vendors
+# 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
 
-# d3d9.alphaTestWiggleRoom = False
+# d3d9.supportDFFormats = True
+
+# Use D32f for D24
+#
+# Useful for reproducing AMD issues on other hw.
+#
+# Supported values:
+# - True/False
+
+# d3d9.useD32forD24 = False
+
+# Support X4R4G4B4
+#
+# Support the X4R4G4B4 format.
+# The Sims 2 is a very broken game.
+#
+# Supported values:
+# - True/False
+
+# d3d9.supportX4R4G4B4 = True
+
+# Support D16_LOCKABLE
+#
+# Support the D16_LOCKABLE format.
+# Always enabled on AMD, or when spoofing an AMD GPU
+# via customVendorId, disabled by default on Nvidia and Intel.
+#
+# Supported values:
+# - True/False
+
+# d3d9.supportD16Lockable = False
+
+# Disable A8 as a Render Target
+#
+# Disable support for A8 format render targets
+# Once again, The Sims 2 is a very broken game.
+#
+# Supported values:
+# - True/False
+
+# d3d9.disableA8RT = False
+
+# Support for VCache Query
+#
+# Support for the vcache query
+# Not very important as a user config.
+# Used internally.
+#
+# Supported values:
+# - True/False
+
+# Defaults to True if vendorId == 0x10de
+# d3d9.supportVCache = True
+
+# Force Sampler Type Spec Constants
+#
+# Useful if games use the wrong image and sampler
+# type combo like Halo: CE or Spellforce.
+# Can fix rendering in older, broken games in some instances.
+#
+# Supported values:
+# - True/False
+
+# d3d9.forceSamplerTypeSpecConstants = False
+
+# Force Aspect Ratio
+#
+# Only exposes modes with a given aspect ratio.
+# Useful for titles that break if they see ultra-wide.
+#
+# Supported values:
+# - Any ratio, ie. "16:9", "4:3"
+
+# d3d9.forceAspectRatio = ""
+
+# Enumerate by Displays
+#
+# Whether we should enumerate D3D9 adapters by display (windows behaviour)
+# or by physical adapter.
+# May be useful in PRIME setups.
+#
+# Supported values:
+# - True/False
+
+# d3d9.enumerateByDisplays = True
+
+# Cached Dynamic Buffers
+#
+# 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.cachedDynamicBuffers = False
+
+# Seamless Cubes
+#
+# Don't use non seamless cube maps even if they are supported.
+# Non seamless cubes are correct d3d9 behavior, but can produce worse looking edges.
+#
+# Supported values:
+# - True/False
+
+# d3d9.seamlessCubes = False
+
+# Debug Utils
+#
+# Enables debug utils as this is off by default, this enables user annotations like BeginEvent()/EndEvent().
+# Alternatively could be enabled with DXVK_DEBUG=markers environment variable.
+#
+# Supported values:
+# - True/False
+
+# dxvk.enableDebugUtils = False
+
+# Memory limit for locked D3D9 textures
+#
+# How much virtual memory will be used for textures (in MB).
+# 0 to disable the limit.
+# THIS DOES NOT IMPACT ACTUAL MEMORY CONSUMPTION OR TEXTURE QUALITY.
+# 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/directx

@@ -0,0 +1 @@
+Subproject commit 9df86f2341616ef1888ae59919feaa6d4fad693d

include/native/meson.build

@@ -0,0 +1,20 @@
+install_subdir(
+  'directx',
+  install_dir: get_option('includedir') / 'dxvk',
+  strip_directory: true,
+  exclude_files: '.git'
+)
+
+install_subdir(
+  'windows',
+  install_dir: get_option('includedir') / 'dxvk',
+  strip_directory: true,
+)
+
+install_headers(
+  'wsi/native_wsi.h',
+  'wsi/native_sdl3.h',
+  'wsi/native_sdl2.h',
+  'wsi/native_glfw.h',
+  subdir: 'dxvk/wsi',
+)

include/native/windows/oaidl.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/objbase.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/ocidl.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/ole2.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/poppack.h

@@ -0,0 +1,8 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#if !(defined(lint) || defined(RC_INVOKED))
+#pragma pack(pop)
+#endif

include/native/windows/pshpack4.h

@@ -0,0 +1,8 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+#if !(defined(lint) || defined(RC_INVOKED))
+#pragma pack(push,4)
+#endif

include/native/windows/rpc.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/rpcndr.h

@@ -0,0 +1,3 @@
+#pragma once
+
+// Don't care.

include/native/windows/unknwn.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "windows_base.h"
+
+typedef interface IUnknown IUnknown;
+
+DEFINE_GUID(IID_IUnknown, 0x00000000,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46)
+
+#ifdef __cplusplus
+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;
+
+};
+#else
+typedef struct IUnknownVtbl
+{
+BEGIN_INTERFACE
+
+  HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+    IUnknown *This,
+    REFIID riid,
+    void **ppvObject
+  );
+  ULONG (STDMETHODCALLTYPE *AddRef)(IUnknown *This);
+  ULONG (STDMETHODCALLTYPE *Release)(IUnknown *This);
+
+END_INTERFACE
+} IUnknownVtbl;
+
+interface IUnknown
+{
+    CONST_VTBL struct IUnknownVtbl *lpVtbl;
+};
+
+#define IUnknown_AddRef(This) ((This)->lpVtbl->AddRef(This))
+#define IUnknown_Release(This) ((This)->lpVtbl->Release(This))
+
+#endif // __cplusplus
+
+DECLARE_UUIDOF_HELPER(IUnknown, 0x00000000,0x0000,0x0000,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46)
+
+#define IID_PPV_ARGS(ppType) __uuidof(decltype(**(ppType))), [](auto** pp) { (void)static_cast<IUnknown*>(*pp); return reinterpret_cast<void**>(pp); }(ppType)

include/native/windows/windows.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#include "windows_base.h"
+#include "unknwn.h"

include/native/windows/windows_base.h

@@ -0,0 +1,400 @@
+#pragma once
+
+#ifdef __cplusplus
+#include <cstdint>
+#include <cstring>
+#else
+#include <stdint.h>
+#include <string.h>
+#include <wchar.h>
+#endif // __cplusplus
+
+// GCC complains about the COM interfaces
+// not having virtual destructors
+
+// and class conversion for C...DESC helper types
+#if defined(__GNUC__) && defined(__cplusplus)
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#pragma GCC diagnostic ignored "-Wclass-conversion"
+#endif // __GNUC__ && __cplusplus
+
+typedef int32_t INT;
+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;
+
+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;
+
+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;
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+typedef struct GUID {
+  uint32_t Data1;
+  uint16_t Data2;
+  uint16_t Data3;
+  uint8_t  Data4[8];
+} GUID;
+#endif // GUID_DEFINED
+
+typedef GUID UUID;
+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
+
+template <typename T>
+constexpr GUID __uuidof_helper();
+
+#define __uuidof(T) __uuidof_helper<T>()
+#define __uuidof_var(T) __uuidof_helper<decltype(T)>()
+
+inline bool operator==(const GUID& a, const GUID& b) { return std::memcmp(&a, &b, sizeof(GUID)) == 0; }
+inline bool operator!=(const GUID& a, const GUID& b) { return std::memcmp(&a, &b, sizeof(GUID)) != 0; }
+
+#endif // __cplusplus
+
+typedef uint32_t DWORD;
+typedef uint16_t WORD;
+typedef DWORD *LPDWORD;
+
+typedef void* HANDLE;
+typedef HANDLE HMONITOR;
+typedef HANDLE HDC;
+typedef HANDLE HMODULE;
+typedef HANDLE HINSTANCE;
+typedef HANDLE HWND;
+typedef HANDLE HKEY;
+typedef HANDLE *LPHANDLE;
+typedef DWORD COLORREF;
+
+#if INTPTR_MAX == INT64_MAX
+typedef int64_t  INT_PTR;
+typedef uint64_t UINT_PTR;
+#else
+typedef int32_t  INT_PTR;
+typedef uint32_t UINT_PTR;
+#endif
+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;
+typedef const wchar_t* LPCWSTR;
+
+typedef struct LUID {
+  DWORD LowPart;
+  LONG  HighPart;
+} LUID;
+
+typedef struct POINT {
+  LONG x;
+  LONG y;
+} POINT;
+
+typedef POINT* LPPOINT;
+
+typedef struct RECT {
+  LONG left;
+  LONG top;
+  LONG right;
+  LONG bottom;
+} RECT,*PRECT,*NPRECT,*LPRECT;
+
+typedef struct SIZE {
+  LONG cx;
+  LONG cy;
+} SIZE,*PSIZE,*LPSIZE;
+
+typedef union {
+  struct {
+    DWORD LowPart;
+    LONG HighPart;
+  };
+
+  struct {
+    DWORD LowPart;
+    LONG HighPart;
+  } u;
+
+  LONGLONG QuadPart;
+} LARGE_INTEGER;
+
+typedef struct MEMORYSTATUS {
+  DWORD  dwLength;
+  SIZE_T dwTotalPhys;
+} MEMORYSTATUS;
+
+typedef struct SECURITY_ATTRIBUTES {
+  DWORD nLength;
+  void* lpSecurityDescriptor;
+  BOOL  bInheritHandle;
+} SECURITY_ATTRIBUTES;
+
+typedef struct PALETTEENTRY {
+  BYTE peRed;
+  BYTE peGreen;
+  BYTE peBlue;
+  BYTE peFlags;
+} PALETTEENTRY, *PPALETTEENTRY, *LPPALETTEENTRY;
+
+typedef struct RGNDATAHEADER {
+  DWORD dwSize;
+  DWORD iType;
+  DWORD nCount;
+  DWORD nRgnSize;
+  RECT  rcBound;
+} RGNDATAHEADER;
+
+typedef struct RGNDATA {
+  RGNDATAHEADER rdh;
+  char          Buffer[1];
+} RGNDATA,*PRGNDATA,*NPRGNDATA,*LPRGNDATA;
+
+// Ignore these.
+#define STDMETHODCALLTYPE
+#define __stdcall
+
+#define CONST const
+#define CONST_VTBL const
+
+#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
+
+#ifdef __cplusplus
+
+#define DEFINE_GUID(iid, a, b, c, d, e, f, g, h, i, j, k) \
+  constexpr GUID iid = {a,b,c,{d,e,f,g,h,i,j,k}};
+
+#define DECLARE_UUIDOF_HELPER(type, a, b, c, d, e, f, g, h, i, j, k) \
+  extern "C++" { template <> constexpr GUID __uuidof_helper<type>() { return GUID{a,b,c,{d,e,f,g,h,i,j,k}}; } } \
+  extern "C++" { template <> constexpr GUID __uuidof_helper<type*>() { return __uuidof_helper<type>(); } } \
+  extern "C++" { template <> constexpr GUID __uuidof_helper<const type*>() { return __uuidof_helper<type>(); } } \
+  extern "C++" { template <> constexpr GUID __uuidof_helper<type&>() { return __uuidof_helper<type>(); } } \
+  extern "C++" { template <> constexpr GUID __uuidof_helper<const type&>() { return __uuidof_helper<type>(); } }
+
+#else
+#define DEFINE_GUID(iid, a, b, c, d, e, f, g, h, i, j, k) \
+  static const GUID iid = {a,b,c,{d,e,f,g,h,i,j,k}};
+#define DECLARE_UUIDOF_HELPER(type, a, b, c, d, e, f, g, h, i, j, k)
+#endif // __cplusplus
+
+#define __CRT_UUID_DECL(type, a, b, c, d, e, f, g, h, i, j, k) DECLARE_UUIDOF_HELPER(type, a, b, c, d, e, f, g, h, i, j, k)
+
+#define S_OK     0
+#define S_FALSE  1
+
+#define E_INVALIDARG  ((HRESULT)0x80070057)
+#define E_FAIL        ((HRESULT)0x80004005)
+#define E_NOINTERFACE ((HRESULT)0x80004002)
+#define E_NOTIMPL     ((HRESULT)0x80004001)
+#define E_OUTOFMEMORY ((HRESULT)0x8007000E)
+#define E_POINTER     ((HRESULT)0x80004003)
+
+#define DXGI_STATUS_OCCLUDED                     ((HRESULT)0x087a0001)
+#define DXGI_STATUS_CLIPPED                      ((HRESULT)0x087a0002)
+#define DXGI_STATUS_NO_REDIRECTION               ((HRESULT)0x087a0004)
+#define DXGI_STATUS_NO_DESKTOP_ACCESS            ((HRESULT)0x087a0005)
+#define DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE ((HRESULT)0x087a0006)
+#define DXGI_STATUS_MODE_CHANGED                 ((HRESULT)0x087a0007)
+#define DXGI_STATUS_MODE_CHANGE_IN_PROGRESS      ((HRESULT)0x087a0008)
+#define DXGI_STATUS_UNOCCLUDED                   ((HRESULT)0x087a0009)
+#define DXGI_STATUS_DDA_WAS_STILL_DRAWING        ((HRESULT)0x087a000a)
+#define DXGI_STATUS_PRESENT_REQUIRED             ((HRESULT)0x087a002f)
+
+#define DXGI_ERROR_INVALID_CALL                  ((HRESULT)0x887A0001)
+#define DXGI_ERROR_NOT_FOUND                     ((HRESULT)0x887A0002)
+#define DXGI_ERROR_MORE_DATA                     ((HRESULT)0x887A0003)
+#define DXGI_ERROR_UNSUPPORTED                   ((HRESULT)0x887A0004)
+#define DXGI_ERROR_DEVICE_REMOVED                ((HRESULT)0x887A0005)
+#define DXGI_ERROR_DEVICE_HUNG                   ((HRESULT)0x887A0006)
+#define DXGI_ERROR_DEVICE_RESET                  ((HRESULT)0x887A0007)
+#define DXGI_ERROR_WAS_STILL_DRAWING             ((HRESULT)0x887A000A)
+#define DXGI_ERROR_FRAME_STATISTICS_DISJOINT     ((HRESULT)0x887A000B)
+#define DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE  ((HRESULT)0x887A000C)
+#define DXGI_ERROR_DRIVER_INTERNAL_ERROR         ((HRESULT)0x887A0020)
+#define DXGI_ERROR_NONEXCLUSIVE                  ((HRESULT)0x887A0021)
+#define DXGI_ERROR_NOT_CURRENTLY_AVAILABLE       ((HRESULT)0x887A0022)
+#define DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED    ((HRESULT)0x887A0023)
+#define DXGI_ERROR_REMOTE_OUTOFMEMORY            ((HRESULT)0x887A0024)
+#define DXGI_ERROR_ACCESS_LOST                   ((HRESULT)0x887A0026)
+#define DXGI_ERROR_WAIT_TIMEOUT                  ((HRESULT)0x887A0027)
+#define DXGI_ERROR_SESSION_DISCONNECTED          ((HRESULT)0x887A0028)
+#define DXGI_ERROR_RESTRICT_TO_OUTPUT_STALE      ((HRESULT)0x887A0029)
+#define DXGI_ERROR_CANNOT_PROTECT_CONTENT        ((HRESULT)0x887A002A)
+#define DXGI_ERROR_ACCESS_DENIED                 ((HRESULT)0x887A002B)
+#define DXGI_ERROR_NAME_ALREADY_EXISTS           ((HRESULT)0x887A002C)
+#define DXGI_ERROR_SDK_COMPONENT_MISSING         ((HRESULT)0x887A002D)
+
+#define D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD ((HRESULT)0x887C0004)
+
+#define WINAPI
+#define WINUSERAPI
+
+#define RGB(r,g,b)          ((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)))
+
+#define MAKE_HRESULT(sev,fac,code) \
+    ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
+
+#ifdef __cplusplus
+#define STDMETHOD(name) virtual HRESULT name
+#define STDMETHOD_(type, name) virtual type name
+#else
+#define STDMETHOD(name) HRESULT (STDMETHODCALLTYPE *name)
+#define STDMETHOD_(type, name) type (STDMETHODCALLTYPE *name)
+#endif // __cplusplus
+
+#define THIS_
+#define THIS
+
+#define __C89_NAMELESSSTRUCTNAME
+#define __C89_NAMELESSUNIONNAME
+#define __C89_NAMELESSUNIONNAME1
+#define __C89_NAMELESSUNIONNAME2
+#define __C89_NAMELESSUNIONNAME3
+#define __C89_NAMELESSUNIONNAME4
+#define __C89_NAMELESSUNIONNAME5
+#define __C89_NAMELESSUNIONNAME6
+#define __C89_NAMELESSUNIONNAME7
+#define __C89_NAMELESSUNIONNAME8
+#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
+
+#define BEGIN_INTERFACE
+#define END_INTERFACE
+
+#ifdef __cplusplus
+#define PURE = 0
+#else
+#define PURE
+#endif // __cplusplus
+
+#define DECLSPEC_SELECTANY
+
+#define __MSABI_LONG(x) x
+
+#define ENUM_CURRENT_SETTINGS ((DWORD)-1)
+#define ENUM_REGISTRY_SETTINGS ((DWORD)-2)
+
+#define INVALID_HANDLE_VALUE ((HANDLE)-1)
+
+#define DUPLICATE_CLOSE_SOURCE ((DWORD)0x1)
+#define DUPLICATE_SAME_ACCESS ((DWORD)0x2)
+
+#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

@@ -0,0 +1,25 @@
+#include <windows.h>
+
+#include <SDL.h>
+
+namespace dxvk::wsi {
+
+  inline SDL_Window* fromHwnd(HWND hWindow) {
+    return reinterpret_cast<SDL_Window*>(hWindow);
+  }
+
+  inline HWND toHwnd(SDL_Window* 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_sdl3.h

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

include/native/wsi/native_wsi.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifdef DXVK_WSI_WIN32
+#error You shouldnt be using this code path.
+#elif DXVK_WSI_SDL3
+#include "wsi/native_sdl3.h"
+#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

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

include/spirv/GLSL.std.450.h

@@ -1,131 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLstd450_H
-#define GLSLstd450_H
-
-static const int GLSLstd450Version = 100;
-static const int GLSLstd450Revision = 3;
-
-enum GLSLstd450 {
-    GLSLstd450Bad = 0,              // Don't use
-
-    GLSLstd450Round = 1,
-    GLSLstd450RoundEven = 2,
-    GLSLstd450Trunc = 3,
-    GLSLstd450FAbs = 4,
-    GLSLstd450SAbs = 5,
-    GLSLstd450FSign = 6,
-    GLSLstd450SSign = 7,
-    GLSLstd450Floor = 8,
-    GLSLstd450Ceil = 9,
-    GLSLstd450Fract = 10,
-
-    GLSLstd450Radians = 11,
-    GLSLstd450Degrees = 12,
-    GLSLstd450Sin = 13,
-    GLSLstd450Cos = 14,
-    GLSLstd450Tan = 15,
-    GLSLstd450Asin = 16,
-    GLSLstd450Acos = 17,
-    GLSLstd450Atan = 18,
-    GLSLstd450Sinh = 19,
-    GLSLstd450Cosh = 20,
-    GLSLstd450Tanh = 21,
-    GLSLstd450Asinh = 22,
-    GLSLstd450Acosh = 23,
-    GLSLstd450Atanh = 24,
-    GLSLstd450Atan2 = 25,
-
-    GLSLstd450Pow = 26,
-    GLSLstd450Exp = 27,
-    GLSLstd450Log = 28,
-    GLSLstd450Exp2 = 29,
-    GLSLstd450Log2 = 30,
-    GLSLstd450Sqrt = 31,
-    GLSLstd450InverseSqrt = 32,
-
-    GLSLstd450Determinant = 33,
-    GLSLstd450MatrixInverse = 34,
-
-    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
-    GLSLstd450ModfStruct = 36,      // no OpVariable operand
-    GLSLstd450FMin = 37,
-    GLSLstd450UMin = 38,
-    GLSLstd450SMin = 39,
-    GLSLstd450FMax = 40,
-    GLSLstd450UMax = 41,
-    GLSLstd450SMax = 42,
-    GLSLstd450FClamp = 43,
-    GLSLstd450UClamp = 44,
-    GLSLstd450SClamp = 45,
-    GLSLstd450FMix = 46,
-    GLSLstd450IMix = 47,            // Reserved
-    GLSLstd450Step = 48,
-    GLSLstd450SmoothStep = 49,
-
-    GLSLstd450Fma = 50,
-    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
-    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
-    GLSLstd450Ldexp = 53,
-
-    GLSLstd450PackSnorm4x8 = 54,
-    GLSLstd450PackUnorm4x8 = 55,
-    GLSLstd450PackSnorm2x16 = 56,
-    GLSLstd450PackUnorm2x16 = 57,
-    GLSLstd450PackHalf2x16 = 58,
-    GLSLstd450PackDouble2x32 = 59,
-    GLSLstd450UnpackSnorm2x16 = 60,
-    GLSLstd450UnpackUnorm2x16 = 61,
-    GLSLstd450UnpackHalf2x16 = 62,
-    GLSLstd450UnpackSnorm4x8 = 63,
-    GLSLstd450UnpackUnorm4x8 = 64,
-    GLSLstd450UnpackDouble2x32 = 65,
-
-    GLSLstd450Length = 66,
-    GLSLstd450Distance = 67,
-    GLSLstd450Cross = 68,
-    GLSLstd450Normalize = 69,
-    GLSLstd450FaceForward = 70,
-    GLSLstd450Reflect = 71,
-    GLSLstd450Refract = 72,
-
-    GLSLstd450FindILsb = 73,
-    GLSLstd450FindSMsb = 74,
-    GLSLstd450FindUMsb = 75,
-
-    GLSLstd450InterpolateAtCentroid = 76,
-    GLSLstd450InterpolateAtSample = 77,
-    GLSLstd450InterpolateAtOffset = 78,
-
-    GLSLstd450NMin = 79,
-    GLSLstd450NMax = 80,
-    GLSLstd450NClamp = 81,
-
-    GLSLstd450Count
-};
-
-#endif  // #ifndef GLSLstd450_H

include/spirv/GLSL.std.450.hpp

@@ -1,135 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLstd450_HPP
-#define GLSLstd450_HPP
-
-namespace spv {
-  
-static const int GLSLstd450Version = 100;
-static const int GLSLstd450Revision = 3;
-
-enum GLSLstd450 {
-    GLSLstd450Bad = 0,              // Don't use
-
-    GLSLstd450Round = 1,
-    GLSLstd450RoundEven = 2,
-    GLSLstd450Trunc = 3,
-    GLSLstd450FAbs = 4,
-    GLSLstd450SAbs = 5,
-    GLSLstd450FSign = 6,
-    GLSLstd450SSign = 7,
-    GLSLstd450Floor = 8,
-    GLSLstd450Ceil = 9,
-    GLSLstd450Fract = 10,
-
-    GLSLstd450Radians = 11,
-    GLSLstd450Degrees = 12,
-    GLSLstd450Sin = 13,
-    GLSLstd450Cos = 14,
-    GLSLstd450Tan = 15,
-    GLSLstd450Asin = 16,
-    GLSLstd450Acos = 17,
-    GLSLstd450Atan = 18,
-    GLSLstd450Sinh = 19,
-    GLSLstd450Cosh = 20,
-    GLSLstd450Tanh = 21,
-    GLSLstd450Asinh = 22,
-    GLSLstd450Acosh = 23,
-    GLSLstd450Atanh = 24,
-    GLSLstd450Atan2 = 25,
-
-    GLSLstd450Pow = 26,
-    GLSLstd450Exp = 27,
-    GLSLstd450Log = 28,
-    GLSLstd450Exp2 = 29,
-    GLSLstd450Log2 = 30,
-    GLSLstd450Sqrt = 31,
-    GLSLstd450InverseSqrt = 32,
-
-    GLSLstd450Determinant = 33,
-    GLSLstd450MatrixInverse = 34,
-
-    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
-    GLSLstd450ModfStruct = 36,      // no OpVariable operand
-    GLSLstd450FMin = 37,
-    GLSLstd450UMin = 38,
-    GLSLstd450SMin = 39,
-    GLSLstd450FMax = 40,
-    GLSLstd450UMax = 41,
-    GLSLstd450SMax = 42,
-    GLSLstd450FClamp = 43,
-    GLSLstd450UClamp = 44,
-    GLSLstd450SClamp = 45,
-    GLSLstd450FMix = 46,
-    GLSLstd450IMix = 47,            // Reserved
-    GLSLstd450Step = 48,
-    GLSLstd450SmoothStep = 49,
-
-    GLSLstd450Fma = 50,
-    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
-    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
-    GLSLstd450Ldexp = 53,
-
-    GLSLstd450PackSnorm4x8 = 54,
-    GLSLstd450PackUnorm4x8 = 55,
-    GLSLstd450PackSnorm2x16 = 56,
-    GLSLstd450PackUnorm2x16 = 57,
-    GLSLstd450PackHalf2x16 = 58,
-    GLSLstd450PackDouble2x32 = 59,
-    GLSLstd450UnpackSnorm2x16 = 60,
-    GLSLstd450UnpackUnorm2x16 = 61,
-    GLSLstd450UnpackHalf2x16 = 62,
-    GLSLstd450UnpackSnorm4x8 = 63,
-    GLSLstd450UnpackUnorm4x8 = 64,
-    GLSLstd450UnpackDouble2x32 = 65,
-
-    GLSLstd450Length = 66,
-    GLSLstd450Distance = 67,
-    GLSLstd450Cross = 68,
-    GLSLstd450Normalize = 69,
-    GLSLstd450FaceForward = 70,
-    GLSLstd450Reflect = 71,
-    GLSLstd450Refract = 72,
-
-    GLSLstd450FindILsb = 73,
-    GLSLstd450FindSMsb = 74,
-    GLSLstd450FindUMsb = 75,
-
-    GLSLstd450InterpolateAtCentroid = 76,
-    GLSLstd450InterpolateAtSample = 77,
-    GLSLstd450InterpolateAtOffset = 78,
-
-    GLSLstd450NMin = 79,
-    GLSLstd450NMax = 80,
-    GLSLstd450NClamp = 81,
-
-    GLSLstd450Count
-};
-
-}
-
-#endif  // #ifndef GLSLstd450_HPP

include/vulkan

@@ -0,0 +1 @@
+Subproject commit 234c4b7370a8ea3239a214c9e871e4b17c89f4ab

include/vulkan/vk_platform.h

@@ -1,92 +0,0 @@
-//
-// File: vk_platform.h
-//
-/*
-** Copyright (c) 2014-2017 The Khronos Group Inc.
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-
-#ifndef VK_PLATFORM_H_
-#define VK_PLATFORM_H_
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif // __cplusplus
-
-/*
-***************************************************************************************************
-*   Platform-specific directives and type declarations
-***************************************************************************************************
-*/
-
-/* Platform-specific calling convention macros.
- *
- * Platforms should define these so that Vulkan clients call Vulkan commands
- * with the same calling conventions that the Vulkan implementation expects.
- *
- * VKAPI_ATTR - Placed before the return type in function declarations.
- *              Useful for C++11 and GCC/Clang-style function attribute syntax.
- * VKAPI_CALL - Placed after the return type in function declarations.
- *              Useful for MSVC-style calling convention syntax.
- * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
- *
- * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
- * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
- */
-#if defined(_WIN32)
-    // On Windows, Vulkan commands use the stdcall convention
-    #define VKAPI_ATTR
-    #define VKAPI_CALL __stdcall
-    #define VKAPI_PTR  VKAPI_CALL
-#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
-    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
-#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
-    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
-    // calling convention, i.e. float parameters are passed in registers. This
-    // is true even if the rest of the application passes floats on the stack,
-    // as it does by default when compiling for the armeabi-v7a NDK ABI.
-    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
-    #define VKAPI_CALL
-    #define VKAPI_PTR  VKAPI_ATTR
-#else
-    // On other platforms, use the default calling convention
-    #define VKAPI_ATTR
-    #define VKAPI_CALL
-    #define VKAPI_PTR
-#endif
-
-#include <stddef.h>
-
-#if !defined(VK_NO_STDINT_H)
-    #if defined(_MSC_VER) && (_MSC_VER < 1600)
-        typedef signed   __int8  int8_t;
-        typedef unsigned __int8  uint8_t;
-        typedef signed   __int16 int16_t;
-        typedef unsigned __int16 uint16_t;
-        typedef signed   __int32 int32_t;
-        typedef unsigned __int32 uint32_t;
-        typedef signed   __int64 int64_t;
-        typedef unsigned __int64 uint64_t;
-    #else
-        #include <stdint.h>
-    #endif
-#endif // !defined(VK_NO_STDINT_H)
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
-
-#endif

include/vulkan/vulkan.h

@@ -1,86 +0,0 @@
-#ifndef VULKAN_H_
-#define VULKAN_H_ 1
-
-/*
-** Copyright (c) 2015-2019 The Khronos Group Inc.
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#include "vk_platform.h"
-#include "vulkan_core.h"
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-#include "vulkan_android.h"
-#endif
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-#include <zircon/types.h>
-#include "vulkan_fuchsia.h"
-#endif
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-#include "vulkan_ios.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-#include "vulkan_macos.h"
-#endif
-
-#ifdef VK_USE_PLATFORM_METAL_EXT
-#include "vulkan_metal.h"
-#endif
-
-#ifdef VK_USE_PLATFORM_VI_NN
-#include "vulkan_vi.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-#include <wayland-client.h>
-#include "vulkan_wayland.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#include <windows.h>
-#include "vulkan_win32.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-#include <xcb/xcb.h>
-#include "vulkan_xcb.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-#include <X11/Xlib.h>
-#include "vulkan_xlib.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#include <X11/Xlib.h>
-#include <X11/extensions/Xrandr.h>
-#include "vulkan_xlib_xrandr.h"
-#endif
-
-
-#ifdef VK_USE_PLATFORM_GGP
-#include <ggp_c/vulkan_types.h>
-#include "vulkan_ggp.h"
-#endif
-
-#endif // VULKAN_H_

include/vulkan/vulkan_win32.h

@@ -1,328 +0,0 @@
-#ifndef VULKAN_WIN32_H_
-#define VULKAN_WIN32_H_ 1
-
-/*
-** Copyright (c) 2015-2019 The Khronos Group Inc.
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-/*
-** This header is generated from the Khronos Vulkan XML API Registry.
-**
-*/
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-#define VK_KHR_win32_surface 1
-#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
-#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
-typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
-typedef struct VkWin32SurfaceCreateInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkWin32SurfaceCreateFlagsKHR    flags;
-    HINSTANCE                       hinstance;
-    HWND                            hwnd;
-} VkWin32SurfaceCreateInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
-    VkInstance                                  instance,
-    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex);
-#endif
-
-
-#define VK_KHR_external_memory_win32 1
-#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
-typedef struct VkImportMemoryWin32HandleInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkExternalMemoryHandleTypeFlagBits    handleType;
-    HANDLE                                handle;
-    LPCWSTR                               name;
-} VkImportMemoryWin32HandleInfoKHR;
-
-typedef struct VkExportMemoryWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportMemoryWin32HandleInfoKHR;
-
-typedef struct VkMemoryWin32HandlePropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           memoryTypeBits;
-} VkMemoryWin32HandlePropertiesKHR;
-
-typedef struct VkMemoryGetWin32HandleInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkDeviceMemory                        memory;
-    VkExternalMemoryHandleTypeFlagBits    handleType;
-} VkMemoryGetWin32HandleInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
-    VkDevice                                    device,
-    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBits          handleType,
-    HANDLE                                      handle,
-    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
-#endif
-
-
-#define VK_KHR_win32_keyed_mutex 1
-#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
-#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
-typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 acquireCount;
-    const VkDeviceMemory*    pAcquireSyncs;
-    const uint64_t*          pAcquireKeys;
-    const uint32_t*          pAcquireTimeouts;
-    uint32_t                 releaseCount;
-    const VkDeviceMemory*    pReleaseSyncs;
-    const uint64_t*          pReleaseKeys;
-} VkWin32KeyedMutexAcquireReleaseInfoKHR;
-
-
-
-#define VK_KHR_external_semaphore_win32 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
-typedef struct VkImportSemaphoreWin32HandleInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkSemaphore                              semaphore;
-    VkSemaphoreImportFlags                   flags;
-    VkExternalSemaphoreHandleTypeFlagBits    handleType;
-    HANDLE                                   handle;
-    LPCWSTR                                  name;
-} VkImportSemaphoreWin32HandleInfoKHR;
-
-typedef struct VkExportSemaphoreWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportSemaphoreWin32HandleInfoKHR;
-
-typedef struct VkD3D12FenceSubmitInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           waitSemaphoreValuesCount;
-    const uint64_t*    pWaitSemaphoreValues;
-    uint32_t           signalSemaphoreValuesCount;
-    const uint64_t*    pSignalSemaphoreValues;
-} VkD3D12FenceSubmitInfoKHR;
-
-typedef struct VkSemaphoreGetWin32HandleInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkSemaphore                              semaphore;
-    VkExternalSemaphoreHandleTypeFlagBits    handleType;
-} VkSemaphoreGetWin32HandleInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-#endif
-
-
-#define VK_KHR_external_fence_win32 1
-#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
-typedef struct VkImportFenceWin32HandleInfoKHR {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkFence                              fence;
-    VkFenceImportFlags                   flags;
-    VkExternalFenceHandleTypeFlagBits    handleType;
-    HANDLE                               handle;
-    LPCWSTR                              name;
-} VkImportFenceWin32HandleInfoKHR;
-
-typedef struct VkExportFenceWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportFenceWin32HandleInfoKHR;
-
-typedef struct VkFenceGetWin32HandleInfoKHR {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkFence                              fence;
-    VkExternalFenceHandleTypeFlagBits    handleType;
-} VkFenceGetWin32HandleInfoKHR;
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-#endif
-
-
-#define VK_NV_external_memory_win32 1
-#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
-#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
-typedef struct VkImportMemoryWin32HandleInfoNV {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkExternalMemoryHandleTypeFlagsNV    handleType;
-    HANDLE                               handle;
-} VkImportMemoryWin32HandleInfoNV;
-
-typedef struct VkExportMemoryWin32HandleInfoNV {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-} VkExportMemoryWin32HandleInfoNV;
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    VkExternalMemoryHandleTypeFlagsNV           handleType,
-    HANDLE*                                     pHandle);
-#endif
-
-
-#define VK_NV_win32_keyed_mutex 1
-#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
-#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
-typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 acquireCount;
-    const VkDeviceMemory*    pAcquireSyncs;
-    const uint64_t*          pAcquireKeys;
-    const uint32_t*          pAcquireTimeoutMilliseconds;
-    uint32_t                 releaseCount;
-    const VkDeviceMemory*    pReleaseSyncs;
-    const uint64_t*          pReleaseKeys;
-} VkWin32KeyedMutexAcquireReleaseInfoNV;
-
-
-
-#define VK_EXT_full_screen_exclusive 1
-#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
-#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
-
-typedef enum VkFullScreenExclusiveEXT {
-    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
-    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
-    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
-    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
-    VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
-    VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT,
-    VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = (VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1),
-    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkFullScreenExclusiveEXT;
-typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
-    VkStructureType             sType;
-    void*                       pNext;
-    VkFullScreenExclusiveEXT    fullScreenExclusive;
-} VkSurfaceFullScreenExclusiveInfoEXT;
-
-typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           fullScreenExclusiveSupported;
-} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
-
-typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    HMONITOR           hmonitor;
-} VkSurfaceFullScreenExclusiveWin32InfoEXT;
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
-typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
-typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
-    uint32_t*                                   pPresentModeCount,
-    VkPresentModeKHR*                           pPresentModes);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
-    VkDevice                                    device,
-    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
-    VkDeviceGroupPresentModeFlagsKHR*           pModes);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

lib/libd3dcompiler_43.def

@@ -1,17 +0,0 @@
-; File generated automatically from d3dcompiler_43.spec; do not edit!
-
-LIBRARY d3dcompiler_43.dll
-
-EXPORTS
-  D3DAssemble @1
-  D3DCompile @3
-  D3DCreateBlob @5
-  D3DDisassemble @8
-  D3DGetBlobPart @9
-  D3DGetDebugInfo @10
-  D3DGetInputAndOutputSignatureBlob @11
-  D3DGetInputSignatureBlob @12
-  D3DGetOutputSignatureBlob @13
-  D3DPreprocess @14
-  D3DReflect @15
-  D3DStripShader @17

lib32/libd3dcompiler_43.def

@@ -1,17 +0,0 @@
-; File generated automatically from d3dcompiler_43.spec; do not edit!
-
-LIBRARY d3dcompiler_43.dll
-
-EXPORTS
-  D3DAssemble@32 @1
-  D3DCompile@44 @3
-  D3DCreateBlob@8 @5
-  D3DDisassemble@20 @8
-  D3DGetBlobPart@20 @9
-  D3DGetDebugInfo@12 @10
-  D3DGetInputAndOutputSignatureBlob@12 @11
-  D3DGetInputSignatureBlob@12 @12
-  D3DGetOutputSignatureBlob@12 @13
-  D3DPreprocess@28 @14
-  D3DReflect@16 @15
-  D3DStripShader@16 @17

meson.build

@@ -1,109 +1,221 @@
-project('dxvk', ['c', 'cpp'], version : 'v1.7.3', meson_version : '>= 0.46')
+project('dxvk', ['c', 'cpp'], version : '2.5.3', meson_version : '>= 0.58', default_options : [ 'cpp_std=c++17', 'b_vscrt=static_from_buildtype', 'warning_level=2' ])
 
+pkg = import('pkgconfig')
 cpu_family = target_machine.cpu_family()
+platform   = target_machine.system()
+fs = import('fs')
 
-add_project_arguments('-DNOMINMAX', language : 'cpp')
+cpp = meson.get_compiler('cpp')
+cc = meson.get_compiler('c')
+dxvk_is_msvc = cpp.get_argument_syntax() == 'msvc'
 
-dxvk_compiler = meson.get_compiler('cpp')
-dxvk_msvc=dxvk_compiler.get_id() == 'msvc'
-# c++17 was added in 15.3, older version needs c++latest
-if dxvk_compiler.get_id() == 'msvc' and dxvk_compiler.version().version_compare('<15.3')
-  dxvk_cpp_std='c++latest'
-else
-  dxvk_cpp_std='c++17'
+compiler_args = [
+  '-msse',
+  '-msse2',
+  '-msse3',
+  '-mfpmath=sse',
+  '-Wimplicit-fallthrough',
+  # gcc
+  '-Wno-missing-field-initializers',
+  '-Wno-unused-parameter',
+  '-Wno-misleading-indentation',
+  '-Wno-cast-function-type', # Needed for GetProcAddress.
+  # clang
+  '-Wno-unused-private-field',
+  '-Wno-microsoft-exception-spec',
+  '-Wno-extern-c-compat',
+  '-Wno-unused-const-variable',
+  '-Wno-missing-braces',
+]
+
+link_args = []
+
+if get_option('build_id')
+  link_args += [
+    '-Wl,--build-id',
+  ]
 endif
 
-if dxvk_compiler.get_id() == 'msvc'
-  add_project_arguments('/std:' + dxvk_cpp_std, language : 'cpp')
+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
 
-if dxvk_compiler.get_id() == 'clang'
-  if dxvk_compiler.has_argument('-Wno-unused-private-field')
-    add_project_arguments('-Wno-unused-private-field', language: 'cpp')
-  endif
-  if dxvk_compiler.has_argument('-Wno-microsoft-exception-spec')
-    add_project_arguments('-Wno-microsoft-exception-spec', language: 'cpp')
-  endif
-endif
+dep_displayinfo = dependency(
+  'libdisplay-info',
+  version: ['>= 0.0.0', '< 0.2.0'],
+  fallback: ['libdisplay-info', 'di_dep'],
+  default_options: ['default_library=static'],
+)
 
-dxvk_include_path = include_directories('./include')
+if platform == 'windows'
+  dxvk_so_version = {'name_prefix': ''}
 
-if (cpu_family == 'x86_64')
-  dxvk_library_path = meson.source_root() + '/lib'
-else
-  dxvk_library_path = meson.source_root() + '/lib32'
-endif
+  compiler_args += [
+    '-DNOMINMAX',
+    '-D_WIN32_WINNT=0xa00',
+  ]
 
-dxvk_extradep = [ ]
+  if not dxvk_is_msvc
+    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',
+    ]
 
-if dxvk_compiler.get_id() == 'msvc'
-  wrc = find_program('rc')
-else
-  if cpu_family == 'x86_64'
-    wrc = find_program('x86_64-w64-mingw32-windres')
-  elif cpu_family == 'x86'
-    wrc = find_program('i686-w64-mingw32-windres')
+    # Wine's built-in back traces only work with dwarf4 symbols
+    if get_option('debug')
+      compiler_args += [
+        '-gdwarf-4',
+      ]
+    endif
+
+    if cpu_family == 'x86'
+      # Enable stdcall fixup on 32-bit
+      link_args += [
+        '-Wl,--enable-stdcall-fixup',
+        '-Wl,--kill-at',
+      ]
+      # Fix stack alignment issues with mingw on 32-bit
+      compiler_args += [
+        '-mpreferred-stack-boundary=2'
+      ]
+    endif
   else
-    error('Unsupported target architecture')
+    # setup file alignment + enable PDB output for MSVC builds
+    # PDBs are useful for Windows consumers of DXVK 
+    compiler_args += [
+      '/Z7'
+    ]
+    link_args += [
+      '/FILEALIGN:4096',
+      '/DEBUG:FULL'
+    ]
   endif
-endif
 
-if cpu_family == 'x86'
-  if dxvk_compiler.has_link_argument('-Wl,--add-stdcall-alias')
-    add_global_link_arguments('-Wl,--add-stdcall-alias', language: 'cpp')
+  lib_d3d9    = cpp.find_library('d3d9')
+  lib_d3d11   = cpp.find_library('d3d11')
+  lib_dxgi    = cpp.find_library('dxgi')
+
+  if dxvk_is_msvc
+    res_ext = '.res'
+    wrc = find_program('rc')
+    wrc_generator = generator(wrc,
+      output    : [ '@BASENAME@' + res_ext ],
+      arguments : [ '/fo', '@OUTPUT@', '@INPUT@' ],
+    )
+  else
+    res_ext = '.o'
+    wrc = find_program('windres')
+    wrc_generator = generator(wrc,
+      output    : [ '@BASENAME@' + res_ext ],
+      arguments : [ '-i', '@INPUT@', '-o', '@OUTPUT@' ],
+    )
   endif
-  if dxvk_compiler.has_link_argument('-Wl,--enable-stdcall-fixup')
-    add_global_link_arguments('-Wl,--enable-stdcall-fixup', language: 'cpp')
-  endif
-endif
 
-lib_vulkan  = dxvk_compiler.find_library('vulkan-1', dirs : dxvk_library_path)
-lib_d3d9    = dxvk_compiler.find_library('d3d9')
-lib_d3d11   = dxvk_compiler.find_library('d3d11')
-lib_dxgi    = dxvk_compiler.find_library('dxgi')
-lib_d3dcompiler_43 = dxvk_compiler.find_library('d3dcompiler_43', dirs : dxvk_library_path)
-
-if dxvk_compiler.get_id() == 'msvc'
-  lib_d3dcompiler_47 = dxvk_compiler.find_library('d3dcompiler')
+  dxvk_name_prefix = ''
+  compiler_args += ['-DDXVK_WSI_WIN32']
 else
-  lib_d3dcompiler_47 = dxvk_compiler.find_library('d3dcompiler_47')
+  dxvk_abi_version = '0'
+  dxvk_version_raw = meson.project_version().strip('v').split('.')
+  dxvk_version = [ dxvk_version_raw[0] ]
+  foreach i : [ 1, 2 ]
+    padded = dxvk_version_raw[i]
+    if padded.to_int() < 10
+      padded = '0' + padded
+    endif
+    dxvk_version += [ padded ]
+  endforeach
+  dxvk_so_version = {'version': dxvk_abi_version + '.' + dxvk_version[0] + dxvk_version[1] + dxvk_version[2]}
+
+  wrc           = find_program('touch')
+  wrc_generator = generator(wrc, output : [ '@BASENAME@_ignored.h' ], arguments : [ '@OUTPUT@' ] )
+
+  dxvk_include_dirs += [
+    './include/native',
+    './include/native/windows',
+    './include/native/directx'
+  ]
+
+  lib_sdl3 = dependency('SDL3', required: false)
+  lib_sdl2 = dependency('SDL2', required: false)
+  lib_glfw = dependency('glfw', required: false)
+  if lib_sdl3.found()
+    compiler_args += ['-DDXVK_WSI_SDL3']
+  endif
+  if lib_sdl2.found()
+    compiler_args += ['-DDXVK_WSI_SDL2']
+  endif
+  if lib_glfw.found()
+    compiler_args += ['-DDXVK_WSI_GLFW']
+  endif
+  if (not lib_sdl3.found() and not lib_sdl2.found() and not lib_glfw.found())
+    error('SDL3, SDL2, or GLFW are required to build dxvk-native')
+  endif
+  
+  dxvk_name_prefix = 'dxvk_'
+  dxvk_pkg_prefix = 'dxvk-'
+
+  link_args += [
+    '-static-libgcc',
+    '-static-libstdc++',
+  ]
 endif
 
+dxvk_include_path = include_directories(dxvk_include_dirs)
+
+add_project_arguments(cpp.get_supported_arguments(compiler_args), language: 'cpp')
+add_project_arguments(cc.get_supported_arguments(compiler_args), language: 'c')
+add_project_link_arguments(cpp.get_supported_link_arguments(link_args), language: 'cpp')
+add_project_link_arguments(cc.get_supported_link_arguments(link_args), language: 'c')
+
 exe_ext = ''
-dll_ext = ''
-
-if dxvk_compiler.get_id() == 'msvc'
-  res_ext = '.res'
-else
-  res_ext = '.o'
-endif
-
 def_spec_ext = '.def'
 
-glsl_compiler = find_program('glslangValidator')
-glsl_generator = generator(glsl_compiler,
+glsl_compiler = find_program('glslang', 'glslangValidator')
+glsl_args = [
+  '--quiet',
+  '--target-env', 'vulkan1.3',
+  '--vn', '@BASENAME@',
+  '--depfile', '@DEPFILE@',
+  '@INPUT@',
+  '-o', '@OUTPUT@',
+]
+glsl_generator = generator(
+  glsl_compiler,
   output    : [ '@BASENAME@.h' ],
-  arguments : [ '-V', '--vn', '@BASENAME@', '@INPUT@', '-o', '@OUTPUT@' ])
-
-if dxvk_compiler.get_id() == 'msvc'
-  wrc_generator = generator(wrc,
-  output    : [ '@BASENAME@' + res_ext ],
-  arguments : [ '/fo', '@OUTPUT@', '@INPUT@' ])
-else
-  wrc_generator = generator(wrc,
-  output    : [ '@BASENAME@' + res_ext ],
-  arguments : [ '-i', '@INPUT@', '-o', '@OUTPUT@' ])
-endif
+  depfile   : '@BASENAME@.h.d',
+  arguments : glsl_args,
+)
 
 dxvk_version = vcs_tag(
   command: ['git', 'describe', '--dirty=+'],
   input:  'version.h.in',
-  output: 'version.h')
+  output: 'version.h',
+)
+
+conf_data = configuration_data()
+conf_data.set('BUILD_COMPILER', cpp.get_id())
+conf_data.set('BUILD_COMPILER_VERSION', cpp.version())
+conf_data.set('BUILD_TARGET', cpu_family)
+dxvk_buildenv = configure_file(
+  configuration : conf_data,
+  input:  'buildenv.h.in',
+  output: 'buildenv.h',
+)
+
+if platform != 'windows'
+  subdir('include/native')
+endif
 
 subdir('src')
-
-enable_tests = get_option('enable_tests')
-
-if enable_tests
-  subdir('tests')
-endif

meson_options.txt

@@ -1,5 +1,8 @@
-option('enable_tests', type : 'boolean', value : false)
 option('enable_dxgi',  type : 'boolean', value : true, description: 'Build DXGI')
+option('enable_d3d8',  type : 'boolean', value : true, description: 'Build D3D8')
 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

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+
+set -e
+
+shopt -s extglob
+
+if [ -z "$1" ] || [ -z "$2" ]; then
+  echo "Usage: $0 version destdir [--no-package] [--dev-build]"
+  exit 1
+fi
+
+DXVK_VERSION="$1"
+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"
+
+if [ -e "$DXVK_BUILD_DIR" ]; then
+  echo "Build directory $DXVK_BUILD_DIR already exists"
+  exit 1
+fi
+
+shift 2
+
+opt_nopackage=0
+opt_devbuild=0
+opt_buildid=false
+opt_64_only=0
+opt_32_only=0
+
+CC=${CC:="gcc"}
+CXX=${CXX:="g++"}
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+  "--no-package")
+    opt_nopackage=1
+    ;;
+  "--dev-build")
+    opt_nopackage=1
+    opt_devbuild=1
+    ;;
+  "--build-id")
+    opt_buildid=true
+    ;;
+  "--64-only")
+    opt_64_only=1
+    ;;
+  "--32-only")
+    opt_32_only=1
+    ;;
+  *)
+    echo "Unrecognized option: $1" >&2
+    exit 1
+  esac
+  shift
+done
+
+function build_arch {  
+  cd "$DXVK_SRC_DIR"
+
+  opt_strip=
+  if [ $opt_devbuild -eq 0 ]; then
+    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              \
+        --force-fallback-for=libdisplay-info \
+        "$DXVK_BUILD_DIR/build.$1"
+
+  cd "$DXVK_BUILD_DIR/build.$1"
+  ninja install
+
+  if [ $opt_devbuild -eq 0 ]; then
+    rm -r "$DXVK_BUILD_DIR/build.$1"
+  fi
+}
+
+function package {
+  cd "$DXVK_BUILD_DIR"
+  tar -czf "$DXVK_ARCHIVE_PATH" "usr"
+  cd ".."
+  rm -R "dxvk-native-$DXVK_VERSION"
+}
+
+if [ $opt_32_only -eq 0 ]; then
+  build_arch 64 lib
+fi
+if [ $opt_64_only -eq 0 ]; then
+  build_arch 32 lib32
+fi
+
+if [ $opt_nopackage -eq 0 ]; then
+  package
+fi

package-release.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 set -e
 
@@ -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"
 
@@ -23,6 +24,9 @@ shift 2
 
 opt_nopackage=0
 opt_devbuild=0
+opt_buildid=false
+opt_64_only=0
+opt_32_only=0
 
 crossfile="build-win"
 
@@ -35,6 +39,15 @@ while [ $# -gt 0 ]; do
     opt_nopackage=1
     opt_devbuild=1
     ;;
+  "--build-id")
+    opt_buildid=true
+    ;;
+  "--64-only")
+    opt_64_only=1
+    ;;
+  "--32-only")
+    opt_32_only=1
+    ;;
   *)
     echo "Unrecognized option: $1" >&2
     exit 1
@@ -48,13 +61,19 @@ function build_arch {
   
   cd "$DXVK_SRC_DIR"
 
-  meson --cross-file "$DXVK_SRC_DIR/$crossfile$1.txt" \
-        --buildtype "release"                         \
-        --prefix "$DXVK_BUILD_DIR"                    \
-        --strip                                       \
-        --bindir "x$1"                                \
-        --libdir "x$1"                                \
-        -Denable_tests=false                          \
+  opt_strip=
+  if [ $opt_devbuild -eq 0 ]; then
+    opt_strip=--strip
+  fi
+
+  meson setup --cross-file "$DXVK_SRC_DIR/$crossfile$1.txt" \
+        --buildtype "release"                               \
+        --prefix "$DXVK_BUILD_DIR"                          \
+        $opt_strip                                          \
+        --bindir "x$1"                                      \
+        --libdir "x$1"                                      \
+        -Db_ndebug=if-release                               \
+        -Dbuild_id=$opt_buildid                             \
         "$DXVK_BUILD_DIR/build.$1"
 
   cd "$DXVK_BUILD_DIR/build.$1"
@@ -67,20 +86,18 @@ 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"
   rm -R "dxvk-$DXVK_VERSION"
 }
 
-build_arch 64
-build_arch 32
-build_script
+if [ $opt_32_only -eq 0 ]; then
+  build_arch 64
+fi
+if [ $opt_64_only -eq 0 ]; then
+  build_arch 32
+fi
 
 if [ $opt_nopackage -eq 0 ]; then
   package

setup_dxvk.sh

@@ -1,213 +0,0 @@
-#!/bin/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] [--with-d3d10] [--symlink]"
-  exit 1
-esac
-
-# process arguments
-shift
-
-with_dxgi=true
-with_d3d10=false
-file_cmd="cp -v"
-
-while (($# > 0)); do
-  case "$1" in
-  "--without-dxgi")
-    with_dxgi=false
-    ;;
-  "--with-d3d10")
-    with_d3d10=true
-    ;;
-  "--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
-
-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
-
-if $with_d3d10 || [ "$action" == "uninstall" ]; then
-  $action d3d10
-  $action d3d10_1
-fi
-
-$action d3d10core
-$action d3d11

src/d3d10/d3d10.def

@@ -1,29 +0,0 @@
-LIBRARY D3D10.DLL
-EXPORTS  
-    D3D10CreateDevice
-    D3D10CreateDeviceAndSwapChain
-    D3D10GetVertexShaderProfile
-    D3D10GetGeometryShaderProfile
-    D3D10GetPixelShaderProfile
-    D3D10CreateBlob
-    D3D10GetInputSignatureBlob
-    D3D10GetOutputSignatureBlob
-    D3D10ReflectShader
-    D3D10CompileShader
-    D3D10CreateEffectFromMemory
-    D3D10CreateEffectPoolFromMemory
-    D3D10CompileEffectFromMemory
-    D3D10DisassembleEffect
-    D3D10DisassembleShader
-    D3D10PreprocessShader
-    D3D10CreateStateBlock
-    D3D10StateBlockMaskDifference
-    D3D10StateBlockMaskDisableAll
-    D3D10StateBlockMaskDisableCapture
-    D3D10StateBlockMaskEnableAll
-    D3D10StateBlockMaskEnableCapture
-    D3D10StateBlockMaskGetSetting
-    D3D10StateBlockMaskIntersect
-    D3D10StateBlockMaskUnion
-    D3D10GetVersion
-    D3D10RegisterLayers

src/d3d10/d3d10_1.def

@@ -1,29 +0,0 @@
-LIBRARY D3D10_1.DLL
-EXPORTS  
-    D3D10CreateDevice1
-    D3D10CreateDeviceAndSwapChain1
-    D3D10GetVertexShaderProfile
-    D3D10GetGeometryShaderProfile
-    D3D10GetPixelShaderProfile
-    D3D10CreateBlob
-    D3D10GetInputSignatureBlob
-    D3D10GetOutputSignatureBlob
-    D3D10ReflectShader
-    D3D10CompileShader
-    D3D10CreateEffectFromMemory
-    D3D10CreateEffectPoolFromMemory
-    D3D10CompileEffectFromMemory
-    D3D10DisassembleEffect
-    D3D10DisassembleShader
-    D3D10PreprocessShader
-    D3D10CreateStateBlock
-    D3D10StateBlockMaskDifference
-    D3D10StateBlockMaskDisableAll
-    D3D10StateBlockMaskDisableCapture
-    D3D10StateBlockMaskEnableAll
-    D3D10StateBlockMaskEnableCapture
-    D3D10StateBlockMaskGetSetting
-    D3D10StateBlockMaskIntersect
-    D3D10StateBlockMaskUnion
-    D3D10GetVersion
-    D3D10RegisterLayers

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/d3d10_device.cpp

@@ -705,10 +705,7 @@ namespace dxvk {
           HANDLE                            hResource,
           REFIID                            ReturnedInterface,
           void**                            ppResource) {
-    InitReturnPtr(ppResource);
-    
-    Logger::err("D3D10Device::OpenSharedResource: Not implemented");
-    return E_NOTIMPL;
+    return m_device->OpenSharedResource(hResource, ReturnedInterface, ppResource);
   }
 
 

src/d3d10/d3d10_interfaces.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include "d3d10_include.h"
-
-#ifdef _MSC_VER
-struct __declspec(uuid("0803425a-57f5-4dd6-9465-a87570834a08")) ID3D10StateBlock;
-#else
-__CRT_UUID_DECL(ID3D10StateBlock, 0x0803425a,0x57f5,0x4dd6,0x94,0x65,0xa8,0x75,0x70,0x83,0x4a,0x08);
-#endif

src/d3d10/d3d10_main.cpp

@@ -1,335 +0,0 @@
-#include <d3dcompiler.h>
-
-#include "d3d10_include.h"
-#include "d3d10_reflection.h"
-
-#include "../dxgi/dxgi_adapter.h"
-
-namespace dxvk {
-  Logger Logger::s_instance("d3d10.log");
-}
-
-extern "C" {
-  using namespace dxvk;
-
-  HRESULT __stdcall D3D10CoreCreateDevice(
-          IDXGIFactory*           pFactory,
-          IDXGIAdapter*           pAdapter,
-          UINT                    Flags,
-          D3D_FEATURE_LEVEL       FeatureLevel,
-          ID3D10Device**          ppDevice);
-
-  static HRESULT D3D10InternalCreateDeviceAndSwapChain(
-          IDXGIAdapter*           pAdapter,
-          D3D10_DRIVER_TYPE       DriverType,
-          HMODULE                 Software,
-          UINT                    Flags,
-          D3D10_FEATURE_LEVEL1    HardwareLevel,
-          UINT                    SDKVersion,
-          DXGI_SWAP_CHAIN_DESC*   pSwapChainDesc,
-          IDXGISwapChain**        ppSwapChain,
-          REFIID                  deviceIID,
-          void**                  ppDevice) {
-    InitReturnPtr(ppDevice);
-    InitReturnPtr(ppSwapChain);
-
-    if (ppSwapChain && !pSwapChainDesc)
-      return E_INVALIDARG;
-    
-    HRESULT hr;
-    
-    // Get DXGI factory and adapter. This is mostly
-    // copied from the equivalent D3D11 functions.
-    Com<IDXGIFactory> dxgiFactory = nullptr;
-    Com<IDXGIAdapter> dxgiAdapter = pAdapter;
-    Com<ID3D10Device> device      = nullptr;
-    
-    if (!pAdapter) {
-      if (DriverType != D3D10_DRIVER_TYPE_HARDWARE)
-        Logger::warn("D3D10CreateDevice: Unsupported driver type");
-      
-      hr = CreateDXGIFactory(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&dxgiFactory));
-
-      if (FAILED(hr)) {
-        Logger::err("D3D10CreateDevice: Failed to create a DXGI factory");
-        return hr;
-      }
-
-      hr = dxgiFactory->EnumAdapters(0, &dxgiAdapter);
-
-      if (FAILED(hr)) {
-        Logger::err("D3D10CreateDevice: No default adapter available");
-        return hr;
-      }
-    } else {
-      if (FAILED(dxgiAdapter->GetParent(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&dxgiFactory)))) {
-        Logger::err("D3D10CreateDevice: Failed to query DXGI factory from DXGI adapter");
-        return E_INVALIDARG;
-      }
-      
-      if (DriverType != D3D10_DRIVER_TYPE_HARDWARE || Software)
-        return E_INVALIDARG;
-    }
-
-    hr = D3D10CoreCreateDevice(
-      dxgiFactory.ptr(), dxgiAdapter.ptr(),
-      Flags, D3D_FEATURE_LEVEL(HardwareLevel),
-      &device);
-    
-    if (FAILED(hr))
-      return hr;
-    
-    if (ppSwapChain) {
-      DXGI_SWAP_CHAIN_DESC desc = *pSwapChainDesc;
-      hr = dxgiFactory->CreateSwapChain(device.ptr(), &desc, ppSwapChain);
-
-      if (FAILED(hr)) {
-        Logger::err("D3D10CreateDevice: Failed to create swap chain");
-        return hr;
-      }
-    }
-
-    if (ppDevice) {
-      // Just assume that this succeeds
-      device->QueryInterface(deviceIID, ppDevice);
-    }
-    
-    if (!ppDevice && !ppSwapChain)
-      return S_FALSE;
-    
-    return S_OK;
-  }
-
-
-  DLLEXPORT HRESULT __stdcall D3D10CreateDevice(
-          IDXGIAdapter*           pAdapter,
-          D3D10_DRIVER_TYPE       DriverType,
-          HMODULE                 Software,
-          UINT                    Flags,
-          UINT                    SDKVersion,
-          ID3D10Device**          ppDevice) {
-    return D3D10InternalCreateDeviceAndSwapChain(
-      pAdapter, DriverType, Software, Flags,
-      D3D10_FEATURE_LEVEL_10_0, SDKVersion,
-      nullptr, nullptr,
-      __uuidof(ID3D10Device),
-      reinterpret_cast<void**>(ppDevice));
-  }
-
-
-  DLLEXPORT HRESULT __stdcall D3D10CreateDevice1(
-          IDXGIAdapter*           pAdapter,
-          D3D10_DRIVER_TYPE       DriverType,
-          HMODULE                 Software,
-          UINT                    Flags,
-          D3D10_FEATURE_LEVEL1    HardwareLevel,
-          UINT                    SDKVersion,
-          ID3D10Device1**         ppDevice) {
-    return D3D10InternalCreateDeviceAndSwapChain(
-      pAdapter, DriverType, Software, Flags,
-      HardwareLevel, SDKVersion,
-      nullptr, nullptr,
-      __uuidof(ID3D10Device1),
-      reinterpret_cast<void**>(ppDevice));
-  }
-
-
-  DLLEXPORT HRESULT __stdcall D3D10CreateDeviceAndSwapChain(
-          IDXGIAdapter*           pAdapter,
-          D3D10_DRIVER_TYPE       DriverType,
-          HMODULE                 Software,
-          UINT                    Flags,
-          UINT                    SDKVersion,
-          DXGI_SWAP_CHAIN_DESC*   pSwapChainDesc,
-          IDXGISwapChain**        ppSwapChain,
-          ID3D10Device**          ppDevice) {
-    return D3D10InternalCreateDeviceAndSwapChain(
-      pAdapter, DriverType, Software, Flags,
-      D3D10_FEATURE_LEVEL_10_0, SDKVersion,
-      pSwapChainDesc, ppSwapChain,
-      __uuidof(ID3D10Device),
-      reinterpret_cast<void**>(ppDevice));
-  }
-
-
-  DLLEXPORT HRESULT __stdcall D3D10CreateDeviceAndSwapChain1(
-          IDXGIAdapter*           pAdapter,
-          D3D10_DRIVER_TYPE       DriverType,
-          HMODULE                 Software,
-          UINT                    Flags,
-          D3D10_FEATURE_LEVEL1    HardwareLevel,
-          UINT                    SDKVersion,
-          DXGI_SWAP_CHAIN_DESC*   pSwapChainDesc,
-          IDXGISwapChain**        ppSwapChain,
-          ID3D10Device1**         ppDevice) {
-    return D3D10InternalCreateDeviceAndSwapChain(
-      pAdapter, DriverType, Software, Flags,
-      HardwareLevel, SDKVersion,
-      pSwapChainDesc, ppSwapChain,
-      __uuidof(ID3D10Device1),
-      reinterpret_cast<void**>(ppDevice));
-  }
-
-
-  const char* STDMETHODCALLTYPE D3D10GetVertexShaderProfile   (ID3D10Device*) { return "vs_4_1"; }
-  const char* STDMETHODCALLTYPE D3D10GetGeometryShaderProfile (ID3D10Device*) { return "gs_4_1"; }
-  const char* STDMETHODCALLTYPE D3D10GetPixelShaderProfile    (ID3D10Device*) { return "ps_4_1"; }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10CreateBlob(SIZE_T size, LPD3D10BLOB* ppBuffer) {
-    return D3DCreateBlob(size, ppBuffer);
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10GetInputSignatureBlob(
-    const void*                     pShaderBytecode,
-          SIZE_T                    BytecodeLength,
-          ID3D10Blob**              ppSignatureBlob) {
-    return D3DGetInputSignatureBlob(
-      pShaderBytecode,
-      BytecodeLength,
-      ppSignatureBlob);
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10GetOutputSignatureBlob(
-    const void*                     pShaderBytecode,
-          SIZE_T                    BytecodeLength,
-          ID3D10Blob**              ppSignatureBlob) {
-    return D3DGetOutputSignatureBlob(
-      pShaderBytecode,
-      BytecodeLength,
-      ppSignatureBlob);
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ReflectShader(
-    const void*                     pShaderBytecode,
-          SIZE_T                    BytecodeLength,
-          ID3D10ShaderReflection**  ppReflector) {
-    static const GUID IID_ID3D11ShaderReflection =
-      {0x0a233719,0x3960,0x4578,{0x9d,0x7c,0x20,0x3b,0x8b,0x1d,0x9c,0xc1}};
-    
-    InitReturnPtr(ppReflector);
-
-    Com<ID3D11ShaderReflection> d3d11Reflector = nullptr;
-    
-    HRESULT hr = D3DReflect(pShaderBytecode,
-      BytecodeLength, IID_ID3D11ShaderReflection,
-      reinterpret_cast<void**>(&d3d11Reflector));
-    
-    if (FAILED(hr)) {
-      Logger::err("D3D10ReflectShader: Failed to create ID3D11ShaderReflection");
-      return hr;
-    }
-    
-    *ppReflector = ref(new D3D10ShaderReflection(d3d11Reflector.ptr()));
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10CompileShader(
-          LPCSTR              pSrcData,
-          SIZE_T              SrcDataSize,
-          LPCSTR              pFileName,
-    const D3D10_SHADER_MACRO* pDefines,
-          LPD3D10INCLUDE      pInclude,
-          LPCSTR              pFunctionName,
-          LPCSTR              pProfile,
-          UINT                Flags,
-          ID3D10Blob**        ppShader,
-          ID3D10Blob**        ppErrorMsgs) {
-    return D3DCompile(pSrcData, SrcDataSize, pFileName,
-      pDefines, pInclude, pFunctionName, pProfile, Flags,
-      0, ppShader, ppErrorMsgs);
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10CreateEffectFromMemory(
-          void*               pData,
-          SIZE_T              DataSize,
-          UINT                EffectFlags,
-          ID3D10Device*       pDevice,
-          ID3D10EffectPool*   pEffectPool,
-          ID3D10Effect**      ppEffect) {
-    Logger::warn("D3D10CreateEffectFromMemory: Not implemented");
-    return E_NOTIMPL;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10CreateEffectPoolFromMemory(
-          void*               pData,
-          SIZE_T              DataSize,
-          UINT                EffectFlags,
-          ID3D10Device*       pDevice,
-          ID3D10EffectPool**  ppEffectPool) {
-    Logger::warn("D3D10CreateEffectPoolFromMemory: Not implemented");
-    return E_NOTIMPL;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10CompileEffectFromMemory(
-          void*               pData,
-          SIZE_T              DataLength,
-          LPCSTR              pSrcFileName,
-    const D3D10_SHADER_MACRO* pDefines,
-          ID3D10Include*      pInclude,
-          UINT                ShaderFlags,
-          UINT                EffectFlags,
-          ID3D10Blob**        ppCompiledEffect,
-          ID3D10Blob**        ppErrors) {
-    Logger::warn("D3D10CompileEffectFromMemory: Not implemented");
-    return E_NOTIMPL;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10DisassembleEffect(
-          ID3D10Effect*       pEffect,
-          BOOL                EnableColorCode,
-          ID3D10Blob**        ppDisassembly) {
-    Logger::warn("D3D10DisassembleEffect: Not implemented");
-    return E_NOTIMPL;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10DisassembleShader(
-    const void*               pShader,
-          SIZE_T              BytecodeLength,
-          BOOL                EnableColorCode,
-          LPCSTR              pComments,
-          ID3D10Blob**        ppDisassembly) {
-    return D3DDisassemble(
-      pShader, BytecodeLength,
-      0, pComments, ppDisassembly);
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10PreprocessShader(
-          LPCSTR              pSrcData,
-          SIZE_T              SrcDataSize,
-          LPCSTR              pFileName,
-    const D3D10_SHADER_MACRO* pDefines,
-          LPD3D10INCLUDE      pInclude,
-          ID3D10Blob**        ppShaderText,
-          ID3D10Blob**        ppErrorMsgs) {
-    return D3DPreprocess(
-      pSrcData, SrcDataSize,
-      pFileName, pDefines,
-      pInclude,
-      ppShaderText,
-      ppErrorMsgs);
-  }
-
-
-  UINT64 STDMETHODCALLTYPE D3D10GetVersion() {
-    return 0xa000100041770ull;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10RegisterLayers() {
-    return E_NOTIMPL;
-  }
-
-}
-
-

src/d3d10/d3d10_multithread.cpp

@@ -1,12 +1,17 @@
+#include <utility>
+
 #include "d3d10_device.h"
 
 namespace dxvk {
 
   D3D10Multithread::D3D10Multithread(
           IUnknown*             pParent,
-          BOOL                  Protected)
+          BOOL                  Protected,
+          BOOL                  Force)
   : m_parent    (pParent),
-    m_protected (Protected) {
+    m_protected (Protected || Force),
+    m_enabled   (Protected),
+    m_forced    (Force) {
     
   }
 
@@ -47,12 +52,18 @@ namespace dxvk {
 
   BOOL STDMETHODCALLTYPE D3D10Multithread::SetMultithreadProtected(
           BOOL                  bMTProtect) {
-    return std::exchange(m_protected, bMTProtect);
+    BOOL result = m_enabled;
+    m_enabled = bMTProtect;
+
+    if (!m_forced)
+      m_protected = m_enabled;
+
+    return result;
   }
 
 
   BOOL STDMETHODCALLTYPE D3D10Multithread::GetMultithreadProtected() {
-    return m_protected;
+    return m_enabled;
   }
 
-}
+}

src/d3d10/d3d10_multithread.h

@@ -64,7 +64,8 @@ namespace dxvk {
 
     D3D10Multithread(
             IUnknown*             pParent,
-            BOOL                  Protected);
+            BOOL                  Protected,
+            BOOL                  Force);
     
     ~D3D10Multithread();
 
@@ -95,6 +96,8 @@ namespace dxvk {
 
     IUnknown* m_parent;
     BOOL      m_protected;
+    BOOL      m_enabled;
+    BOOL      m_forced;
 
     sync::RecursiveSpinlock m_mutex;
 

src/d3d10/d3d10_query.h

@@ -6,7 +6,6 @@ namespace dxvk {
 
   class D3D10Device;
   class D3D11Device;
-  class D3D11DeviceContext;
   class D3D11Query;
 
   class D3D10Query : public ID3D10Predicate {

src/d3d10/d3d10_reflection.cpp

@@ -1,326 +0,0 @@
-#include "d3d10_reflection.h"
-
-namespace dxvk {
-
-  D3D10ShaderReflectionType::D3D10ShaderReflectionType(
-          ID3D11ShaderReflectionType*     d3d11)
-  : m_d3d11(d3d11) {
-
-  }
-
-  
-  D3D10ShaderReflectionType::~D3D10ShaderReflectionType() {
-
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionType::GetDesc(
-          D3D10_SHADER_TYPE_DESC*         pDesc) {
-    D3D11_SHADER_TYPE_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-    
-    pDesc->Class    = D3D10_SHADER_VARIABLE_CLASS(d3d11Desc.Class);
-    pDesc->Type     = D3D10_SHADER_VARIABLE_TYPE (d3d11Desc.Type);
-    pDesc->Rows     = d3d11Desc.Rows;
-    pDesc->Columns  = d3d11Desc.Columns;
-    pDesc->Elements = d3d11Desc.Elements;
-    pDesc->Members  = d3d11Desc.Members;
-    pDesc->Offset   = d3d11Desc.Offset;
-    return S_OK;
-  }
-
-  
-  ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeByIndex(
-          UINT                            Index) {
-    return FindMemberType(m_d3d11->GetMemberTypeByIndex(Index));
-  }
-
-  
-  ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeByName(
-    const char*                           Name) {
-    return FindMemberType(m_d3d11->GetMemberTypeByName(Name));
-  }
-
-  
-  const char* STDMETHODCALLTYPE D3D10ShaderReflectionType::GetMemberTypeName(
-          UINT                            Index) {
-    return m_d3d11->GetMemberTypeName(Index);
-  }
-
-
-  ID3D10ShaderReflectionType* D3D10ShaderReflectionType::FindMemberType(
-          ID3D11ShaderReflectionType*     pMemberType) {
-    if (!pMemberType)
-      return nullptr;
-
-    auto entry = m_members.find(pMemberType);
-
-    if (entry == m_members.end()) {
-      entry = m_members.insert({ pMemberType,
-        std::make_unique<D3D10ShaderReflectionType>(pMemberType) }).first;
-    }
-
-    return entry->second.get();
-  }
-
-  
-  D3D10ShaderReflectionVariable::D3D10ShaderReflectionVariable(ID3D11ShaderReflectionVariable* d3d11)
-  : m_d3d11(d3d11), m_type(m_d3d11->GetType()) {
-
-  }
-
-
-  D3D10ShaderReflectionVariable::~D3D10ShaderReflectionVariable() {
-
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionVariable::GetDesc(
-          D3D10_SHADER_VARIABLE_DESC*     pDesc) {
-    D3D11_SHADER_VARIABLE_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-
-    pDesc->Name         = d3d11Desc.Name;
-    pDesc->StartOffset  = d3d11Desc.StartOffset;
-    pDesc->Size         = d3d11Desc.Size;
-    pDesc->uFlags       = d3d11Desc.uFlags;
-    pDesc->DefaultValue = d3d11Desc.DefaultValue;
-    return S_OK;
-  }
-
-  
-  ID3D10ShaderReflectionType* STDMETHODCALLTYPE D3D10ShaderReflectionVariable::GetType() {
-    return &m_type;
-  }
-
-
-  D3D10ShaderReflectionConstantBuffer::D3D10ShaderReflectionConstantBuffer(
-          ID3D11ShaderReflectionConstantBuffer* d3d11)
-  : m_d3d11(d3d11) {
-
-  }
-
-  
-  D3D10ShaderReflectionConstantBuffer::~D3D10ShaderReflectionConstantBuffer() {
-
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetDesc(
-          D3D10_SHADER_BUFFER_DESC*       pDesc) {
-    D3D11_SHADER_BUFFER_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-    
-    pDesc->Name       = d3d11Desc.Name;
-    pDesc->Type       = D3D10_CBUFFER_TYPE(d3d11Desc.Type);
-    pDesc->Variables  = d3d11Desc.Variables;
-    pDesc->Size       = d3d11Desc.Size;
-    pDesc->uFlags     = d3d11Desc.uFlags;
-    return S_OK;
-  }
-
-
-  ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetVariableByIndex(
-          UINT                            Index) {
-    return FindVariable(m_d3d11->GetVariableByIndex(Index));
-  }
-
-  
-  ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE D3D10ShaderReflectionConstantBuffer::GetVariableByName(
-          LPCSTR                          Name) {
-    return FindVariable(m_d3d11->GetVariableByName(Name));
-  }
-
-
-  ID3D10ShaderReflectionVariable* D3D10ShaderReflectionConstantBuffer::FindVariable(
-          ID3D11ShaderReflectionVariable* pVariable) {
-    if (!pVariable)
-      return nullptr;
-
-    auto entry = m_variables.find(pVariable);
-
-    if (entry == m_variables.end()) {
-      entry = m_variables.emplace(
-        std::piecewise_construct,
-        std::forward_as_tuple(pVariable),
-        std::forward_as_tuple(pVariable)).first;
-    }
-
-    return &entry->second;
-  }
-
-
-  D3D10ShaderReflection::D3D10ShaderReflection(ID3D11ShaderReflection* d3d11)
-  : m_d3d11(d3d11) {
-
-  }
-
-
-  D3D10ShaderReflection::~D3D10ShaderReflection() {
-
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::QueryInterface(
-          REFIID              riid,
-          void**              ppvObject) {
-    if (ppvObject == nullptr)
-      return E_POINTER;
-
-    static const GUID IID_ID3D10ShaderReflection
-      = {0xd40e20b6,0xf8f7,0x42ad,{0xab,0x20,0x4b,0xaf,0x8f,0x15,0xdf,0xaa}};
-
-    if (riid == __uuidof(IUnknown)
-     || riid == IID_ID3D10ShaderReflection) {
-      *ppvObject = ref(this);
-      return S_OK;
-    }
-
-    return E_NOINTERFACE;
-  }
-
-  
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetDesc(
-          D3D10_SHADER_DESC*              pDesc) {
-    D3D11_SHADER_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetDesc(&d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-    
-    pDesc->Version                     = d3d11Desc.Version;
-    pDesc->Creator                     = d3d11Desc.Creator;
-    pDesc->Flags                       = d3d11Desc.Flags;
-    pDesc->ConstantBuffers             = d3d11Desc.ConstantBuffers;
-    pDesc->BoundResources              = d3d11Desc.BoundResources;
-    pDesc->InputParameters             = d3d11Desc.InputParameters;
-    pDesc->OutputParameters            = d3d11Desc.OutputParameters;
-    pDesc->InstructionCount            = d3d11Desc.InstructionCount;
-    pDesc->TempRegisterCount           = d3d11Desc.TempRegisterCount;
-    pDesc->TempArrayCount              = d3d11Desc.TempArrayCount;
-    pDesc->DefCount                    = d3d11Desc.DefCount;
-    pDesc->DclCount                    = d3d11Desc.DclCount;
-    pDesc->TextureNormalInstructions   = d3d11Desc.TextureNormalInstructions;
-    pDesc->TextureLoadInstructions     = d3d11Desc.TextureLoadInstructions;
-    pDesc->TextureCompInstructions     = d3d11Desc.TextureCompInstructions;
-    pDesc->TextureBiasInstructions     = d3d11Desc.TextureBiasInstructions;
-    pDesc->TextureGradientInstructions = d3d11Desc.TextureGradientInstructions;
-    pDesc->FloatInstructionCount       = d3d11Desc.FloatInstructionCount;
-    pDesc->IntInstructionCount         = d3d11Desc.IntInstructionCount;
-    pDesc->UintInstructionCount        = d3d11Desc.UintInstructionCount;
-    pDesc->StaticFlowControlCount      = d3d11Desc.StaticFlowControlCount;
-    pDesc->DynamicFlowControlCount     = d3d11Desc.DynamicFlowControlCount;
-    pDesc->MacroInstructionCount       = d3d11Desc.MacroInstructionCount;
-    pDesc->ArrayInstructionCount       = d3d11Desc.ArrayInstructionCount;
-    pDesc->CutInstructionCount         = d3d11Desc.CutInstructionCount;
-    pDesc->EmitInstructionCount        = d3d11Desc.EmitInstructionCount;
-    pDesc->GSOutputTopology            = D3D10_PRIMITIVE_TOPOLOGY(d3d11Desc.GSOutputTopology);
-    pDesc->GSMaxOutputVertexCount      = d3d11Desc.GSMaxOutputVertexCount;
-    return S_OK;
-  }
-
-  
-  ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE
-  D3D10ShaderReflection::GetConstantBufferByIndex(
-          UINT                            Index) {
-    return FindConstantBuffer(m_d3d11->GetConstantBufferByIndex(Index));
-  }
-
-
-  ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE
-  D3D10ShaderReflection::GetConstantBufferByName(
-          LPCSTR                          Name) {
-    return FindConstantBuffer(m_d3d11->GetConstantBufferByName(Name));
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetInputParameterDesc(
-          UINT                            ParameterIndex,
-          D3D10_SIGNATURE_PARAMETER_DESC* pDesc) {
-    D3D11_SIGNATURE_PARAMETER_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetInputParameterDesc(ParameterIndex, &d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-    
-    ConvertSignatureParameterDesc(&d3d11Desc, pDesc);
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetOutputParameterDesc(
-          UINT                            ParameterIndex,
-          D3D10_SIGNATURE_PARAMETER_DESC* pDesc) {
-    D3D11_SIGNATURE_PARAMETER_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetOutputParameterDesc(ParameterIndex, &d3d11Desc);
-
-    if (FAILED(hr))
-      return hr;
-    
-    ConvertSignatureParameterDesc(&d3d11Desc, pDesc);
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10ShaderReflection::GetResourceBindingDesc(
-          UINT                            ResourceIndex,
-          D3D10_SHADER_INPUT_BIND_DESC*   pDesc) {
-    D3D11_SHADER_INPUT_BIND_DESC d3d11Desc;
-    HRESULT hr = m_d3d11->GetResourceBindingDesc(
-      ResourceIndex, &d3d11Desc);
-    
-    if (FAILED(hr))
-      return hr;
-
-    pDesc->Name         = d3d11Desc.Name;
-    pDesc->Type         = D3D10_SHADER_INPUT_TYPE(d3d11Desc.Type);
-    pDesc->BindPoint    = d3d11Desc.BindPoint;
-    pDesc->BindCount    = d3d11Desc.BindCount;
-    pDesc->uFlags       = d3d11Desc.uFlags;
-    pDesc->ReturnType   = D3D10_RESOURCE_RETURN_TYPE(d3d11Desc.ReturnType);
-    pDesc->Dimension    = D3D10_SRV_DIMENSION       (d3d11Desc.Dimension);
-    pDesc->NumSamples   = d3d11Desc.NumSamples;
-    return S_OK;
-  }
-
-
-  ID3D10ShaderReflectionConstantBuffer* D3D10ShaderReflection::FindConstantBuffer(
-          ID3D11ShaderReflectionConstantBuffer* pConstantBuffer) {
-    if (!pConstantBuffer)
-      return nullptr;
-
-    auto entry = m_constantBuffers.find(pConstantBuffer);
-
-    if (entry == m_constantBuffers.end()) {
-      entry = m_constantBuffers.emplace(
-        std::piecewise_construct,
-        std::forward_as_tuple(pConstantBuffer),
-        std::forward_as_tuple(pConstantBuffer)).first;
-    }
-
-    return &entry->second;
-  }
-
-
-  void D3D10ShaderReflection::ConvertSignatureParameterDesc(
-    const D3D11_SIGNATURE_PARAMETER_DESC* pSrcDesc,
-          D3D10_SIGNATURE_PARAMETER_DESC* pDstDesc) {
-    pDstDesc->SemanticName        = pSrcDesc->SemanticName;
-    pDstDesc->SemanticIndex       = pSrcDesc->SemanticIndex;
-    pDstDesc->Register            = pSrcDesc->Register;
-    pDstDesc->SystemValueType     = D3D10_NAME(pSrcDesc->SystemValueType);
-    pDstDesc->ComponentType       = D3D10_REGISTER_COMPONENT_TYPE(pSrcDesc->ComponentType);
-    pDstDesc->Mask                = pSrcDesc->Mask;
-    pDstDesc->ReadWriteMask       = pSrcDesc->ReadWriteMask;
-  }
-
-}

src/d3d10/d3d10_reflection.h

@@ -1,163 +0,0 @@
-#pragma once
-
-#include <unordered_map>
-#include <vector>
-
-#include "d3d10_include.h"
-
-#include <d3d10shader.h>
-#include <d3d11shader.h>
-
-namespace dxvk {
-
-  class D3D10ShaderReflectionType : public ID3D10ShaderReflectionType {
-
-  public:
-
-    D3D10ShaderReflectionType(
-            ID3D11ShaderReflectionType*     d3d11);
-    
-    ~D3D10ShaderReflectionType();
-
-    HRESULT STDMETHODCALLTYPE GetDesc(
-            D3D10_SHADER_TYPE_DESC*         pDesc);
-    
-    ID3D10ShaderReflectionType* STDMETHODCALLTYPE GetMemberTypeByIndex(
-            UINT                            Index);
-    
-    ID3D10ShaderReflectionType* STDMETHODCALLTYPE GetMemberTypeByName(
-      const char*                           Name);
-    
-    const char* STDMETHODCALLTYPE GetMemberTypeName(
-            UINT                            Index);
-    
-    ID3D11ShaderReflectionType* GetD3D11Iface() {
-      return m_d3d11;
-    }
-  
-  private:
-
-    ID3D11ShaderReflectionType* m_d3d11;
-
-    std::unordered_map<
-      ID3D11ShaderReflectionType*,
-      std::unique_ptr<D3D10ShaderReflectionType>> m_members;
-
-    ID3D10ShaderReflectionType* FindMemberType(
-            ID3D11ShaderReflectionType*     pMemberType);
-
-  };
-
-
-  class D3D10ShaderReflectionVariable : public ID3D10ShaderReflectionVariable {
-
-  public:
-
-    D3D10ShaderReflectionVariable(
-            ID3D11ShaderReflectionVariable* d3d11);
-    
-    ~D3D10ShaderReflectionVariable();
-
-    HRESULT STDMETHODCALLTYPE GetDesc(
-            D3D10_SHADER_VARIABLE_DESC*     pDesc);
-    
-    ID3D10ShaderReflectionType* STDMETHODCALLTYPE GetType();
-
-    ID3D11ShaderReflectionVariable* STDMETHODCALLTYPE GetD3D11Iface() {
-      return m_d3d11;
-    }
-
-  private:
-
-    ID3D11ShaderReflectionVariable* m_d3d11;
-    D3D10ShaderReflectionType       m_type;
-
-  };
-
-
-  class D3D10ShaderReflectionConstantBuffer : public ID3D10ShaderReflectionConstantBuffer {
-
-  public:
-
-    D3D10ShaderReflectionConstantBuffer(
-            ID3D11ShaderReflectionConstantBuffer* d3d11);
-    
-    ~D3D10ShaderReflectionConstantBuffer();
-
-    HRESULT STDMETHODCALLTYPE GetDesc(
-            D3D10_SHADER_BUFFER_DESC*       pDesc);
-
-    ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByIndex(
-            UINT                            Index);
-    
-    ID3D10ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByName(
-            LPCSTR                          Name);
-    
-    ID3D11ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetD3D11Iface() {
-      return m_d3d11;
-    }
-    
-  private:
-
-    ID3D11ShaderReflectionConstantBuffer* m_d3d11;
-
-    std::unordered_map<
-      ID3D11ShaderReflectionVariable*,
-      D3D10ShaderReflectionVariable> m_variables;
-
-    ID3D10ShaderReflectionVariable* FindVariable(
-            ID3D11ShaderReflectionVariable* pVariable);
-
-  };
-
-
-  class D3D10ShaderReflection : public ComObject<ID3D10ShaderReflection> {
-
-  public:
-
-    D3D10ShaderReflection(ID3D11ShaderReflection* d3d11);
-    ~D3D10ShaderReflection();
-
-    HRESULT STDMETHODCALLTYPE QueryInterface(
-            REFIID                          riid,
-            void**                          ppvObject);
-    
-    HRESULT STDMETHODCALLTYPE GetDesc(
-            D3D10_SHADER_DESC*              pDesc);
-    
-    ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByIndex(
-            UINT                            Index);
-
-    ID3D10ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByName(
-            LPCSTR                          Name);
-
-    HRESULT STDMETHODCALLTYPE GetInputParameterDesc(
-            UINT                            ParameterIndex,
-            D3D10_SIGNATURE_PARAMETER_DESC* pDesc);
-
-    HRESULT STDMETHODCALLTYPE GetOutputParameterDesc(
-            UINT                            ParameterIndex,
-            D3D10_SIGNATURE_PARAMETER_DESC* pDesc);
-
-    HRESULT STDMETHODCALLTYPE GetResourceBindingDesc(
-            UINT                            ResourceIndex,
-            D3D10_SHADER_INPUT_BIND_DESC*   pDesc);
-    
-  private:
-
-    Com<ID3D11ShaderReflection> m_d3d11;
-
-    std::unordered_map<
-      ID3D11ShaderReflectionConstantBuffer*,
-      D3D10ShaderReflectionConstantBuffer> m_constantBuffers;
-    
-    ID3D10ShaderReflectionConstantBuffer* FindConstantBuffer(
-            ID3D11ShaderReflectionConstantBuffer* pConstantBuffer);
-    
-    void ConvertSignatureParameterDesc(
-      const D3D11_SIGNATURE_PARAMETER_DESC* pSrcDesc,
-            D3D10_SIGNATURE_PARAMETER_DESC* pDstDesc);
-
-  };
-
-}

src/d3d10/d3d10_state_block.cpp

@@ -1,432 +0,0 @@
-#include "d3d10_state_block.h"
-
-#define MAKE_STATE_TYPE(field, count) { offsetof(D3D10_STATE_BLOCK_MASK, field), count }
-
-namespace dxvk {
-
-  static const std::array<std::pair<size_t, size_t>, 24> g_stateTypes = {{
-    MAKE_STATE_TYPE(SOBuffers,                1),
-    MAKE_STATE_TYPE(OMRenderTargets,          1),
-    MAKE_STATE_TYPE(OMDepthStencilState,      1),
-    MAKE_STATE_TYPE(OMBlendState,             1),
-    MAKE_STATE_TYPE(VS,                       1),
-    MAKE_STATE_TYPE(VSSamplers,               D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT),
-    MAKE_STATE_TYPE(VSShaderResources,        D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT),
-    MAKE_STATE_TYPE(VSConstantBuffers,        D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT),
-    MAKE_STATE_TYPE(GS,                       1),
-    MAKE_STATE_TYPE(GSSamplers,               D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT),
-    MAKE_STATE_TYPE(GSShaderResources,        D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT),
-    MAKE_STATE_TYPE(GSConstantBuffers,        D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT),
-    MAKE_STATE_TYPE(PS,                       1),
-    MAKE_STATE_TYPE(PSSamplers,               D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT),
-    MAKE_STATE_TYPE(PSShaderResources,        D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT),
-    MAKE_STATE_TYPE(PSConstantBuffers,        D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT),
-    MAKE_STATE_TYPE(IAVertexBuffers,          D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT),
-    MAKE_STATE_TYPE(IAIndexBuffer,            1),
-    MAKE_STATE_TYPE(IAInputLayout,            1),
-    MAKE_STATE_TYPE(IAPrimitiveTopology,      1),
-    MAKE_STATE_TYPE(RSViewports,              1),
-    MAKE_STATE_TYPE(RSScissorRects,           1),
-    MAKE_STATE_TYPE(RSRasterizerState,        1),
-    MAKE_STATE_TYPE(Predication,              1),
-  }};
-
-
-  D3D10StateBlock::D3D10StateBlock(
-          ID3D10Device*             pDevice,
-    const D3D10_STATE_BLOCK_MASK*   pMask)
-  : m_device(pDevice), m_mask(*pMask) {
-
-  }
-
-  
-  D3D10StateBlock::~D3D10StateBlock() {
-
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlock::QueryInterface(
-          REFIID                    riid,
-          void**                    ppvObject) {
-    if (ppvObject == nullptr)
-      return E_POINTER;
-    
-    *ppvObject = nullptr;
-
-    if (riid == __uuidof(IUnknown)
-     || riid == __uuidof(ID3D10StateBlock)) {
-      *ppvObject = ref(this);
-      return S_OK;
-    }
-
-    Logger::warn("D3D10StateBlock::QueryInterface: Unknown interface query");
-    Logger::warn(str::format(riid));
-    return E_NOINTERFACE;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlock::Capture() {
-    m_state = D3D10_STATE_BLOCK_STATE();
-
-    if (TestBit(&m_mask.VS, 0)) m_device->VSGetShader(&m_state.vs);
-    if (TestBit(&m_mask.GS, 0)) m_device->GSGetShader(&m_state.gs);
-    if (TestBit(&m_mask.PS, 0)) m_device->PSGetShader(&m_state.ps);
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSSamplers, i)) m_device->VSGetSamplers(i, 1, &m_state.vsSso[i]);
-      if (TestBit(m_mask.GSSamplers, i)) m_device->GSGetSamplers(i, 1, &m_state.gsSso[i]);
-      if (TestBit(m_mask.PSSamplers, i)) m_device->PSGetSamplers(i, 1, &m_state.psSso[i]);
-    }
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSShaderResources, i)) m_device->VSGetShaderResources(i, 1, &m_state.vsSrv[i]);
-      if (TestBit(m_mask.GSShaderResources, i)) m_device->GSGetShaderResources(i, 1, &m_state.gsSrv[i]);
-      if (TestBit(m_mask.PSShaderResources, i)) m_device->PSGetShaderResources(i, 1, &m_state.psSrv[i]);
-    }
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSConstantBuffers, i)) m_device->VSGetConstantBuffers(i, 1, &m_state.vsCbo[i]);
-      if (TestBit(m_mask.GSConstantBuffers, i)) m_device->GSGetConstantBuffers(i, 1, &m_state.gsCbo[i]);
-      if (TestBit(m_mask.PSConstantBuffers, i)) m_device->PSGetConstantBuffers(i, 1, &m_state.psCbo[i]);
-    }
-
-    for (uint32_t i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.IAVertexBuffers, i)) {
-        m_device->IAGetVertexBuffers(i, 1,
-          &m_state.iaVertexBuffers[i],
-          &m_state.iaVertexOffsets[i],
-          &m_state.iaVertexStrides[i]);
-      }
-    }
-
-    if (TestBit(&m_mask.IAIndexBuffer, 0)) {
-      m_device->IAGetIndexBuffer(
-        &m_state.iaIndexBuffer,
-        &m_state.iaIndexFormat,
-        &m_state.iaIndexOffset);
-    }
-
-    if (TestBit(&m_mask.IAInputLayout, 0))
-      m_device->IAGetInputLayout(&m_state.iaInputLayout);
-    
-    if (TestBit(&m_mask.IAPrimitiveTopology, 0))
-      m_device->IAGetPrimitiveTopology(&m_state.iaTopology);
-    
-    if (TestBit(&m_mask.OMRenderTargets, 0)) {
-      m_device->OMGetRenderTargets(
-        D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT,
-        &m_state.omRtv[0], &m_state.omDsv);
-    }
-
-    if (TestBit(&m_mask.OMDepthStencilState, 0)) {
-      m_device->OMGetDepthStencilState(
-        &m_state.omDepthStencilState,
-        &m_state.omStencilRef);
-    }
-    
-    if (TestBit(&m_mask.OMBlendState, 0)) {
-      m_device->OMGetBlendState(
-        &m_state.omBlendState,
-         m_state.omBlendFactor,
-        &m_state.omSampleMask);
-    }
-    
-    if (TestBit(&m_mask.RSViewports, 0)) {
-      m_device->RSGetViewports(&m_state.rsViewportCount, nullptr);
-      m_device->RSGetViewports(&m_state.rsViewportCount, m_state.rsViewports);
-    }
-    
-    if (TestBit(&m_mask.RSScissorRects, 0)) {
-      m_device->RSGetScissorRects(&m_state.rsScissorCount, nullptr);
-      m_device->RSGetScissorRects(&m_state.rsScissorCount, m_state.rsScissors);
-    }
-
-    if (TestBit(&m_mask.RSRasterizerState, 0))
-      m_device->RSGetState(&m_state.rsState);
-    
-    if (TestBit(&m_mask.SOBuffers, 0)) {
-      m_device->SOGetTargets(
-        D3D10_SO_BUFFER_SLOT_COUNT,
-        &m_state.soBuffers[0],
-        &m_state.soOffsets[0]);
-    }
-
-    if (TestBit(&m_mask.Predication, 0))
-      m_device->GetPredication(&m_state.predicate, &m_state.predicateInvert);
-
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlock::Apply() {
-    if (TestBit(&m_mask.VS, 0)) m_device->VSSetShader(m_state.vs.ptr());
-    if (TestBit(&m_mask.GS, 0)) m_device->GSSetShader(m_state.gs.ptr());
-    if (TestBit(&m_mask.PS, 0)) m_device->PSSetShader(m_state.ps.ptr());
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSSamplers, i)) m_device->VSSetSamplers(i, 1, &m_state.vsSso[i]);
-      if (TestBit(m_mask.GSSamplers, i)) m_device->GSSetSamplers(i, 1, &m_state.gsSso[i]);
-      if (TestBit(m_mask.PSSamplers, i)) m_device->PSSetSamplers(i, 1, &m_state.psSso[i]);
-    }
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSShaderResources, i)) m_device->VSSetShaderResources(i, 1, &m_state.vsSrv[i]);
-      if (TestBit(m_mask.GSShaderResources, i)) m_device->GSSetShaderResources(i, 1, &m_state.gsSrv[i]);
-      if (TestBit(m_mask.PSShaderResources, i)) m_device->PSSetShaderResources(i, 1, &m_state.psSrv[i]);
-    }
-    
-    for (uint32_t i = 0; i < D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.VSConstantBuffers, i)) m_device->VSSetConstantBuffers(i, 1, &m_state.vsCbo[i]);
-      if (TestBit(m_mask.GSConstantBuffers, i)) m_device->GSSetConstantBuffers(i, 1, &m_state.gsCbo[i]);
-      if (TestBit(m_mask.PSConstantBuffers, i)) m_device->PSSetConstantBuffers(i, 1, &m_state.psCbo[i]);
-    }
-
-    for (uint32_t i = 0; i < D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; i++) {
-      if (TestBit(m_mask.IAVertexBuffers, i)) {
-        m_device->IASetVertexBuffers(i, 1,
-          &m_state.iaVertexBuffers[i],
-          &m_state.iaVertexOffsets[i],
-          &m_state.iaVertexStrides[i]);
-      }
-    }
-
-    if (TestBit(&m_mask.IAIndexBuffer, 0)) {
-      m_device->IASetIndexBuffer(
-        m_state.iaIndexBuffer.ptr(),
-        m_state.iaIndexFormat,
-        m_state.iaIndexOffset);
-    }
-
-    if (TestBit(&m_mask.IAInputLayout, 0))
-      m_device->IASetInputLayout(m_state.iaInputLayout.ptr());
-    
-    if (TestBit(&m_mask.IAPrimitiveTopology, 0))
-      m_device->IASetPrimitiveTopology(m_state.iaTopology);
-    
-    if (TestBit(&m_mask.OMRenderTargets, 0)) {
-      m_device->OMSetRenderTargets(
-        D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT,
-        &m_state.omRtv[0], m_state.omDsv.ptr());
-    }
-
-    if (TestBit(&m_mask.OMDepthStencilState, 0)) {
-      m_device->OMSetDepthStencilState(
-        m_state.omDepthStencilState.ptr(),
-        m_state.omStencilRef);
-    }
-    
-    if (TestBit(&m_mask.OMBlendState, 0)) {
-      m_device->OMSetBlendState(
-        m_state.omBlendState.ptr(),
-        m_state.omBlendFactor,
-        m_state.omSampleMask);
-    }
-    
-    if (TestBit(&m_mask.RSViewports, 0))
-      m_device->RSSetViewports(m_state.rsViewportCount, m_state.rsViewports);
-    
-    if (TestBit(&m_mask.RSScissorRects, 0))
-      m_device->RSSetScissorRects(m_state.rsScissorCount, m_state.rsScissors);
-
-    if (TestBit(&m_mask.RSRasterizerState, 0))
-      m_device->RSSetState(m_state.rsState.ptr());
-    
-    if (TestBit(&m_mask.SOBuffers, 0)) {
-      m_device->SOSetTargets(
-        D3D10_SO_BUFFER_SLOT_COUNT,
-        &m_state.soBuffers[0],
-        &m_state.soOffsets[0]);
-    }
-    
-    if (TestBit(&m_mask.Predication, 0))
-      m_device->SetPredication(m_state.predicate.ptr(), m_state.predicateInvert);
-
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlock::GetDevice(
-          ID3D10Device**            ppDevice) {
-    Logger::err("D3D10StateBlock::GetDevice: Stub");
-    return E_NOTIMPL;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlock::ReleaseAllDeviceObjects() {
-    // Not entirely sure if this is correct?
-    m_state = D3D10_STATE_BLOCK_STATE();
-    return S_OK;
-  }
-
-
-  BOOL D3D10StateBlock::TestBit(
-    const BYTE*                     pMask,
-          UINT                      Idx) {
-    uint32_t byte = Idx / 8;
-    uint32_t bit  = Idx % 8;
-    return (pMask[byte] & (1 << bit)) != 0;
-  }
-
-}
-
-extern "C" {
-  using namespace dxvk;
-
-  HRESULT STDMETHODCALLTYPE D3D10CreateStateBlock(
-          ID3D10Device*             pDevice,
-          D3D10_STATE_BLOCK_MASK*   pStateBlockMask,
-          ID3D10StateBlock**        ppStateBlock) {
-    InitReturnPtr(ppStateBlock);
-
-    if (!pDevice || !pStateBlockMask || !ppStateBlock)
-      return E_INVALIDARG;
-    
-    *ppStateBlock = ref(new D3D10StateBlock(pDevice, pStateBlockMask));
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskEnableCapture(
-          D3D10_STATE_BLOCK_MASK*   pMask,
-          D3D10_DEVICE_STATE_TYPES  StateType,
-          UINT                      StartIdx,
-          UINT                      Count) {
-    if (!pMask || !StateType || StateType > g_stateTypes.size())
-      return E_INVALIDARG;
-    
-    auto pair = g_stateTypes[uint32_t(StateType) - 1];
-    auto mask = reinterpret_cast<BYTE*>(pMask) + pair.first;
-
-    if (StartIdx + Count > pair.second)
-      return E_INVALIDARG;
-    
-    for (uint32_t i = StartIdx; i < StartIdx + Count; i++) {
-      uint32_t byte = i / 8;
-      uint32_t bit  = i % 8;
-      mask[byte] |= 1 << bit;
-    }
-
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskDisableCapture(
-          D3D10_STATE_BLOCK_MASK*   pMask,
-          D3D10_DEVICE_STATE_TYPES  StateType,
-          UINT                      StartIdx,
-          UINT                      Count) {
-    if (!pMask || !StateType || StateType > g_stateTypes.size())
-      return E_INVALIDARG;
-    
-    auto pair = g_stateTypes[uint32_t(StateType) - 1];
-    auto mask = reinterpret_cast<BYTE*>(pMask) + pair.first;
-
-    if (StartIdx + Count > pair.second)
-      return E_INVALIDARG;
-    
-    for (uint32_t i = StartIdx; i < StartIdx + Count; i++) {
-      uint32_t byte = i / 8;
-      uint32_t bit  = i % 8;
-      mask[byte] &= ~(1 << bit);
-    }
-
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskEnableAll(
-          D3D10_STATE_BLOCK_MASK*   pMask) {
-    if (!pMask)
-      return E_INVALIDARG;
-    
-    *pMask = D3D10_STATE_BLOCK_MASK();
-    for (size_t i = 0; i < g_stateTypes.size(); i++) {
-      D3D10StateBlockMaskEnableCapture(pMask,
-        D3D10_DEVICE_STATE_TYPES(i + 1),
-        0, g_stateTypes[i].second);
-    }
-
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskDisableAll(
-          D3D10_STATE_BLOCK_MASK* pMask) {
-    if (!pMask)
-      return E_INVALIDARG;
-    
-    *pMask = D3D10_STATE_BLOCK_MASK();
-    return S_OK;
-  }
-
-
-  BOOL STDMETHODCALLTYPE D3D10StateBlockMaskGetSetting(
-          D3D10_STATE_BLOCK_MASK*   pMask,
-          D3D10_DEVICE_STATE_TYPES  StateType,
-          UINT                      Idx) {
-    if (!pMask || !StateType || StateType > g_stateTypes.size())
-      return FALSE;
-    
-    auto pair = g_stateTypes[uint32_t(StateType) - 1];
-    auto mask = reinterpret_cast<BYTE*>(pMask) + pair.first;
-
-    if (Idx >= pair.second)
-      return FALSE;
-    
-    uint32_t byte = Idx / 8;
-    uint32_t bit  = Idx % 8;
-    return (mask[byte] & (1 << bit)) != 0;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskDifference(
-          D3D10_STATE_BLOCK_MASK* pA,
-          D3D10_STATE_BLOCK_MASK* pB,
-          D3D10_STATE_BLOCK_MASK* pResult) {
-    if (!pA || !pB || !pResult)
-      return E_INVALIDARG;
-    
-    auto a = reinterpret_cast<const BYTE*>(pA);
-    auto b = reinterpret_cast<const BYTE*>(pB);
-    auto r = reinterpret_cast<BYTE*>(pResult);
-
-    for (size_t i = 0; i < sizeof(D3D10_STATE_BLOCK_MASK); i++)
-      r[i] = a[i] ^ b[i];
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskIntersect(
-          D3D10_STATE_BLOCK_MASK*   pA,
-          D3D10_STATE_BLOCK_MASK*   pB,
-          D3D10_STATE_BLOCK_MASK*   pResult) {
-    if (!pA || !pB || !pResult)
-      return E_INVALIDARG;
-    
-    auto a = reinterpret_cast<const BYTE*>(pA);
-    auto b = reinterpret_cast<const BYTE*>(pB);
-    auto r = reinterpret_cast<BYTE*>(pResult);
-
-    for (size_t i = 0; i < sizeof(D3D10_STATE_BLOCK_MASK); i++)
-      r[i] = a[i] & b[i];
-    return S_OK;
-  }
-
-
-  HRESULT STDMETHODCALLTYPE D3D10StateBlockMaskUnion(
-          D3D10_STATE_BLOCK_MASK*   pA,
-          D3D10_STATE_BLOCK_MASK*   pB,
-          D3D10_STATE_BLOCK_MASK*   pResult) {
-    if (!pA || !pB || !pResult)
-      return E_INVALIDARG;
-    
-    auto a = reinterpret_cast<const BYTE*>(pA);
-    auto b = reinterpret_cast<const BYTE*>(pB);
-    auto r = reinterpret_cast<BYTE*>(pResult);
-
-    for (size_t i = 0; i < sizeof(D3D10_STATE_BLOCK_MASK); i++)
-      r[i] = a[i] | b[i];
-    return S_OK;
-  }
-
-}

src/d3d10/d3d10_state_block.h

@@ -1,82 +0,0 @@
-#pragma once
-
-#include "d3d10_include.h"
-#include "d3d10_interfaces.h"
-
-namespace dxvk {
-
-  struct D3D10_STATE_BLOCK_STATE {
-    Com<ID3D10VertexShader>       vs                  = { };
-    Com<ID3D10SamplerState>       vsSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT]              = { };
-    Com<ID3D10ShaderResourceView> vsSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT]       = { };
-    Com<ID3D10Buffer>             vsCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT]  = { };
-    Com<ID3D10GeometryShader>     gs                  = { };
-    Com<ID3D10SamplerState>       gsSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT]              = { };
-    Com<ID3D10ShaderResourceView> gsSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT]       = { };
-    Com<ID3D10Buffer>             gsCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT]  = { };
-    Com<ID3D10PixelShader>        ps                  = { };
-    Com<ID3D10SamplerState>       psSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT]              = { };
-    Com<ID3D10ShaderResourceView> psSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT]       = { };
-    Com<ID3D10Buffer>             psCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT]  = { };
-    Com<ID3D10Buffer>             iaVertexBuffers[D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = { };
-    UINT                          iaVertexOffsets[D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = { };
-    UINT                          iaVertexStrides[D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = { };
-    Com<ID3D10Buffer>             iaIndexBuffer       = { };
-    DXGI_FORMAT                   iaIndexFormat       = DXGI_FORMAT_UNKNOWN;
-    UINT                          iaIndexOffset       = 0;
-    Com<ID3D10InputLayout>        iaInputLayout       = nullptr;
-    D3D10_PRIMITIVE_TOPOLOGY      iaTopology          = D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED;
-    Com<ID3D10RenderTargetView>   omRtv[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT] = { };
-    Com<ID3D10DepthStencilView>   omDsv               = { };
-    Com<ID3D10DepthStencilState>  omDepthStencilState = { };
-    UINT                          omStencilRef        = 0;
-    Com<ID3D10BlendState>         omBlendState        = { };
-    FLOAT                         omBlendFactor[4]    = { };
-    UINT                          omSampleMask        = 0;
-    UINT                          rsViewportCount     = 0;
-    D3D10_VIEWPORT                rsViewports[D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE] = { };
-    UINT                          rsScissorCount      = 0;
-    RECT                          rsScissors [D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE] = { };
-    Com<ID3D10RasterizerState>    rsState             = { };
-    Com<ID3D10Buffer>             soBuffers[D3D10_SO_BUFFER_SLOT_COUNT] = { };
-    UINT                          soOffsets[D3D10_SO_BUFFER_SLOT_COUNT] = { };
-    Com<ID3D10Predicate>          predicate           = { };
-    BOOL                          predicateInvert     = FALSE;
-  };
-
-
-  class D3D10StateBlock : public ComObject<ID3D10StateBlock> {
-
-  public:
-    D3D10StateBlock(
-            ID3D10Device*             pDevice,
-      const D3D10_STATE_BLOCK_MASK*   pMask);
-    
-    ~D3D10StateBlock();
-
-    HRESULT STDMETHODCALLTYPE QueryInterface(
-            REFIID                    riid,
-            void**                    ppvObject);
-
-    HRESULT STDMETHODCALLTYPE Capture();
-
-    HRESULT STDMETHODCALLTYPE Apply();
-
-    HRESULT STDMETHODCALLTYPE GetDevice(
-            ID3D10Device**            ppDevice);
-
-    HRESULT STDMETHODCALLTYPE ReleaseAllDeviceObjects();
-  
-  private:
-
-    Com<ID3D10Device>       m_device;
-    D3D10_STATE_BLOCK_MASK  m_mask;
-    D3D10_STATE_BLOCK_STATE m_state;
-
-    static BOOL TestBit(
-      const BYTE*                     pMask,
-            UINT                      Idx);
-
-  };
-
-}

src/d3d10/d3d10core.sym

@@ -0,0 +1,9 @@
+{
+  global:
+    D3D10CoreCreateDevice;
+    D3D10CoreGetVersion;
+    D3D10CoreRegisterLayers;
+
+  local:
+    *;
+};

src/d3d10/meson.build

@@ -1,49 +1,37 @@
-d3d10_res      = wrc_generator.process('version10.rc')
-d3d10_1_res    = wrc_generator.process('version10_1.rc')
 d3d10_core_res = wrc_generator.process('version10_core.rc')
 
 d3d10_core_src = [
   'd3d10_core.cpp',
 ]
 
-d3d10_main_src = [
-  'd3d10_main.cpp',
-  'd3d10_reflection.cpp',
-  'd3d10_state_block.cpp',
-]
+d3d10_core_ld_args      = []
+d3d10_core_link_depends = []
 
-d3d10_core_dll = shared_library('d3d10core'+dll_ext, d3d10_core_src, d3d10_core_res,
-  name_prefix         : '',
-  dependencies        : [ d3d11_dep ],
+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(dxvk_name_prefix+'d3d10core', d3d10_core_src, d3d10_core_res,
+  dependencies        : [ d3d10_d3d11_dep ],
   include_directories : dxvk_include_path,
   install             : true,
-  objects             : not dxvk_msvc ? 'd3d10core'+def_spec_ext : [],
   vs_module_defs      : 'd3d10core'+def_spec_ext,
-  override_options    : ['cpp_std='+dxvk_cpp_std])
+  link_args           : d3d10_core_ld_args,
+  link_depends        : [ d3d10_core_link_depends ],
+  kwargs              : dxvk_so_version,
+)
 
 d3d10_core_dep = declare_dependency(
-  link_with           : [ d3d10_core_dll ])
+  link_with           : [ d3d10_core_dll ],
+)
 
-d3d10_deps = [ lib_d3dcompiler_43, lib_dxgi, dxbc_dep, dxvk_dep, d3d10_core_dep ]
-
-d3d10_dll = shared_library('d3d10'+dll_ext, d3d10_main_src, d3d10_res,
-  name_prefix         : '',
-  dependencies        : [ d3d10_deps ],
-  include_directories : dxvk_include_path,
-  install             : true,
-  objects             : not dxvk_msvc ? 'd3d10'+def_spec_ext : [],
-  vs_module_defs      : 'd3d10'+def_spec_ext,
-  override_options    : ['cpp_std='+dxvk_cpp_std])
-
-d3d10_1_dll = shared_library('d3d10_1'+dll_ext, d3d10_main_src, d3d10_1_res,
-  name_prefix         : '',
-  dependencies        : [ d3d10_deps ],
-  include_directories : dxvk_include_path,
-  install             : true,
-  objects             : not dxvk_msvc ? 'd3d10_1'+def_spec_ext : [],
-  vs_module_defs      : 'd3d10_1'+def_spec_ext,
-  override_options    : ['cpp_std='+dxvk_cpp_std])
-
-d3d10_dep = declare_dependency(
-  link_with           : [ d3d10_dll, d3d10_1_dll, d3d10_core_dll ],
-  include_directories : [ dxvk_include_path ])
+if platform != 'windows'
+  pkg.generate(d3d10_core_dll,
+    filebase: dxvk_pkg_prefix + 'd3d10core',
+    subdirs:  'dxvk',
+  )
+endif

src/d3d10/version10_1.rc

@@ -1,32 +0,0 @@
-#include <windows.h>
-
-// DLL version information.
-VS_VERSION_INFO    VERSIONINFO
-FILEVERSION        10,0,17763,1
-PRODUCTVERSION     10,0,17763,1
-FILEFLAGSMASK      VS_FFI_FILEFLAGSMASK
-FILEFLAGS          0
-FILEOS VOS_NT_WINDOWS32
-FILETYPE VFT_DLL
-FILESUBTYPE VFT2_UNKNOWN
-BEGIN
-  BLOCK "StringFileInfo"
-  BEGIN
-    BLOCK "080904b0"
-    BEGIN
-      VALUE "CompanyName",      "DXVK"
-      VALUE "FileDescription",  "Direct3D 10.1 Runtime"
-      VALUE "FileVersion",      "10.0.17763.1 (WinBuild.160101.0800)"
-      VALUE "InternalName",     "D3D10_1.dll"
-      VALUE "LegalCopyright",   "zlib/libpng license"
-      VALUE "OriginalFilename", "D3D10_1.dll"
-      VALUE "ProductName",      "DXVK"
-      VALUE "ProductVersion",   "10.0.17763.1"
-    END
-  END
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x0809, 1200
-  END
-END
-

src/d3d11/d3d11.def

@@ -3,3 +3,4 @@ EXPORTS
     D3D11CoreCreateDevice @18
     D3D11CreateDevice @22
     D3D11CreateDeviceAndSwapChain @23
+    D3D11On12CreateDevice @24

src/d3d11/d3d11.sym

@@ -0,0 +1,10 @@
+{
+  global:
+    D3D11CoreCreateDevice;
+    D3D11CreateDevice;
+    D3D11CreateDeviceAndSwapChain;
+    D3D11On12CreateDevice;
+
+  local:
+    *;
+};

src/d3d11/d3d11_annotation.cpp

@@ -1,55 +1,139 @@
 #include "d3d11_annotation.h"
+#include "d3d11_context_def.h"
+#include "d3d11_context_imm.h"
+#include "d3d11_device.h"
+
+#include "../util/util_misc.h"
+#include "../util/util_win32_compat.h"
 
 namespace dxvk {
 
-  D3D11UserDefinedAnnotation::D3D11UserDefinedAnnotation(ID3D11DeviceContext* ctx)
-  : m_container(ctx) { }
+  template <bool Register>
+  static void RegisterUserDefinedAnnotation(IDXVKUserDefinedAnnotation* annotation) {
+    using RegistrationFunctionType = void(__stdcall *)(IDXVKUserDefinedAnnotation*);
+    static const int16_t RegisterOrdinal = 28257;
+    static const int16_t UnregisterOrdinal = 28258;
 
+    HMODULE d3d9Module = ::LoadLibraryA("d3d9.dll");
+    if (!d3d9Module) {
+      Logger::info("Unable to find d3d9, some annotations may be missed.");
+      return;
+    }
 
-  D3D11UserDefinedAnnotation::~D3D11UserDefinedAnnotation() {
+    const int16_t ordinal = Register ? RegisterOrdinal : UnregisterOrdinal;
+    auto registrationFunction = reinterpret_cast<RegistrationFunctionType>(::GetProcAddress(d3d9Module,
+      reinterpret_cast<const char*>(static_cast<uintptr_t>(ordinal))));
 
+    if (!registrationFunction) {
+      Logger::info("Unable to find DXVK_RegisterAnnotation, some annotations may be missed.");
+      return;
+    }
+
+    registrationFunction(annotation);
   }
 
 
-  ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::AddRef() {
+  template<typename ContextType>
+  D3D11UserDefinedAnnotation<ContextType>::D3D11UserDefinedAnnotation(
+          ContextType*          container,
+    const Rc<DxvkDevice>&       dxvkDevice)
+  : m_container(container),
+    m_annotationsEnabled(dxvkDevice->debugFlags().test(DxvkDebugFlag::Markers)) {
+    if (!IsDeferred && m_annotationsEnabled)
+      RegisterUserDefinedAnnotation<true>(this);
+  }
+
+
+  template<typename ContextType>
+  D3D11UserDefinedAnnotation<ContextType>::~D3D11UserDefinedAnnotation() {
+    if (!IsDeferred && m_annotationsEnabled)
+      RegisterUserDefinedAnnotation<false>(this);
+  }
+
+
+  template<typename ContextType>
+  ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::AddRef() {
     return m_container->AddRef();
   }
 
   
-  ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::Release() {
+  template<typename ContextType>
+  ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::Release() {
     return m_container->Release();
   }
 
   
-  HRESULT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::QueryInterface(
+  template<typename ContextType>
+  HRESULT STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::QueryInterface(
           REFIID                  riid,
           void**                  ppvObject) {
     return m_container->QueryInterface(riid, ppvObject);
   }
   
 
-  INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::BeginEvent(
+  template<typename ContextType>
+  INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::BeginEvent(
+          D3DCOLOR                Color,
           LPCWSTR                 Name) {
-    // Currently not implemented
-    return -1;
+    if (!m_annotationsEnabled || !Name)
+      return -1;
+
+    D3D10DeviceLock lock = m_container->LockContext();
+
+    m_container->EmitCs([
+      cColor = Color,
+      cLabel = dxvk::str::fromws(Name)
+    ] (DxvkContext* ctx) {
+      ctx->beginDebugLabel(vk::makeLabel(cColor, cLabel.c_str()));
+    });
+
+    return m_eventDepth++;
   }
 
 
-  INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::EndEvent() {
-    // Currently not implemented
-    return -1;
+  template<typename ContextType>
+  INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::EndEvent() {
+    if (!m_annotationsEnabled)
+      return -1;
+
+    D3D10DeviceLock lock = m_container->LockContext();
+
+    if (!m_eventDepth)
+      return 0;
+
+    m_container->EmitCs([] (DxvkContext* ctx) {
+      ctx->endDebugLabel();
+    });
+
+    return --m_eventDepth;
   }
 
 
-  void STDMETHODCALLTYPE D3D11UserDefinedAnnotation::SetMarker(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::SetMarker(
+          D3DCOLOR                Color,
           LPCWSTR                 Name) {
-    // Currently not implemented
+    if (!m_annotationsEnabled || !Name)
+      return;
+
+    D3D10DeviceLock lock = m_container->LockContext();
+
+    m_container->EmitCs([
+      cColor = Color,
+      cLabel = dxvk::str::fromws(Name)
+    ] (DxvkContext* ctx) {
+      ctx->insertDebugLabel(vk::makeLabel(cColor, cLabel.c_str()));
+    });
   }
 
 
-  BOOL STDMETHODCALLTYPE D3D11UserDefinedAnnotation::GetStatus() {
-    // Currently not implemented
-    return FALSE;
+  template<typename ContextType>
+  BOOL STDMETHODCALLTYPE D3D11UserDefinedAnnotation<ContextType>::GetStatus() {
+    return m_annotationsEnabled;
   }
 
-}
+
+  template class D3D11UserDefinedAnnotation<D3D11DeferredContext>;
+  template class D3D11UserDefinedAnnotation<D3D11ImmediateContext>;
+
+}

src/d3d11/d3d11_annotation.h

@@ -1,16 +1,31 @@
 #pragma once
 
+#include <type_traits>
+
 #include "d3d11_include.h"
 
+#include "../dxvk/dxvk_annotation.h"
+#include "../dxvk/dxvk_device.h"
+
 namespace dxvk {
 
-  class D3D11UserDefinedAnnotation : ID3DUserDefinedAnnotation {
+  class D3D11DeferredContext;
+  class D3D11ImmediateContext;
 
+  template<typename ContextType>
+  class D3D11UserDefinedAnnotation final : public IDXVKUserDefinedAnnotation {
+    constexpr static bool IsDeferred = std::is_same_v<ContextType, D3D11DeferredContext>;
   public:
 
-    D3D11UserDefinedAnnotation(ID3D11DeviceContext* ctx);
+    D3D11UserDefinedAnnotation(
+            ContextType*          container,
+      const Rc<DxvkDevice>&       dxvkDevice);
+
     ~D3D11UserDefinedAnnotation();
 
+    D3D11UserDefinedAnnotation             (const D3D11UserDefinedAnnotation&) = delete;
+    D3D11UserDefinedAnnotation& operator = (const D3D11UserDefinedAnnotation&) = delete;
+
     ULONG STDMETHODCALLTYPE AddRef();
     
     ULONG STDMETHODCALLTYPE Release();
@@ -20,19 +35,23 @@ namespace dxvk {
             void**                  ppvObject);
     
     INT STDMETHODCALLTYPE BeginEvent(
+            D3DCOLOR                Color,
             LPCWSTR                 Name);
 
     INT STDMETHODCALLTYPE EndEvent();
 
     void STDMETHODCALLTYPE SetMarker(
+            D3DCOLOR                Color,
             LPCWSTR                 Name);
 
     BOOL STDMETHODCALLTYPE GetStatus();
 
   private:
 
-    ID3D11DeviceContext*  m_container;
+    ContextType*  m_container           = nullptr;
+    int32_t       m_eventDepth          = 0u;
+    bool          m_annotationsEnabled  = false;
 
   };
 
-}
+}

src/d3d11/d3d11_blend.cpp

@@ -6,7 +6,8 @@ namespace dxvk {
   D3D11BlendState::D3D11BlendState(
           D3D11Device*        device,
     const D3D11_BLEND_DESC1&  desc)
-  : m_device(device), m_desc(desc), m_d3d10(this) {
+  : D3D11StateObject<ID3D11BlendState1>(device),
+    m_desc(desc), m_d3d10(this) {
     // If Independent Blend is disabled, we must ignore the
     // blend modes for render target 1 to 7. In Vulkan, all
     // blend modes need to be identical in that case.
@@ -34,22 +35,6 @@ namespace dxvk {
   D3D11BlendState::~D3D11BlendState() {
     
   }
-  
-  
-  ULONG STDMETHODCALLTYPE D3D11BlendState::AddRef() {
-    ULONG refCount = m_refCount++;
-    if (!refCount)
-      m_device->AddRef();
-    return refCount + 1;
-  }
-
-
-  ULONG STDMETHODCALLTYPE D3D11BlendState::Release() {
-    ULONG refCount = --m_refCount;
-    if (!refCount)
-      m_device->Release();
-    return refCount;
-  }
 
 
   HRESULT STDMETHODCALLTYPE D3D11BlendState::QueryInterface(REFIID riid, void** ppvObject) {
@@ -73,17 +58,15 @@ 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;
   }
   
   
-  void STDMETHODCALLTYPE D3D11BlendState::GetDevice(ID3D11Device** ppDevice) {
-    *ppDevice = ref(m_device);
-  }
-  
-  
   void STDMETHODCALLTYPE D3D11BlendState::GetDesc(D3D11_BLEND_DESC* pDesc) {
     pDesc->AlphaToCoverageEnable  = m_desc.AlphaToCoverageEnable;
     pDesc->IndependentBlendEnable = m_desc.IndependentBlendEnable;
@@ -107,7 +90,7 @@ namespace dxvk {
   
   
   void D3D11BlendState::BindToContext(
-    const Rc<DxvkContext>&  ctx,
+          DxvkContext*      ctx,
           uint32_t          sampleMask) const {
     // We handled Independent Blend during object creation
     // already, so if it is disabled, all elements in the

src/d3d11/d3d11_blend.h

@@ -11,7 +11,7 @@ namespace dxvk {
   
   class D3D11Device;
   
-  class D3D11BlendState : public D3D11DeviceChild<ID3D11BlendState1, NoWrapper> {
+  class D3D11BlendState : public D3D11StateObject<ID3D11BlendState1> {
     
   public:
     
@@ -21,18 +21,11 @@ namespace dxvk {
             D3D11Device*       device,
       const D3D11_BLEND_DESC1& desc);
     ~D3D11BlendState();
-    
-    ULONG STDMETHODCALLTYPE AddRef() final;
-
-    ULONG STDMETHODCALLTYPE Release() final;
 
     HRESULT STDMETHODCALLTYPE QueryInterface(
             REFIID  riid,
             void**  ppvObject) final;
     
-    void STDMETHODCALLTYPE GetDevice(
-            ID3D11Device **ppDevice) final;
-    
     void STDMETHODCALLTYPE GetDesc(
             D3D11_BLEND_DESC* pDesc) final;
     
@@ -40,7 +33,7 @@ namespace dxvk {
             D3D11_BLEND_DESC1* pDesc) final;
     
     void BindToContext(
-      const Rc<DxvkContext>&  ctx,
+            DxvkContext*      ctx,
             UINT              sampleMask) const;
     
     D3D10BlendState* GetD3D10Iface() {
@@ -55,7 +48,6 @@ namespace dxvk {
 
   private:
     
-    D3D11Device* const            m_device;
     D3D11_BLEND_DESC1             m_desc;
     
     std::array<DxvkBlendMode, 8>  m_blendModes;
@@ -63,8 +55,6 @@ namespace dxvk {
     DxvkLogicOpState              m_loState;
 
     D3D10BlendState               m_d3d10;
-
-    std::atomic<uint32_t> m_refCount = { 0u };
     
     static DxvkBlendMode DecodeBlendMode(
       const D3D11_RENDER_TARGET_BLEND_DESC1& BlendDesc);

src/d3d11/d3d11_buffer.cpp

@@ -1,19 +1,20 @@
 #include "d3d11_buffer.h"
 #include "d3d11_context.h"
+#include "d3d11_context_imm.h"
 #include "d3d11_device.h"
 
-#include "../dxvk/dxvk_data.h"
-
 namespace dxvk {
   
   D3D11Buffer::D3D11Buffer(
           D3D11Device*                pDevice,
-    const D3D11_BUFFER_DESC*          pDesc)
-  : m_device      (pDevice),
+    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;
+    DxvkBufferCreateInfo info;
+    info.flags  = 0;
     info.size   = pDesc->ByteWidth;
     info.usage  = VK_BUFFER_USAGE_TRANSFER_SRC_BIT
                 | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
@@ -35,17 +36,14 @@ namespace dxvk {
     
     if (pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-      info.stages |= m_device->GetEnabledShaderStages();
+      info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_UNIFORM_READ_BIT;
-
-      if (m_device->GetOptions()->constantBufferRangeCheck)
-        info.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
     }
     
     if (pDesc->BindFlags & D3D11_BIND_SHADER_RESOURCE) {
       info.usage  |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-      info.stages |= m_device->GetEnabledShaderStages();
+      info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT;
     }
     
@@ -58,7 +56,7 @@ namespace dxvk {
     if (pDesc->BindFlags & D3D11_BIND_UNORDERED_ACCESS) {
       info.usage  |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
                   |  VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-      info.stages |= m_device->GetEnabledShaderStages();
+      info.stages |= m_parent->GetEnabledShaderStages();
       info.access |= VK_ACCESS_SHADER_READ_BIT
                   |  VK_ACCESS_SHADER_WRITE_BIT;
     }
@@ -69,10 +67,57 @@ namespace dxvk {
       info.access |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
     }
 
-    // Create the buffer and set the entire buffer slice as mapped,
-    // so that we only have to update it when invalidating th buffer
-    m_buffer = m_device->GetDXVKDevice()->createBuffer(info, GetMemoryFlags());
-    m_mapped = m_buffer->getSliceHandle();
+    if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILED) {
+      info.flags  |= VK_BUFFER_CREATE_SPARSE_BINDING_BIT
+                  |  VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
+                  |  VK_BUFFER_CREATE_SPARSE_ALIASED_BIT;
+    }
+
+    // Set host read bit as necessary. We may internally read staging
+    // buffer contents even if the buffer is not marked for reading.
+    if (pDesc->CPUAccessFlags && pDesc->Usage != D3D11_USAGE_DYNAMIC) {
+      info.stages |= VK_PIPELINE_STAGE_HOST_BIT;
+      info.access |= VK_ACCESS_HOST_READ_BIT;
+
+      if (pDesc->CPUAccessFlags & D3D11_CPU_ACCESS_WRITE)
+        info.access |= VK_ACCESS_HOST_WRITE_BIT;
+    }
+
+    // Always enable BDA usage if available so that CUDA interop can work
+    if (m_parent->GetDXVKDevice()->features().vk12.bufferDeviceAddress)
+      info.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
+
+    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_cookie = m_buffer->cookie();
+      m_mapPtr = m_buffer->mapPtr(0);
+      m_mapMode = DetermineMapMode(m_buffer->memFlags());
+    } else if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)) {
+      VkMemoryPropertyFlags memoryFlags = GetMemoryFlags();
+      m_mapMode = DetermineMapMode(memoryFlags);
+
+      // 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, memoryFlags);
+      m_cookie = m_buffer->cookie();
+      m_mapPtr = m_buffer->mapPtr(0);
+    } else {
+      m_sparseAllocator = m_parent->GetDXVKDevice()->createSparsePageAllocator();
+      m_sparseAllocator->setCapacity(info.size / SparseMemoryPageSize);
+
+      m_cookie = 0u;
+      m_mapPtr = nullptr;
+      m_mapMode = D3D11_COMMON_BUFFER_MAP_MODE_NONE;
+    }
 
     // For Stream Output buffers we need a counter
     if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT)
@@ -81,7 +126,8 @@ namespace dxvk {
   
   
   D3D11Buffer::~D3D11Buffer() {
-
+    if (m_desc.CPUAccessFlags && m_11on12.Resource != nullptr)
+      m_11on12.Resource->Unmap(0, nullptr);
   }
   
   
@@ -114,17 +160,15 @@ 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;
   }
   
   
-  void STDMETHODCALLTYPE D3D11Buffer::GetDevice(ID3D11Device** ppDevice) {
-    *ppDevice = m_device.ref();
-  }
-  
-  
   UINT STDMETHODCALLTYPE D3D11Buffer::GetEvictionPriority() {
     return DXGI_RESOURCE_PRIORITY_NORMAL;
   }
@@ -161,22 +205,30 @@ namespace dxvk {
 
     // Check whether the given combination of buffer view
     // type and view format is supported by the device
-    DXGI_VK_FORMAT_INFO viewFormat = m_device->LookupFormat(Format, DXGI_VK_FORMAT_MODE_ANY);
-    VkFormatFeatureFlags features = GetBufferFormatFeatures(BindFlags);
+    DXGI_VK_FORMAT_INFO viewFormat = m_parent->LookupFormat(Format, DXGI_VK_FORMAT_MODE_ANY);
+    VkFormatFeatureFlags2 features = GetBufferFormatFeatures(BindFlags);
 
     return CheckFormatFeatureSupport(viewFormat.Format, features);
   }
 
 
+  void D3D11Buffer::SetDebugName(const char* pName) {
+    if (m_buffer) {
+      m_parent->GetContext()->InjectCs(DxvkCsQueue::HighPriority, [
+        cBuffer = m_buffer,
+        cName   = std::string(pName ? pName : "")
+      ] (DxvkContext* ctx) {
+        ctx->setDebugName(cBuffer, cName.c_str());
+      });
+    }
+  }
+
+
   HRESULT D3D11Buffer::NormalizeBufferProperties(D3D11_BUFFER_DESC* pDesc) {
     // Zero-sized buffers are illegal
-    if (!pDesc->ByteWidth)
+    if (!pDesc->ByteWidth && !(pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL))
       return E_INVALIDARG;
 
-    // We don't support tiled resources
-    if (pDesc->MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED))
-      return E_INVALIDARG;
-    
     // Constant buffer size must be a multiple of 16
     if ((pDesc->BindFlags & D3D11_BIND_CONSTANT_BUFFER)
      && (pDesc->ByteWidth & 0xF))
@@ -197,7 +249,25 @@ namespace dxvk {
     // Mip generation obviously doesn't work for buffers
     if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
       return E_INVALIDARG;
-    
+
+    // Basic validation for tiled buffers
+    if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILED) {
+      if ((pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)
+       || (pDesc->Usage != D3D11_USAGE_DEFAULT)
+       || (pDesc->CPUAccessFlags))
+        return E_INVALIDARG;
+    }
+
+    // Basic validation for tile pools
+    if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL) {
+      if ((pDesc->MiscFlags & ~D3D11_RESOURCE_MISC_TILE_POOL)
+       || (pDesc->ByteWidth % SparseMemoryPageSize)
+       || (pDesc->Usage != D3D11_USAGE_DEFAULT)
+       || (pDesc->BindFlags)
+       || (pDesc->CPUAccessFlags))
+        return E_INVALIDARG;
+    }
+
     if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED))
       pDesc->StructureByteStride = 0;
     
@@ -205,17 +275,50 @@ 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,
-          VkFormatFeatureFlags  Features) const {
-    VkFormatProperties properties = m_device->GetDXVKDevice()->adapter()->formatProperties(Format);
-    return (properties.bufferFeatures & Features) == Features;
+          VkFormatFeatureFlags2 Features) const {
+    DxvkFormatFeatures support = m_parent->GetDXVKDevice()->getFormatFeatures(Format);
+    return (support.buffer & Features) == Features;
   }
 
 
   VkMemoryPropertyFlags D3D11Buffer::GetMemoryFlags() const {
     VkMemoryPropertyFlags memoryFlags = 0;
-    
+
+    if (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED))
+      return VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+
     switch (m_desc.Usage) {
       case D3D11_USAGE_IMMUTABLE:
         memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ -250,7 +353,11 @@ namespace dxvk {
         break;
     }
     
-    if (memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT && m_device->GetOptions()->apitraceMode) {
+    bool useCached = (m_parent->GetOptions()->cachedDynamicResources == ~0u)
+                  || (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;
     }
@@ -260,7 +367,7 @@ namespace dxvk {
 
 
   Rc<DxvkBuffer> D3D11Buffer::CreateSoCounterBuffer() {
-    Rc<DxvkDevice> device = m_device->GetDXVKDevice();
+    Rc<DxvkDevice> device = m_parent->GetDXVKDevice();
 
     DxvkBufferCreateInfo info;
     info.size   = sizeof(D3D11SOCounter);
@@ -276,8 +383,17 @@ namespace dxvk {
                 | VK_ACCESS_INDIRECT_COMMAND_READ_BIT
                 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
                 | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
+    info.debugName = "SO counter";
+
     return device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
   }
+
+
+  D3D11_COMMON_BUFFER_MAP_MODE D3D11Buffer::DetermineMapMode(VkMemoryPropertyFlags MemFlags) {
+    return (MemFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+      ? D3D11_COMMON_BUFFER_MAP_MODE_DIRECT
+      : D3D11_COMMON_BUFFER_MAP_MODE_NONE;
+  }
   
 
   D3D11Buffer* GetCommonBuffer(ID3D11Resource* pResource) {

src/d3d11/d3d11_buffer.h

@@ -1,17 +1,18 @@
 #pragma once
 
+#include "../dxvk/dxvk_cs.h"
 #include "../dxvk/dxvk_device.h"
 
 #include "../d3d10/d3d10_buffer.h"
 
 #include "d3d11_device_child.h"
 #include "d3d11_interfaces.h"
+#include "d3d11_on_12.h"
 #include "d3d11_resource.h"
 
 namespace dxvk {
   
   class D3D11Device;
-  class D3D11DeviceContext;
 
 
   /**
@@ -41,16 +42,15 @@ 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(
             REFIID  riid,
             void**  ppvObject) final;
     
-    void STDMETHODCALLTYPE GetDevice(
-            ID3D11Device **ppDevice) final;
-    
     void STDMETHODCALLTYPE GetType(
             D3D11_RESOURCE_DIMENSION *pResourceDimension) final;
     
@@ -61,6 +61,8 @@ namespace dxvk {
     void STDMETHODCALLTYPE GetDesc(
             D3D11_BUFFER_DESC *pDesc) final;
     
+    void STDMETHODCALLTYPE SetDebugName(const char* pName) final;
+
     bool CheckViewCompatibility(
             UINT                BindFlags,
             DXGI_FORMAT         Format) const;
@@ -69,26 +71,46 @@ namespace dxvk {
       return &m_desc;
     }
 
+    BOOL IsTilePool() const {
+      return bool(m_desc.MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL);
+    }
+
     D3D11_COMMON_BUFFER_MAP_MODE GetMapMode() const {
-      return (m_buffer->memFlags() & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
-        ? D3D11_COMMON_BUFFER_MAP_MODE_DIRECT
-        : D3D11_COMMON_BUFFER_MAP_MODE_NONE;
+      return m_mapMode;
+    }
+
+    uint64_t GetCookie() const {
+      return m_cookie;
     }
 
     Rc<DxvkBuffer> GetBuffer() const {
       return m_buffer;
     }
+
+    Rc<DxvkSparsePageAllocator> GetSparseAllocator() const {
+      return m_sparseAllocator;
+    }
     
     DxvkBufferSlice GetBufferSlice() const {
-      return GetBufferSlice(0, m_desc.ByteWidth);
+      return DxvkBufferSlice(m_buffer, 0, m_desc.ByteWidth);
     }
     
     DxvkBufferSlice GetBufferSlice(VkDeviceSize offset) const {
-      return GetBufferSlice(offset, m_desc.ByteWidth - offset);
+      VkDeviceSize size = m_desc.ByteWidth;
+      offset = std::min(offset, size);
+      return DxvkBufferSlice(m_buffer, offset, size - offset);
     }
     
     DxvkBufferSlice GetBufferSlice(VkDeviceSize offset, VkDeviceSize length) const {
-      return DxvkBufferSlice(m_buffer, offset, length);
+      VkDeviceSize size = m_desc.ByteWidth;
+      offset = std::min(offset, size);
+      return DxvkBufferSlice(m_buffer, offset, std::min(length, size - offset));
+    }
+
+    VkDeviceSize GetRemainingSize(VkDeviceSize offset) const {
+      VkDeviceSize size = m_desc.ByteWidth;
+      offset = std::min(offset, size);
+      return size - offset;
     }
 
     DxvkBufferSlice GetSOCounter() {
@@ -97,23 +119,47 @@ namespace dxvk {
         : DxvkBufferSlice();
     }
     
-    DxvkBufferSliceHandle AllocSlice() {
-      return m_buffer->allocSlice();
+    Rc<DxvkResourceAllocation> AllocSlice(DxvkLocalAllocationCache* cache) {
+      return m_buffer->allocateStorage(cache);
     }
     
-    DxvkBufferSliceHandle DiscardSlice() {
-      m_mapped = m_buffer->allocSlice();
-      return m_mapped;
+    Rc<DxvkResourceAllocation> DiscardSlice(DxvkLocalAllocationCache* cache) {
+      auto allocation = m_buffer->allocateStorage(cache);
+      m_mapPtr = allocation->mapPtr();
+      return allocation;
     }
 
-    DxvkBufferSliceHandle GetMappedSlice() const {
-      return m_mapped;
+    void* GetMapPtr() const {
+      return m_mapPtr;
     }
 
     D3D10Buffer* GetD3D10Iface() {
       return &m_d3d10;
     }
 
+    bool HasSequenceNumber() const {
+      return m_mapMode != D3D11_COMMON_BUFFER_MAP_MODE_NONE
+          && !(m_desc.MiscFlags & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS)
+          && !(m_desc.BindFlags);
+    }
+
+    void TrackSequenceNumber(uint64_t Seq) {
+      m_seq = Seq;
+    }
+
+    uint64_t GetSequenceNumber() {
+      return HasSequenceNumber() ? m_seq
+        : 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
      * 
@@ -123,26 +169,48 @@ 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:
     
-    const Com<D3D11Device>      m_device;
-    const D3D11_BUFFER_DESC     m_desc;
+    D3D11_BUFFER_DESC             m_desc;
+    D3D11_ON_12_RESOURCE_INFO     m_11on12;
+    D3D11_COMMON_BUFFER_MAP_MODE  m_mapMode;
     
-    Rc<DxvkBuffer>              m_buffer;
-    Rc<DxvkBuffer>              m_soCounter;
-    DxvkBufferSliceHandle       m_mapped;
+    Rc<DxvkBuffer>                m_buffer;
+    uint64_t                      m_cookie = 0u;
 
-    D3D11DXGIResource           m_resource;
-    D3D10Buffer                 m_d3d10;
+    Rc<DxvkBuffer>                m_soCounter;
+    Rc<DxvkSparsePageAllocator>   m_sparseAllocator;
+    uint64_t                      m_seq = 0ull;
+
+    void*                         m_mapPtr = nullptr;
+
+    D3D11DXGIResource             m_resource;
+    D3D10Buffer                   m_d3d10;
 
     BOOL CheckFormatFeatureSupport(
             VkFormat              Format,
-            VkFormatFeatureFlags  Features) const;
+            VkFormatFeatureFlags2 Features) const;
     
     VkMemoryPropertyFlags GetMemoryFlags() const;
 
     Rc<DxvkBuffer> CreateSoCounterBuffer();
 
+    static D3D11_COMMON_BUFFER_MAP_MODE DetermineMapMode(
+            VkMemoryPropertyFlags MemFlags);
+
   };
 
 

src/d3d11/d3d11_class_linkage.cpp

@@ -5,7 +5,7 @@ namespace dxvk {
   
   D3D11ClassLinkage::D3D11ClassLinkage(
           D3D11Device*                pDevice)
-  : m_device(pDevice) {
+  : D3D11DeviceChild<ID3D11ClassLinkage>(pDevice) {
     
   }
   
@@ -28,17 +28,15 @@ 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;
   }
   
   
-  void STDMETHODCALLTYPE D3D11ClassLinkage::GetDevice(ID3D11Device** ppDevice) {
-    *ppDevice = m_device.ref();
-  }
-  
-  
   HRESULT STDMETHODCALLTYPE D3D11ClassLinkage::CreateClassInstance(
           LPCSTR              pClassTypeName,
           UINT                ConstantBufferOffset,

src/d3d11/d3d11_class_linkage.h

@@ -20,9 +20,6 @@ namespace dxvk {
             REFIID  riid,
             void**  ppvObject) final;
     
-    void STDMETHODCALLTYPE GetDevice(
-            ID3D11Device **ppDevice) final;
-    
     HRESULT STDMETHODCALLTYPE CreateClassInstance(
             LPCSTR              pClassTypeName,
             UINT                ConstantBufferOffset,
@@ -36,10 +33,6 @@ namespace dxvk {
             UINT                InstanceIndex,
             ID3D11ClassInstance **ppInstance);  
     
-  private:
-    
-    Com<D3D11Device> m_device;
-    
   };
   
 }

src/d3d11/d3d11_cmd.h

@@ -10,20 +10,12 @@ namespace dxvk {
    * Used to identify the type of command
    * data most recently added to a CS chunk.
    */
-  enum class D3D11CmdType {
+  enum class D3D11CmdType : uint32_t {
+    None,
     DrawIndirect,
     DrawIndirectIndexed,
-  };
-
-
-  /**
-   * \brief Command data header
-   * 
-   * Stores the command type. All command
-   * data structs must inherit this struct.
-   */
-  struct D3D11CmdData {
-    D3D11CmdType        type;
+    Draw,
+    DrawIndexed,
   };
 
 
@@ -34,10 +26,10 @@ namespace dxvk {
    * the first draw, as well as the number of
    * draws to execute.
    */
-  struct D3D11CmdDrawIndirectData : public D3D11CmdData {
+  struct D3D11CmdDrawIndirectData {
     uint32_t            offset;
     uint32_t            count;
     uint32_t            stride;
   };
 
-}
+}

src/d3d11/d3d11_cmdlist.cpp

@@ -1,12 +1,14 @@
 #include "d3d11_cmdlist.h"
 #include "d3d11_device.h"
+#include "d3d11_buffer.h"
+#include "d3d11_texture.h"
 
 namespace dxvk {
     
   D3D11CommandList::D3D11CommandList(
           D3D11Device*  pDevice,
           UINT          ContextFlags)
-  : m_device      (pDevice),
+  : D3D11DeviceChild<ID3D11CommandList>(pDevice),
     m_contextFlags(ContextFlags) { }
   
   
@@ -28,63 +30,121 @@ 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;
   }
   
   
-  void STDMETHODCALLTYPE D3D11CommandList::GetDevice(ID3D11Device **ppDevice) {
-    *ppDevice = ref(m_device);
-  }
-  
-  
   UINT STDMETHODCALLTYPE D3D11CommandList::GetContextFlags() {
     return m_contextFlags;
   }
   
   
-  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);
-
-    MarkSubmitted();
+  uint64_t D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) {
+    m_chunks.push_back(std::move(Chunk));
+    return m_chunks.size() - 1;
   }
   
   
-  void D3D11CommandList::EmitToCsThread(DxvkCsThread* CsThread) {
+  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));
+    }
+
+    // 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)
-      CsThread->dispatchChunk(DxvkCsChunkRef(chunk));
-    
-    MarkSubmitted();
-  }
-  
-  
-  void D3D11CommandList::MarkSubmitted() {
-    if (m_submitted.exchange(true) && !m_warned.exchange(true)
-     && m_device->GetOptions()->dcSingleUseMode) {
-      Logger::warn(
-        "D3D11: Command list submitted multiple times,\n"
-        "       but d3d11.dcSingleUseMode is enabled");
+    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);
     }
   }
   
-}
+  
+  void D3D11CommandList::TrackResourceUsage(
+          ID3D11Resource*     pResource,
+          D3D11_RESOURCE_DIMENSION ResourceType,
+          UINT                Subresource,
+          uint64_t            ChunkId) {
+    TrackedResource entry;
+    entry.ref = D3D11ResourceRef(pResource, Subresource, ResourceType);
+    entry.chunkId = ChunkId;
+
+    m_resources.push_back(std::move(entry));
+  }
+
+
+  void D3D11CommandList::TrackResourceSequenceNumber(
+    const D3D11ResourceRef&   Resource,
+          uint64_t            Seq) {
+    ID3D11Resource* iface = Resource.Get();
+
+    switch (Resource.GetType()) {
+      case D3D11_RESOURCE_DIMENSION_UNKNOWN:
+        break;
+
+      case D3D11_RESOURCE_DIMENSION_BUFFER: {
+        auto impl = static_cast<D3D11Buffer*>(iface);
+        impl->TrackSequenceNumber(Seq);
+      } break;
+
+      case D3D11_RESOURCE_DIMENSION_TEXTURE1D: {
+        auto impl = static_cast<D3D11Texture1D*>(iface)->GetCommonTexture();
+        impl->TrackSequenceNumber(Resource.GetSubresource(), Seq);
+      } break;
+
+      case D3D11_RESOURCE_DIMENSION_TEXTURE2D: {
+        auto impl = static_cast<D3D11Texture2D*>(iface)->GetCommonTexture();
+        impl->TrackSequenceNumber(Resource.GetSubresource(), Seq);
+      } break;
+
+      case D3D11_RESOURCE_DIMENSION_TEXTURE3D: {
+        auto impl = static_cast<D3D11Texture3D*>(iface)->GetCommonTexture();
+        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:
@@ -18,36 +22,43 @@ namespace dxvk {
             REFIID  riid,
             void**  ppvObject) final;
     
-    void STDMETHODCALLTYPE GetDevice(
-            ID3D11Device **ppDevice) final;
-    
     UINT STDMETHODCALLTYPE GetContextFlags() final;
     
-    void AddChunk(
-            DxvkCsChunkRef&&    Chunk);
-
     void AddQuery(
             D3D11Query*         pQuery);
     
-    void EmitToCommandList(
-            ID3D11CommandList*  pCommandList);
-    
+    uint64_t AddChunk(
+            DxvkCsChunkRef&&    Chunk);
+
+    uint64_t AddCommandList(
+            D3D11CommandList*   pCommandList);
+
     void EmitToCsThread(
-            DxvkCsThread*       CsThread);
-    
+      const D3D11ChunkDispatchProc& DispatchProc);
+
+    void TrackResourceUsage(
+            ID3D11Resource*     pResource,
+            D3D11_RESOURCE_DIMENSION ResourceType,
+            UINT                Subresource,
+            uint64_t            ChunkId);
+
   private:
-    
-    D3D11Device* const m_device;
-    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<TrackedResource>        m_resources;
 
-    std::atomic<bool> m_submitted = { false };
-    std::atomic<bool> m_warned    = { false };
-
-    void MarkSubmitted();
+    void TrackResourceSequenceNumber(
+      const D3D11ResourceRef&   Resource,
+            uint64_t            Seq);
     
   };
   
-}
+}

src/d3d11/d3d11_context_def.cpp

@@ -7,20 +7,9 @@ namespace dxvk {
           D3D11Device*    pParent,
     const Rc<DxvkDevice>& Device,
           UINT            ContextFlags)
-  : D3D11DeviceContext(pParent, Device, GetCsChunkFlags(pParent)),
-    m_contextFlags(ContextFlags),
+  : D3D11CommonContext<D3D11DeferredContext>(pParent, Device, ContextFlags, 0u),
     m_commandList (CreateCommandList()) {
-    ClearState();
-  }
-  
-  
-  D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE D3D11DeferredContext::GetType() {
-    return D3D11_DEVICE_CONTEXT_DEFERRED;
-  }
-  
-  
-  UINT STDMETHODCALLTYPE D3D11DeferredContext::GetContextFlags() {
-    return m_contextFlags;
+    ResetContextState();
   }
   
   
@@ -146,14 +135,26 @@ namespace dxvk {
           BOOL                RestoreContextState) {
     D3D10DeviceLock lock = LockContext();
 
+    // Clear state so that the command list can't observe any
+    // current context state. The command list itself will clean
+    // up after execution to ensure that no state changes done
+    // by the command list are visible to the immediate context.
+    ResetCommandListState();
+
+    // Flush any outstanding commands so that
+    // we don't mess up the execution order
     FlushCsChunk();
     
-    static_cast<D3D11CommandList*>(pCommandList)->EmitToCommandList(m_commandList.ptr());
+    // Record any chunks from the given command list into the
+    // current command list and deal with context state
+    auto commandList = static_cast<D3D11CommandList*>(pCommandList);
+    m_chunkId = m_commandList->AddCommandList(commandList);
     
+    // Restore deferred context state
     if (RestoreContextState)
-      RestoreState();
+      RestoreCommandListState();
     else
-      ClearState();
+      ResetContextState();
   }
   
   
@@ -162,19 +163,34 @@ namespace dxvk {
           ID3D11CommandList   **ppCommandList) {
     D3D10DeviceLock lock = LockContext();
 
+    // End all queries that were left active by the app
     FinalizeQueries();
+
+    // Clean up command list state so that the any state changed
+    // 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
     FlushCsChunk();
     
-    if (ppCommandList != nullptr)
+    if (ppCommandList)
       *ppCommandList = m_commandList.ref();
+
+    // Create a clean command list, and if requested, restore all
+    // previously set context state. Otherwise, reset the context.
+    // Any use of ExecuteCommandList will reset command list state
+    // before the command list is actually executed.
     m_commandList = CreateCommandList();
+    m_chunkId = 0;
     
     if (RestoreDeferredContextState)
-      RestoreState();
+      RestoreCommandListState();
     else
-      ClearState();
+      ResetContextState();
     
     m_mappedResources.clear();
+    ResetStagingBuffer();
     return S_OK;
   }
   
@@ -190,51 +206,37 @@ namespace dxvk {
     if (unlikely(!pResource || !pMappedResource))
       return E_INVALIDARG;
     
-    D3D11_RESOURCE_DIMENSION resourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN;
-    pResource->GetType(&resourceDim);
-    
-    if (MapType == D3D11_MAP_WRITE_DISCARD) {
-      D3D11DeferredContextMapEntry entry;
-      
-      HRESULT status = resourceDim == D3D11_RESOURCE_DIMENSION_BUFFER
-        ? MapBuffer(pResource,              MapType, MapFlags, &entry)
-        : MapImage (pResource, Subresource, MapType, MapFlags, &entry);
-      
-      if (unlikely(FAILED(status))) {
-        *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
-        return status;
-      }
-      
-      // Adding a new map entry actually overrides the
-      // old one in practice because the lookup function
-      // scans the array in reverse order
-      m_mappedResources.push_back(std::move(entry));
-      
-      // Fill mapped resource structure
-      pMappedResource->pData      = entry.MapPointer;
-      pMappedResource->RowPitch   = entry.RowPitch;
-      pMappedResource->DepthPitch = entry.DepthPitch;
-      return S_OK;
-    } else if (MapType == D3D11_MAP_WRITE_NO_OVERWRITE) {
+    if (likely(MapType == D3D11_MAP_WRITE_DISCARD)) {
+      D3D11_RESOURCE_DIMENSION resourceDim;
+      pResource->GetType(&resourceDim);
+
+      return likely(resourceDim == D3D11_RESOURCE_DIMENSION_BUFFER)
+        ? MapBuffer(pResource, pMappedResource)
+        : MapImage(pResource, Subresource, pMappedResource);
+    } else if (likely(MapType == D3D11_MAP_WRITE_NO_OVERWRITE)) {
       // The resource must be mapped with D3D11_MAP_WRITE_DISCARD
       // before it can be mapped with D3D11_MAP_WRITE_NO_OVERWRITE.
-      auto entry = FindMapEntry(pResource, Subresource);
-      
-      if (unlikely(entry == m_mappedResources.rend())) {
-        *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
+      D3D11_RESOURCE_DIMENSION resourceDim;
+      pResource->GetType(&resourceDim);
+
+      if (likely(resourceDim == D3D11_RESOURCE_DIMENSION_BUFFER)) {
+        D3D11_MAPPED_SUBRESOURCE sr = FindMapEntry(static_cast<D3D11Buffer*>(pResource)->GetCookie());
+        pMappedResource->pData = sr.pData;
+
+        if (unlikely(!sr.pData))
+          return D3D11_ERROR_DEFERRED_CONTEXT_MAP_WITHOUT_INITIAL_DISCARD;
+
+        pMappedResource->RowPitch = sr.RowPitch;
+        pMappedResource->DepthPitch = sr.DepthPitch;
+        return S_OK;
+      } else {
+        // Images cannot be mapped with NO_OVERWRITE
+        pMappedResource->pData = nullptr;
         return E_INVALIDARG;
       }
-      
-      // Return same memory region as earlier
-      entry->MapType = D3D11_MAP_WRITE_NO_OVERWRITE;
-      
-      pMappedResource->pData      = entry->MapPointer;
-      pMappedResource->RowPitch   = entry->RowPitch;
-      pMappedResource->DepthPitch = entry->DepthPitch;
-      return S_OK;
     } else {
       // Not allowed on deferred contexts
-      *pMappedResource = D3D11_MAPPED_SUBRESOURCE();
+      pMappedResource->pData = nullptr;
       return E_INVALIDARG;
     }
   }
@@ -259,51 +261,28 @@ namespace dxvk {
 
   HRESULT D3D11DeferredContext::MapBuffer(
           ID3D11Resource*               pResource,
-          D3D11_MAP                     MapType,
-          UINT                          MapFlags,
-          D3D11DeferredContextMapEntry* pMapEntry) {
+          D3D11_MAPPED_SUBRESOURCE*     pMappedResource) {
     D3D11Buffer* pBuffer = static_cast<D3D11Buffer*>(pResource);
-    
+
     if (unlikely(pBuffer->GetMapMode() == D3D11_COMMON_BUFFER_MAP_MODE_NONE)) {
       Logger::err("D3D11: Cannot map a device-local buffer");
+      pMappedResource->pData = nullptr;
       return E_INVALIDARG;
     }
-    
-    pMapEntry->pResource    = pResource;
-    pMapEntry->Subresource  = 0;
-    pMapEntry->MapType      = D3D11_MAP_WRITE_DISCARD;
-    pMapEntry->RowPitch     = pBuffer->Desc()->ByteWidth;
-    pMapEntry->DepthPitch   = pBuffer->Desc()->ByteWidth;
-    
-    if (likely(m_csFlags.test(DxvkCsChunkFlag::SingleUse))) {
-      // For resources that cannot be written by the GPU,
-      // we may write to the buffer resource directly and
-      // just swap in the buffer slice as needed.
-      auto bufferSlice = pBuffer->AllocSlice();
-      pMapEntry->MapPointer = bufferSlice.mapPtr;
 
-      EmitCs([
-        cDstBuffer = pBuffer->GetBuffer(),
-        cPhysSlice = bufferSlice
-      ] (DxvkContext* ctx) {
-        ctx->invalidateBuffer(cDstBuffer, cPhysSlice);
-      });
-    } else {
-      // For GPU-writable resources, we need a data slice
-      // to perform the update operation at execution time.
-      auto dataSlice = AllocUpdateBufferSlice(pBuffer->Desc()->ByteWidth);
-      pMapEntry->MapPointer = dataSlice.ptr();
+    auto bufferSlice = pBuffer->AllocSlice(&m_allocationCache);
+    pMappedResource->pData        = bufferSlice->mapPtr();
+    pMappedResource->RowPitch     = pBuffer->Desc()->ByteWidth;
+    pMappedResource->DepthPitch   = pBuffer->Desc()->ByteWidth;
 
-      EmitCs([
-        cDstBuffer = pBuffer->GetBuffer(),
-        cDataSlice = dataSlice
-      ] (DxvkContext* ctx) {
-        DxvkBufferSliceHandle slice = cDstBuffer->allocSlice();
-        std::memcpy(slice.mapPtr, cDataSlice.ptr(), cDataSlice.length());
-        ctx->invalidateBuffer(cDstBuffer, slice);
-      });
-    }
-    
+    EmitCs([
+      cDstBuffer = pBuffer->GetBuffer(),
+      cDstSlice  = std::move(bufferSlice)
+    ] (DxvkContext* ctx) {
+      ctx->invalidateBuffer(cDstBuffer, Rc<DxvkResourceAllocation>(cDstSlice));
+    });
+
+    AddMapEntry(pBuffer->GetCookie(), *pMappedResource);
     return S_OK;
   }
   
@@ -311,87 +290,82 @@ namespace dxvk {
   HRESULT D3D11DeferredContext::MapImage(
           ID3D11Resource*               pResource,
           UINT                          Subresource,
-          D3D11_MAP                     MapType,
-          UINT                          MapFlags,
-          D3D11DeferredContextMapEntry* pMapEntry) {
-    const D3D11CommonTexture* pTexture = GetCommonTexture(pResource);
-    const Rc<DxvkImage> image = pTexture->GetImage();
+          D3D11_MAPPED_SUBRESOURCE*     pMappedResource) {
+    D3D11CommonTexture* pTexture = GetCommonTexture(pResource);
     
-    if (unlikely(pTexture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE)) {
-      Logger::err("D3D11: Cannot map a device-local image");
+    if (unlikely(Subresource >= pTexture->CountSubresources())) {
+      pMappedResource->pData = nullptr;
       return E_INVALIDARG;
     }
 
-    if (unlikely(Subresource >= pTexture->CountSubresources()))
+    if (unlikely(pTexture->Desc()->Usage != D3D11_USAGE_DYNAMIC)) {
+      pMappedResource->pData = nullptr;
       return E_INVALIDARG;
-    
-    VkFormat packedFormat = m_parent->LookupPackedFormat(
-      pTexture->Desc()->Format, pTexture->GetFormatMode()).Format;
-    
-    auto formatInfo = imageFormatInfo(packedFormat);
-    auto subresource = pTexture->GetSubresourceFromIndex(
-        formatInfo->aspectMask, Subresource);
-    
-    VkExtent3D levelExtent = image->mipLevelExtent(subresource.mipLevel);
-    VkExtent3D blockCount = util::computeBlockCount(
-      levelExtent, formatInfo->blockSize);
-    
-    VkDeviceSize eSize = formatInfo->elementSize;
-    VkDeviceSize xSize = blockCount.width  * eSize;
-    VkDeviceSize ySize = blockCount.height * xSize;
-    VkDeviceSize zSize = blockCount.depth  * ySize;
+    }
 
-    auto dataSlice = AllocUpdateBufferSlice(zSize);
-    
-    pMapEntry->pResource    = pResource;
-    pMapEntry->Subresource  = Subresource;
-    pMapEntry->MapType      = D3D11_MAP_WRITE_DISCARD;
-    pMapEntry->RowPitch     = xSize;
-    pMapEntry->DepthPitch   = ySize;
-    pMapEntry->MapPointer   = dataSlice.ptr();
+    VkFormat packedFormat = pTexture->GetPackedFormat();
+    auto formatInfo = lookupFormatInfo(packedFormat);
+    auto layout = pTexture->GetSubresourceLayout(formatInfo->aspectMask, Subresource);
 
-    EmitCs([
-      cImage              = pTexture->GetImage(),
-      cSubresource        = pTexture->GetSubresourceFromIndex(
-        VK_IMAGE_ASPECT_COLOR_BIT, Subresource),
-      cDataSlice          = dataSlice,
-      cDataPitchPerRow    = pMapEntry->RowPitch,
-      cDataPitchPerLayer  = pMapEntry->DepthPitch,
-      cPackedFormat       = GetPackedDepthStencilFormat(pTexture->Desc()->Format)
-    ] (DxvkContext* ctx) {
-      VkImageSubresourceLayers srLayers;
-      srLayers.aspectMask     = cSubresource.aspectMask;
-      srLayers.mipLevel       = cSubresource.mipLevel;
-      srLayers.baseArrayLayer = cSubresource.arrayLayer;
-      srLayers.layerCount     = 1;
+    if (pTexture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) {
+      auto storage = pTexture->AllocStorage();
+      auto mapPtr = storage->mapPtr();
 
-      VkOffset3D mipLevelOffset = { 0, 0, 0 };
-      VkExtent3D mipLevelExtent = cImage->mipLevelExtent(srLayers.mipLevel);
-      
-      if (cPackedFormat == VK_FORMAT_UNDEFINED) {
-        ctx->updateImage(
-          cImage, srLayers,
-          mipLevelOffset,
-          mipLevelExtent,
-          cDataSlice.ptr(),
-          cDataPitchPerRow,
-          cDataPitchPerLayer);
-      } else {
-        ctx->updateDepthStencilImage(
-          cImage, srLayers,
-          VkOffset2D { mipLevelOffset.x,     mipLevelOffset.y      },
-          VkExtent2D { mipLevelExtent.width, mipLevelExtent.height },
-          cDataSlice.ptr(),
-          cDataPitchPerRow,
-          cDataPitchPerLayer,
-          cPackedFormat);
-      }
-    });
+      EmitCs([
+        cImage = pTexture->GetImage(),
+        cStorage = std::move(storage)
+      ] (DxvkContext* ctx) {
+        ctx->invalidateImage(cImage, Rc<DxvkResourceAllocation>(cStorage));
+        ctx->initImage(cImage, cImage->getAvailableSubresources(), VK_IMAGE_LAYOUT_PREINITIALIZED);
+      });
 
-    return S_OK;
+      pMappedResource->RowPitch   = layout.RowPitch;
+      pMappedResource->DepthPitch = layout.DepthPitch;
+      pMappedResource->pData      = mapPtr;
+      return S_OK;
+    } else {
+      auto dataSlice = AllocStagingBuffer(layout.Size);
+
+      pMappedResource->RowPitch   = layout.RowPitch;
+      pMappedResource->DepthPitch = layout.DepthPitch;
+      pMappedResource->pData      = dataSlice.mapPtr(0);
+
+      auto subresource = pTexture->GetSubresourceFromIndex(formatInfo->aspectMask, Subresource);
+      auto mipExtent = pTexture->MipLevelExtent(subresource.mipLevel);
+
+      UpdateImage(pTexture, &subresource,
+        VkOffset3D { 0, 0, 0 }, mipExtent,
+        std::move(dataSlice));
+
+      return S_OK;
+    }
   }
   
   
+  void D3D11DeferredContext::UpdateMappedBuffer(
+          D3D11Buffer*                  pDstBuffer,
+          UINT                          Offset,
+          UINT                          Length,
+    const void*                         pSrcData,
+          UINT                          CopyFlags) {
+    void* mapPtr = nullptr;
+
+    if (unlikely(CopyFlags == D3D11_COPY_NO_OVERWRITE))
+      mapPtr = FindMapEntry(pDstBuffer->GetCookie()).pData;
+
+    if (likely(!mapPtr)) {
+      // The caller validates the map mode, so we can
+      // safely ignore the MapBuffer return value here
+      D3D11_MAPPED_SUBRESOURCE mapInfo;
+      MapBuffer(pDstBuffer, &mapInfo);
+      AddMapEntry(pDstBuffer->GetCookie(), mapInfo);
+      mapPtr = mapInfo.pData;
+    }
+
+    std::memcpy(reinterpret_cast<char*>(mapPtr) + Offset, pSrcData, Length);
+  }
+
+
   void D3D11DeferredContext::FinalizeQueries() {
     for (auto& query : m_queriesBegun) {
       m_commandList->AddQuery(query.ptr());
@@ -407,20 +381,59 @@ namespace dxvk {
 
 
   Com<D3D11CommandList> D3D11DeferredContext::CreateCommandList() {
-    return new D3D11CommandList(m_parent, m_contextFlags);
+    return new D3D11CommandList(m_parent, m_flags);
   }
   
   
   void D3D11DeferredContext::EmitCsChunk(DxvkCsChunkRef&& chunk) {
-    m_commandList->AddChunk(std::move(chunk));
+    m_chunkId = m_commandList->AddChunk(std::move(chunk));
   }
 
 
-  DxvkCsChunkFlags D3D11DeferredContext::GetCsChunkFlags(
-          D3D11Device*                  pDevice) {
-    return pDevice->GetOptions()->dcSingleUseMode
-      ? DxvkCsChunkFlags(DxvkCsChunkFlag::SingleUse)
-      : DxvkCsChunkFlags();
+  uint64_t D3D11DeferredContext::GetCurrentChunkId() const {
+    return m_csChunk->empty() ? m_chunkId : m_chunkId + 1;
   }
 
-}
+
+  void D3D11DeferredContext::TrackTextureSequenceNumber(
+          D3D11CommonTexture*         pResource,
+          UINT                        Subresource) {
+    m_commandList->TrackResourceUsage(
+      pResource->GetInterface(),
+      pResource->GetDimension(),
+      Subresource, GetCurrentChunkId());
+  }
+
+
+  void D3D11DeferredContext::TrackBufferSequenceNumber(
+          D3D11Buffer*                pResource) {
+    m_commandList->TrackResourceUsage(pResource,
+      D3D11_RESOURCE_DIMENSION_BUFFER, 0,
+      GetCurrentChunkId());
+  }
+
+
+  D3D11_MAPPED_SUBRESOURCE D3D11DeferredContext::FindMapEntry(
+          uint64_t                      Cookie) {
+    // Recently mapped resources as well as entries with
+    // up-to-date map infos will be located at the end
+    // of the resource array, so scan in reverse order.
+    size_t size = m_mappedResources.size();
+
+    for (size_t i = 1; i <= size; i++) {
+      const auto& entry = m_mappedResources[size - i];
+
+      if (entry.ResourceCookie == Cookie)
+        return entry.MapInfo;
+    }
+
+    return D3D11_MAPPED_SUBRESOURCE();
+  }
+
+  void D3D11DeferredContext::AddMapEntry(
+          uint64_t                      Cookie,
+    const D3D11_MAPPED_SUBRESOURCE&     MapInfo) {
+    m_mappedResources.push_back({ Cookie, MapInfo });
+  }
+
+}

src/d3d11/d3d11_context_def.h

@@ -1,26 +1,19 @@
 #pragma once
 
-#include "d3d11_buffer.h"
 #include "d3d11_cmdlist.h"
 #include "d3d11_context.h"
-#include "d3d11_texture.h"
 
-#include <algorithm>
 #include <vector>
 
 namespace dxvk {
   
   struct D3D11DeferredContextMapEntry {
-    Com<ID3D11Resource>     pResource;
-    UINT                    Subresource;
-    D3D11_MAP               MapType;
-    UINT                    RowPitch;
-    UINT                    DepthPitch;
-    void*                   MapPointer;
+    uint64_t                  ResourceCookie = 0u;
+    D3D11_MAPPED_SUBRESOURCE  MapInfo = { };
   };
   
-  class D3D11DeferredContext : public D3D11DeviceContext {
-    
+  class D3D11DeferredContext : public D3D11CommonContext<D3D11DeferredContext> {
+    friend class D3D11CommonContext<D3D11DeferredContext>;
   public:
     
     D3D11DeferredContext(
@@ -28,10 +21,6 @@ namespace dxvk {
       const Rc<DxvkDevice>& Device,
             UINT            ContextFlags);
     
-    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType();
-    
-    UINT STDMETHODCALLTYPE GetContextFlags();
-    
     HRESULT STDMETHODCALLTYPE GetData(
             ID3D11Asynchronous*         pAsync,
             void*                       pData,
@@ -81,10 +70,12 @@ namespace dxvk {
            ID3DDeviceContextState*           pState,
            ID3DDeviceContextState**          ppPreviousState);
 
+    D3D10DeviceLock LockContext() {
+      return D3D10DeviceLock();
+    }
+
   private:
     
-    const UINT m_contextFlags;
-    
     // Command list that we're recording
     Com<D3D11CommandList> m_commandList;
     
@@ -96,36 +87,50 @@ 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_MAP                     MapType,
-            UINT                          MapFlags,
-            D3D11DeferredContextMapEntry* pMapEntry);
+            D3D11_MAPPED_SUBRESOURCE*     pMappedResource);
     
     HRESULT MapImage(
             ID3D11Resource*               pResource,
             UINT                          Subresource,
-            D3D11_MAP                     MapType,
-            UINT                          MapFlags,
-            D3D11DeferredContextMapEntry* pMapEntry);
-    
+            D3D11_MAPPED_SUBRESOURCE*     pMappedResource);
+
+    void UpdateMappedBuffer(
+            D3D11Buffer*                  pDstBuffer,
+            UINT                          Offset,
+            UINT                          Length,
+      const void*                         pSrcData,
+            UINT                          CopyFlags);
+
     void FinalizeQueries();
 
     Com<D3D11CommandList> CreateCommandList();
     
     void EmitCsChunk(DxvkCsChunkRef&& chunk);
 
+    uint64_t GetCurrentChunkId() const;
+
+    void TrackTextureSequenceNumber(
+            D3D11CommonTexture*           pResource,
+            UINT                          Subresource);
+
+    void TrackBufferSequenceNumber(
+            D3D11Buffer*                  pResource);
+
+    D3D11_MAPPED_SUBRESOURCE FindMapEntry(
+            uint64_t                      Coookie);
+
+    void AddMapEntry(
+            uint64_t                      Cookie,
+      const D3D11_MAPPED_SUBRESOURCE&     MapInfo);
+
     static DxvkCsChunkFlags GetCsChunkFlags(
             D3D11Device*                  pDevice);
     
-    auto FindMapEntry(ID3D11Resource* pResource, UINT Subresource) {
-      return std::find_if(m_mappedResources.rbegin(), m_mappedResources.rend(),
-        [pResource, Subresource] (const D3D11DeferredContextMapEntry& entry) {
-          return entry.pResource   == pResource
-              && entry.Subresource == Subresource;
-        });
-    }
-    
   };
   
 }

src/d3d11/d3d11_context_ext.cpp

@@ -1,32 +1,46 @@
-#include "d3d11_context.h"
+#include <vector>
+#include <utility>
+#include <cstring>
+
+#include "d3d11_device.h"
+#include "d3d11_context_imm.h"
+#include "d3d11_context_def.h"
+#include "d3d11_cuda.h"
+
+#include "../util/log/log.h"
 
 namespace dxvk {
   
-  D3D11DeviceContextExt::D3D11DeviceContextExt(
-          D3D11DeviceContext*     pContext)
+  template<typename ContextType>
+  D3D11DeviceContextExt<ContextType>::D3D11DeviceContextExt(
+          ContextType*          pContext)
   : m_ctx(pContext) {
     
   }
   
   
-  ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::AddRef() {
+  template<typename ContextType>
+  ULONG STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::AddRef() {
     return m_ctx->AddRef();
   }
   
   
-  ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::Release() {
+  template<typename ContextType>
+  ULONG STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::Release() {
     return m_ctx->Release();
   }
   
   
-  HRESULT STDMETHODCALLTYPE D3D11DeviceContextExt::QueryInterface(
+  template<typename ContextType>
+  HRESULT STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::QueryInterface(
           REFIID                  riid,
           void**                  ppvObject) {
     return m_ctx->QueryInterface(riid, ppvObject);
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirect(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::MultiDrawIndirect(
           UINT                    DrawCount,
           ID3D11Buffer*           pBufferForArgs,
           UINT                    ByteOffsetForArgs,
@@ -34,17 +48,21 @@ namespace dxvk {
     D3D10DeviceLock lock = m_ctx->LockContext();
     m_ctx->SetDrawBuffers(pBufferForArgs, nullptr);
     
+    if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
+      m_ctx->ApplyDirtyGraphicsBindings();
+
     m_ctx->EmitCs([
       cCount  = DrawCount,
       cOffset = ByteOffsetForArgs,
       cStride = ByteStrideForArgs
     ] (DxvkContext* ctx) {
-      ctx->drawIndirect(cOffset, cCount, cStride);
+      ctx->drawIndirect(cOffset, cCount, cStride, false);
     });
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirect(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::MultiDrawIndexedIndirect(
           UINT                    DrawCount,
           ID3D11Buffer*           pBufferForArgs,
           UINT                    ByteOffsetForArgs,
@@ -52,17 +70,21 @@ namespace dxvk {
     D3D10DeviceLock lock = m_ctx->LockContext();
     m_ctx->SetDrawBuffers(pBufferForArgs, nullptr);
     
+    if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
+      m_ctx->ApplyDirtyGraphicsBindings();
+
     m_ctx->EmitCs([
       cCount  = DrawCount,
       cOffset = ByteOffsetForArgs,
       cStride = ByteStrideForArgs
     ] (DxvkContext* ctx) {
-      ctx->drawIndexedIndirect(cOffset, cCount, cStride);
+      ctx->drawIndexedIndirect(cOffset, cCount, cStride, false);
     });
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirectCount(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::MultiDrawIndirectCount(
           UINT                    MaxDrawCount,
           ID3D11Buffer*           pBufferForCount,
           UINT                    ByteOffsetForCount,
@@ -72,6 +94,9 @@ namespace dxvk {
     D3D10DeviceLock lock = m_ctx->LockContext();
     m_ctx->SetDrawBuffers(pBufferForArgs, pBufferForCount);
 
+    if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
+      m_ctx->ApplyDirtyGraphicsBindings();
+
     m_ctx->EmitCs([
       cMaxCount  = MaxDrawCount,
       cArgOffset = ByteOffsetForArgs,
@@ -83,7 +108,8 @@ namespace dxvk {
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirectCount(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::MultiDrawIndexedIndirectCount(
           UINT                    MaxDrawCount,
           ID3D11Buffer*           pBufferForCount,
           UINT                    ByteOffsetForCount,
@@ -93,6 +119,9 @@ namespace dxvk {
     D3D10DeviceLock lock = m_ctx->LockContext();
     m_ctx->SetDrawBuffers(pBufferForArgs, pBufferForCount);
 
+    if (unlikely(m_ctx->HasDirtyGraphicsBindings()))
+      m_ctx->ApplyDirtyGraphicsBindings();
+
     m_ctx->EmitCs([
       cMaxCount  = MaxDrawCount,
       cArgOffset = ByteOffsetForArgs,
@@ -104,7 +133,8 @@ namespace dxvk {
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::SetDepthBoundsTest(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::SetDepthBoundsTest(
           BOOL                    Enable,
           FLOAT                   MinDepthBounds,
           FLOAT                   MaxDepthBounds) {
@@ -121,17 +151,84 @@ namespace dxvk {
   }
   
   
-  void STDMETHODCALLTYPE D3D11DeviceContextExt::SetBarrierControl(
+  template<typename ContextType>
+  void STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::SetBarrierControl(
           UINT                    ControlFlags) {
     D3D10DeviceLock lock = m_ctx->LockContext();
-    DxvkBarrierControlFlags flags;
-    
-    if (ControlFlags & D3D11_VK_BARRIER_CONTROL_IGNORE_WRITE_AFTER_WRITE)
-      flags.set(DxvkBarrierControl::IgnoreWriteAfterWrite);
-    
+    D3D11Device* parent = static_cast<D3D11Device*>(m_ctx->GetParentInterface());
+    DxvkBarrierControlFlags flags = parent->GetOptionsBarrierControlFlags();
+
+    if (ControlFlags & D3D11_VK_BARRIER_CONTROL_IGNORE_WRITE_AFTER_WRITE) {
+      flags.set(DxvkBarrierControl::ComputeAllowReadWriteOverlap,
+                DxvkBarrierControl::GraphicsAllowReadWriteOverlap);
+    }
+
     m_ctx->EmitCs([cFlags = flags] (DxvkContext* ctx) {
       ctx->setBarrierControl(cFlags);
     });
   }
-  
+
+
+  template<typename ContextType>
+  bool STDMETHODCALLTYPE D3D11DeviceContextExt<ContextType>::LaunchCubinShaderNVX(IUnknown* hShader, uint32_t GridX, uint32_t GridY, uint32_t GridZ,
+      const void* pParams, uint32_t ParamSize, void* const* pReadResources, uint32_t NumReadResources, void* const* pWriteResources, uint32_t NumWriteResources) {
+    D3D10DeviceLock lock = m_ctx->LockContext();
+
+    CubinShaderWrapper* cubinShader = static_cast<CubinShaderWrapper*>(hShader);
+    CubinShaderLaunchInfo launchInfo;
+
+    const uint32_t maxResources = NumReadResources + NumWriteResources;
+    launchInfo.buffers.reserve(maxResources);
+    launchInfo.images.reserve(maxResources);
+
+    for (uint32_t i = 0; i < NumReadResources; i++)
+      launchInfo.insertResource(static_cast<ID3D11Resource*>(pReadResources[i]), DxvkAccess::Read);
+
+    for (uint32_t i = 0; i < NumWriteResources; i++)
+      launchInfo.insertResource(static_cast<ID3D11Resource*>(pWriteResources[i]), DxvkAccess::Write);
+
+    launchInfo.paramSize = ParamSize;
+    launchInfo.params.resize(launchInfo.paramSize);
+    std::memcpy(launchInfo.params.data(), pParams, ParamSize);
+
+    launchInfo.cuLaunchConfig[0] = reinterpret_cast<void*>(0x01); // CU_LAUNCH_PARAM_BUFFER_POINTER
+    launchInfo.cuLaunchConfig[1] = launchInfo.params.data();
+    launchInfo.cuLaunchConfig[2] = reinterpret_cast<void*>(0x02); // CU_LAUNCH_PARAM_BUFFER_SIZE
+    launchInfo.cuLaunchConfig[3] = &launchInfo.paramSize; // yes, this actually requires a pointer to a size_t containing the parameter size
+    launchInfo.cuLaunchConfig[4] = reinterpret_cast<void*>(0x00); // CU_LAUNCH_PARAM_END
+
+    launchInfo.nvxLaunchInfo.function       = cubinShader->cuFunction();
+    launchInfo.nvxLaunchInfo.gridDimX       = GridX;
+    launchInfo.nvxLaunchInfo.gridDimY       = GridY;
+    launchInfo.nvxLaunchInfo.gridDimZ       = GridZ;
+    launchInfo.nvxLaunchInfo.blockDimX      = cubinShader->blockDim().width;
+    launchInfo.nvxLaunchInfo.blockDimY      = cubinShader->blockDim().height;
+    launchInfo.nvxLaunchInfo.blockDimZ      = cubinShader->blockDim().depth;
+    launchInfo.nvxLaunchInfo.sharedMemBytes = 0;
+    launchInfo.nvxLaunchInfo.paramCount     = 0;
+    launchInfo.nvxLaunchInfo.pParams        = nullptr;
+    launchInfo.nvxLaunchInfo.extraCount     = 1;
+    launchInfo.nvxLaunchInfo.pExtras        = launchInfo.cuLaunchConfig.data();
+
+    launchInfo.shader = cubinShader;
+
+    /* Need to capture by value in case this gets called from a deferred context */
+    m_ctx->EmitCs([cLaunchInfo = std::move(launchInfo)] (DxvkContext* ctx) {
+      ctx->launchCuKernelNVX(cLaunchInfo.nvxLaunchInfo, cLaunchInfo.buffers, cLaunchInfo.images);
+    });
+
+    // Track resource usage as necessary
+    for (uint32_t i = 0; i < NumReadResources; i++)
+      m_ctx->TrackResourceSequenceNumber(static_cast<ID3D11Resource*>(pReadResources[i]));
+
+    for (uint32_t i = 0; i < NumWriteResources; i++)
+      m_ctx->TrackResourceSequenceNumber(static_cast<ID3D11Resource*>(pWriteResources[i]));
+
+    return true;
+  }
+
+
+  template class D3D11DeviceContextExt<D3D11DeferredContext>;
+  template class D3D11DeviceContextExt<D3D11ImmediateContext>;
+
 }

src/d3d11/d3d11_context_ext.h

@@ -4,14 +4,16 @@
 
 namespace dxvk {
   
-  class D3D11DeviceContext;
+  class D3D11DeferredContext;
+  class D3D11ImmediateContext;
 
-  class D3D11DeviceContextExt : public ID3D11VkExtContext {
+  template<typename ContextType>
+  class D3D11DeviceContextExt : public ID3D11VkExtContext1 {
     
   public:
     
     D3D11DeviceContextExt(
-            D3D11DeviceContext*     pContext);
+            ContextType*            pContext);
     
     ULONG STDMETHODCALLTYPE AddRef();
     
@@ -56,11 +58,23 @@ namespace dxvk {
     
     void STDMETHODCALLTYPE SetBarrierControl(
             UINT                    ControlFlags);
-    
+
+    bool STDMETHODCALLTYPE LaunchCubinShaderNVX(
+            IUnknown*               hShader,
+            uint32_t                GridX,
+            uint32_t                GridY,
+            uint32_t                GridZ,
+            const void*             pParams,
+            uint32_t                paramSize,
+            void* const*            pReadResources,
+            uint32_t                NumReadResources,
+            void* const*            pWriteResources,
+            uint32_t                NumWriteResources);
+
   private:
     
-    D3D11DeviceContext* m_ctx;
-    
+    ContextType* m_ctx;
+
   };
 
 }

src/d3d11/d3d11_context_imm.h

@@ -2,18 +2,22 @@
 
 #include "../util/util_time.h"
 
-#include "../util/sync/sync_signal_win32.h"
+#include "../util/sync/sync_signal.h"
 
 #include "d3d11_context.h"
 #include "d3d11_state_object.h"
+#include "d3d11_video.h"
 
 namespace dxvk {
   
   class D3D11Buffer;
   class D3D11CommonTexture;
-  
-  class D3D11ImmediateContext : public D3D11DeviceContext {
+
+  class D3D11ImmediateContext : public D3D11CommonContext<D3D11ImmediateContext> {
+    friend class D3D11CommonContext<D3D11ImmediateContext>;
     friend class D3D11SwapChain;
+    friend class D3D11VideoContext;
+    friend class D3D11DXGIKeyedMutex;
   public:
     
     D3D11ImmediateContext(
@@ -21,14 +25,10 @@ namespace dxvk {
       const Rc<DxvkDevice>& Device);
     ~D3D11ImmediateContext();
     
-    ULONG STDMETHODCALLTYPE AddRef();
-    
-    ULONG STDMETHODCALLTYPE Release();
-    
-    D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType();
-    
-    UINT STDMETHODCALLTYPE GetContextFlags();
-    
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID  riid,
+            void**  ppvObject);
+
     HRESULT STDMETHODCALLTYPE GetData(
             ID3D11Asynchronous*         pAsync,
             void*                       pData,
@@ -74,58 +74,72 @@ namespace dxvk {
             ID3D11Resource*             pResource,
             UINT                        Subresource);
             
-    void STDMETHODCALLTYPE UpdateSubresource(
-            ID3D11Resource*                   pDstResource,
-            UINT                              DstSubresource,
-      const D3D11_BOX*                        pDstBox,
-      const void*                             pSrcData,
-            UINT                              SrcRowPitch,
-            UINT                              SrcDepthPitch);
-    
-    void STDMETHODCALLTYPE UpdateSubresource1(
-            ID3D11Resource*                   pDstResource,
-            UINT                              DstSubresource,
-      const D3D11_BOX*                        pDstBox,
-      const void*                             pSrcData,
-            UINT                              SrcRowPitch,
-            UINT                              SrcDepthPitch,
-            UINT                              CopyFlags);
-
-    void STDMETHODCALLTYPE OMSetRenderTargets(
-            UINT                              NumViews,
-            ID3D11RenderTargetView* const*    ppRenderTargetViews,
-            ID3D11DepthStencilView*           pDepthStencilView);
-    
-    void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews(
-            UINT                              NumRTVs,
-            ID3D11RenderTargetView* const*    ppRenderTargetViews,
-            ID3D11DepthStencilView*           pDepthStencilView,
-            UINT                              UAVStartSlot,
-            UINT                              NumUAVs,
-            ID3D11UnorderedAccessView* const* ppUnorderedAccessViews,
-      const UINT*                             pUAVInitialCounts);
-    
     void STDMETHODCALLTYPE SwapDeviceContextState(
-           ID3DDeviceContextState*           pState,
-           ID3DDeviceContextState**          ppPreviousState);
+            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();
+    }
+
+    void InjectCsChunk(
+            DxvkCsQueue                 Queue,
+            DxvkCsChunkRef&&            Chunk,
+            bool                        Synchronize);
+
+    template<typename Fn>
+    void InjectCs(
+            DxvkCsQueue                 Queue,
+            Fn&&                        Command) {
+      auto chunk = AllocCsChunk();
+      chunk->push(std::move(Command));
+
+      InjectCsChunk(Queue, std::move(chunk), false);
+    }
 
-    void SynchronizeCsThread();
-    
   private:
     
-    DxvkCsThread m_csThread;
-    bool         m_csIsBusy = false;
+    DxvkCsThread            m_csThread;
+    uint64_t                m_csSeqNum = 0ull;
 
-    std::atomic<uint32_t> m_refCount = { 0 };
+    uint32_t                m_mappedImageCount = 0u;
 
-    Rc<sync::Win32Fence> m_eventSignal;
-    uint64_t             m_eventCount = 0;
+    Rc<sync::CallbackFence> m_submissionFence;
+    uint64_t                m_submissionId = 0ull;
+    DxvkSubmitStatus        m_submitStatus;
+
+    uint64_t                m_flushSeqNum = 0ull;
+    GpuFlushTracker         m_flushTracker;
+
+    Rc<sync::Fence>         m_stagingBufferFence;
+
+    VkDeviceSize            m_discardMemoryCounter = 0u;
+    VkDeviceSize            m_discardMemoryOnFlush = 0u;
+
+    bool                    m_hasPendingMsaaResolve = false;
+
+    D3D10Multithread        m_multithread;
+    D3D11VideoContext       m_videoContext;
+
+    Com<D3D11DeviceContextState, false> m_stateObject;
+
+    std::string             m_flushReason;
 
-    dxvk::high_resolution_clock::time_point m_lastFlush
-      = dxvk::high_resolution_clock::now();
-    
-    Com<D3D11DeviceContextState> m_stateObject;
-    
     HRESULT MapBuffer(
             D3D11Buffer*                pResource,
             D3D11_MAP                   MapType,
@@ -143,19 +157,67 @@ namespace dxvk {
             D3D11CommonTexture*         pResource,
             UINT                        Subresource);
     
+    void ReadbackImageBuffer(
+            D3D11CommonTexture*         pResource,
+            UINT                        Subresource);
+
+    void UpdateDirtyImageRegion(
+            D3D11CommonTexture*         pResource,
+            UINT                        Subresource,
+      const D3D11_COMMON_TEXTURE_REGION* pRegion);
+
+    void UpdateMappedBuffer(
+            D3D11Buffer*                pDstBuffer,
+            UINT                        Offset,
+            UINT                        Length,
+      const void*                       pSrcData,
+            UINT                        CopyFlags);
+
     void SynchronizeDevice();
+
+    void EndFrame(
+            Rc<DxvkLatencyTracker>      LatencyTracker);
     
     bool WaitForResource(
-      const Rc<DxvkResource>&                 Resource,
-            D3D11_MAP                         MapType,
-            UINT                              MapFlags);
+      const DxvkPagedResource&          Resource,
+            uint64_t                    SequenceNumber,
+            D3D11_MAP                   MapType,
+            UINT                        MapFlags);
     
     void EmitCsChunk(DxvkCsChunkRef&& chunk);
 
-    void FlushImplicit(BOOL StrongHint);
+    void TrackTextureSequenceNumber(
+            D3D11CommonTexture*         pResource,
+            UINT                        Subresource);
+
+    void TrackBufferSequenceNumber(
+            D3D11Buffer*                pResource);
+
+    uint64_t GetCurrentSequenceNumber();
+
+    uint64_t GetPendingCsChunks();
+
+    void ApplyDirtyNullBindings();
+
+    void ConsiderFlush(
+            GpuFlushType                FlushType);
+
+    void ExecuteFlush(
+            GpuFlushType                FlushType,
+            HANDLE                      hEvent,
+            BOOL                        Synchronize);
+
+    void ThrottleAllocation();
+
+    void ThrottleDiscard(
+            VkDeviceSize                Size);
+
+    DxvkStagingBufferStats GetStagingMemoryStatistics();
+
+    static GpuFlushType GetMaxFlushType(
+            D3D11Device*    pParent,
+      const Rc<DxvkDevice>& Device);
 
-    void SignalEvent(HANDLE hEvent);
-    
   };
   
 }

src/d3d11/d3d11_context_state.h

@@ -15,128 +15,239 @@
 
 namespace dxvk {
   
+  /**
+   * \brief Per-stage state
+   *
+   * Stores an object of the given type for each shader stage.
+   * \tparam Object type
+   */
+  template<typename T>
+  class D3D11ShaderStageState {
+
+  public:
+
+          T& operator [] (DxbcProgramType type)       { return m_state[uint32_t(type)]; }
+    const T& operator [] (DxbcProgramType type) const { return m_state[uint32_t(type)]; }
+
+    /**
+     * \brief Calls reset method on all objects
+     */
+    void reset() {
+      for (auto& state : m_state)
+        state.reset();
+    }
+
+  private:
+
+    std::array<T, 6> m_state = { };
+
+  };
+
+
+  /**
+   * \brief Constant buffer bindings
+   *
+   * Stores the bound buffer range from a runtime point of view,
+   * as well as the range that is actually bound to the context.
+   */
   struct D3D11ConstantBufferBinding {
-    Com<D3D11Buffer> buffer         = nullptr;
+    Com<D3D11Buffer, false> buffer  = nullptr;
     UINT             constantOffset = 0;
     UINT             constantCount  = 0;
     UINT             constantBound  = 0;
   };
   
-  using D3D11ConstantBufferBindings = std::array<
-    D3D11ConstantBufferBinding, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT>;
-  
-  
-  using D3D11SamplerBindings = std::array<
-    D3D11SamplerState*, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT>;
-    
-  
-  struct D3D11ShaderResourceBindings {
-    std::array<Com<D3D11ShaderResourceView>, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT> views     = { };
-    DxvkBindingSet<D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT>                           hazardous = { };
-  };
-    
-    
-  using D3D11UnorderedAccessBindings = std::array<
-    Com<D3D11UnorderedAccessView>, D3D11_1_UAV_SLOT_COUNT>;
-  
-  
-  struct D3D11ContextStateVS {
-    Com<D3D11VertexShader>        shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-  };
-  
-  
-  struct D3D11ContextStateHS {
-    Com<D3D11HullShader>          shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-  };
-  
-  
-  struct D3D11ContextStateDS {
-    Com<D3D11DomainShader>        shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-  };
-  
-  
-  struct D3D11ContextStateGS {
-    Com<D3D11GeometryShader>      shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-  };
-  
-  
-  struct D3D11ContextStatePS {
-    Com<D3D11PixelShader>         shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-    D3D11UnorderedAccessBindings  unorderedAccessViews = { };
-  };
-  
-  
-  struct D3D11ContextStateCS {
-    Com<D3D11ComputeShader>       shader = nullptr;
-    D3D11ConstantBufferBindings   constantBuffers = { };
-    D3D11SamplerBindings          samplers        = { };
-    D3D11ShaderResourceBindings   shaderResources = { };
-    D3D11UnorderedAccessBindings  unorderedAccessViews = { };
+  struct D3D11ShaderStageCbvBinding {
+    std::array<D3D11ConstantBufferBinding, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT> buffers = { };
 
-    DxvkBindingSet<D3D11_1_UAV_SLOT_COUNT> uavMask = { };
+    uint32_t maxCount = 0;
+
+    void reset() {
+      for (uint32_t i = 0; i < maxCount; i++)
+        buffers[i] = D3D11ConstantBufferBinding();
+
+      maxCount = 0;
+    }
   };
+
+  using D3D11CbvBindings = D3D11ShaderStageState<D3D11ShaderStageCbvBinding>;
   
+  /**
+   * \brief Shader resource bindings
+   *
+   * Stores bound shader resource views, as well as a bit
+   * set of views that are potentially hazardous.
+   */
+  struct D3D11ShaderStageSrvBinding {
+    std::array<Com<D3D11ShaderResourceView, false>, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT> views     = { };
+    DxvkBindingSet<D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT>                           hazardous = { };
+
+    uint32_t maxCount = 0;
+
+    void reset() {
+      for (uint32_t i = 0; i < maxCount; i++)
+        views[i] = nullptr;
+
+      hazardous.clear();
+      maxCount = 0;
+    }
+  };
+    
+  using D3D11SrvBindings = D3D11ShaderStageState<D3D11ShaderStageSrvBinding>;
+
+  /**
+   * \brief Sampler bindings
+   *
+   * Stores bound samplers.
+   */
+  struct D3D11ShaderStageSamplerBinding {
+    std::array<D3D11SamplerState*, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT> samplers = { };
+
+    uint32_t maxCount = 0;
+
+    void reset() {
+      for (uint32_t i = 0; i < maxCount; i++)
+        samplers[i] = nullptr;
+
+      maxCount = 0;
+    }
+  };
+    
+  using D3D11SamplerBindings = D3D11ShaderStageState<D3D11ShaderStageSamplerBinding>;
+
+  /**
+   * \brief UAV bindings
+   *
+   * Stores bound UAVs. For compute shader UAVs,
+   * we also store a bit mask of bound UAVs.
+   */
+  using D3D11ShaderStageUavBinding = std::array<Com<D3D11UnorderedAccessView, false>, D3D11_1_UAV_SLOT_COUNT>;
   
+  struct D3D11UavBindings {
+    D3D11ShaderStageUavBinding              views = { };
+    DxvkBindingSet<D3D11_1_UAV_SLOT_COUNT>  mask  = { };
+
+    uint32_t maxCount = 0;
+
+    void reset() {
+      for (uint32_t i = 0; i < maxCount; i++)
+        views[i] = nullptr;
+
+      mask.clear();
+      maxCount = 0;
+    }
+  };
+
+  /**
+   * \brief Input assembly state
+   *
+   * Stores vertex buffers, the index buffer, the
+   * input layout, and the dynamic primitive topology.
+   */
   struct D3D11VertexBufferBinding {
-    Com<D3D11Buffer> buffer = nullptr;
-    UINT             offset = 0;
-    UINT             stride = 0;
+    Com<D3D11Buffer, false> buffer = nullptr;
+    UINT                    offset = 0;
+    UINT                    stride = 0;
   };
   
-  
   struct D3D11IndexBufferBinding {
-    Com<D3D11Buffer> buffer = nullptr;
-    UINT             offset = 0;
-    DXGI_FORMAT      format = DXGI_FORMAT_UNKNOWN;
+    Com<D3D11Buffer, false> buffer = nullptr;
+    UINT                    offset = 0;
+    DXGI_FORMAT             format = DXGI_FORMAT_UNKNOWN;
   };
 
-
-  struct D3D11ContextStateID {
-    Com<D3D11Buffer> argBuffer = nullptr;
-    Com<D3D11Buffer> cntBuffer = nullptr;
-  };
-  
-  
   struct D3D11ContextStateIA {
-    Com<D3D11InputLayout>    inputLayout       = nullptr;
-    D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
+    Com<D3D11InputLayout, false> inputLayout       = nullptr;
+    D3D11_PRIMITIVE_TOPOLOGY     primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
     
     std::array<D3D11VertexBufferBinding, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT> vertexBuffers = { };
     D3D11IndexBufferBinding                                                         indexBuffer   = { };
+
+    uint32_t maxVbCount = 0;
+
+    void reset() {
+      inputLayout = nullptr;
+
+      primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;
+
+      for (uint32_t i = 0; i < maxVbCount; i++)
+        vertexBuffers[i] = D3D11VertexBufferBinding();
+
+      indexBuffer = D3D11IndexBufferBinding();
+    }
   };
   
+  /**
+   * \brief Output merger state
+   *
+   * Stores RTV, DSV, and graphics UAV bindings, as well as related state.
+   */
+  using D3D11RenderTargetViewBinding = std::array<Com<D3D11RenderTargetView, false>, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT>;
   
   struct D3D11ContextStateOM {
-    std::array<Com<D3D11RenderTargetView, false>, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT> renderTargetViews = { };
-    Com<D3D11DepthStencilView, false>                                                     depthStencilView  = { };
+    D3D11ShaderStageUavBinding        uavs  = { };
+    D3D11RenderTargetViewBinding      rtvs  = { };
+    Com<D3D11DepthStencilView, false> dsv   = { };
     
     D3D11BlendState*        cbState = nullptr;
     D3D11DepthStencilState* dsState = nullptr;
     
     FLOAT blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
-    UINT  sampleMask     = 0xFFFFFFFFu;
-    UINT  stencilRef     = 0u;
+
+    UINT  sampleCount    = 0u;
+    UINT  sampleMask     = D3D11_DEFAULT_SAMPLE_MASK;
+    UINT  stencilRef     = D3D11_DEFAULT_STENCIL_REFERENCE;
 
     UINT  maxRtv         = 0u;
+    UINT  minUav         = D3D11_1_UAV_SLOT_COUNT;
     UINT  maxUav         = 0u;
+
+    void reset() {
+      for (uint32_t i = minUav; i < maxUav; i++)
+        uavs[i] = nullptr;
+
+      for (uint32_t i = 0; i < maxRtv; i++)
+        rtvs[i] = nullptr;
+
+      dsv = nullptr;
+
+      cbState = nullptr;
+      dsState = nullptr;
+
+      for (uint32_t i = 0; i < 4; i++)
+        blendFactor[i] = 1.0f;
+
+      sampleCount = 0u;
+      sampleMask = D3D11_DEFAULT_SAMPLE_MASK;
+      stencilRef = D3D11_DEFAULT_STENCIL_REFERENCE;
+
+      maxRtv = 0u;
+      minUav = D3D11_1_UAV_SLOT_COUNT;
+      maxUav = 0u;
+    }
   };
   
-  
+  /**
+   * \brief Indirect draw state
+   *
+   * Stores the current indirct draw
+   * argument and draw count buffer.
+   */
+  struct D3D11ContextStateID {
+    uint64_t argBufferCookie = 0u;
+    uint64_t cntBufferCookie = 0u;
+
+    void reset() {
+      argBufferCookie = 0u;
+      cntBufferCookie = 0u;
+    }
+  };
+
+  /**
+   * \brief Rasterizer state
+   *
+   * Stores viewport info and the rasterizer state object.
+   */
   struct D3D11ContextStateRS {
     uint32_t numViewports = 0;
     uint32_t numScissors  = 0;
@@ -145,43 +256,125 @@ namespace dxvk {
     std::array<D3D11_RECT,     D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE> scissors  = { };
     
     D3D11RasterizerState* state = nullptr;
+
+    void reset() {
+      for (uint32_t i = 0; i < numViewports; i++)
+        viewports[i] = D3D11_VIEWPORT();
+
+      for (uint32_t i = 0; i < numScissors; i++)
+        scissors[i] = D3D11_RECT();
+
+      numViewports = 0;
+      numScissors = 0;
+
+      state = nullptr;
+    }
   };
 
-
+  /**
+   * \brief Stream output binding
+   *
+   * Stores stream output buffers with offset.
+   */
   struct D3D11ContextSoTarget {
-    Com<D3D11Buffer> buffer = nullptr;
-    UINT             offset = 0;
+    Com<D3D11Buffer, false> buffer = nullptr;
+    UINT                    offset = 0;
   };
-  
 
   struct D3D11ContextStateSO {
     std::array<D3D11ContextSoTarget, D3D11_SO_BUFFER_SLOT_COUNT> targets = { };
+
+    void reset() {
+      for (uint32_t i = 0; i < targets.size(); i++)
+        targets[i] = D3D11ContextSoTarget();
+    }
   };
   
-  
+  /**
+   * \brief Predication state
+   *
+   * Stores predication info.
+   */
   struct D3D11ContextStatePR {
-    Com<D3D11Query> predicateObject = nullptr;
-    BOOL            predicateValue  = FALSE;
+    Com<D3D11Query, false> predicateObject = nullptr;
+    BOOL                   predicateValue  = false;
+
+    void reset() {
+      predicateObject = nullptr;
+      predicateValue = false;
+    }
   };
-  
+
+
+  /**
+   * \brief Lazy binding state
+   *
+   * Keeps track of what state needs to be
+   * re-applied to the context.
+   */
+  struct D3D11LazyBindings {
+    DxbcProgramTypeFlags shadersUsed = 0u;
+    DxbcProgramTypeFlags shadersDirty = 0u;
+    DxbcProgramTypeFlags graphicsUavShaders = 0u;
+
+    D3D11ShaderStageState<DxbcBindingMask> bindingsUsed;
+    D3D11ShaderStageState<DxbcBindingMask> bindingsDirty;
+
+    void reset() {
+      shadersUsed = 0u;
+      shadersDirty = 0u;
+      graphicsUavShaders = 0u;
+
+      bindingsUsed.reset();
+      bindingsDirty.reset();
+    }
+  };
+
   
   /**
    * \brief Context state
    */
   struct D3D11ContextState {
-    D3D11ContextStateCS cs;
-    D3D11ContextStateDS ds;
-    D3D11ContextStateGS gs;
-    D3D11ContextStateHS hs;
-    D3D11ContextStatePS ps;
-    D3D11ContextStateVS vs;
-    
+    Com<D3D11VertexShader, false>    vs;
+    Com<D3D11HullShader, false>      hs;
+    Com<D3D11DomainShader, false>    ds;
+    Com<D3D11GeometryShader, false>  gs;
+    Com<D3D11PixelShader, false>     ps;
+    Com<D3D11ComputeShader, false>   cs;
+
     D3D11ContextStateID id;
     D3D11ContextStateIA ia;
     D3D11ContextStateOM om;
     D3D11ContextStateRS rs;
     D3D11ContextStateSO so;
     D3D11ContextStatePR pr;
+
+    D3D11CbvBindings    cbv;
+    D3D11SrvBindings    srv;
+    D3D11UavBindings    uav;
+    D3D11SamplerBindings samplers;
+
+    D3D11LazyBindings   lazy;
   };
-  
-}
+
+  /**
+   * \brief Maximum used binding numbers in a shader stage
+   */
+  struct D3D11MaxUsedStageBindings {
+    uint32_t cbvCount     : 5;
+    uint32_t srvCount     : 9;
+    uint32_t uavCount     : 7;
+    uint32_t samplerCount : 5;
+    uint32_t reserved     : 6;
+  };
+
+  /**
+   * \brief Maximum used binding numbers for all context state
+   */
+  struct D3D11MaxUsedBindings {
+    std::array<D3D11MaxUsedStageBindings, uint32_t(DxbcProgramType::Count)> stages;
+    uint32_t  vbCount;
+    uint32_t  soCount;
+  };
+
+}

src/d3d11/d3d11_cuda.cpp

@@ -0,0 +1,51 @@
+#include "d3d11_cuda.h"
+
+namespace dxvk {
+
+  CubinShaderWrapper::CubinShaderWrapper(const Rc<dxvk::DxvkDevice>& dxvkDevice, VkCuModuleNVX cuModule, VkCuFunctionNVX cuFunction, VkExtent3D blockDim)
+  : m_dxvkDevice(dxvkDevice), m_module(cuModule), m_function(cuFunction), m_blockDim(blockDim) { };
+
+
+  CubinShaderWrapper::~CubinShaderWrapper() {
+    VkDevice vkDevice = m_dxvkDevice->handle();
+    m_dxvkDevice->vkd()->vkDestroyCuFunctionNVX(vkDevice, m_function, nullptr);
+    m_dxvkDevice->vkd()->vkDestroyCuModuleNVX(vkDevice, m_module, nullptr);
+  };
+
+
+  HRESULT STDMETHODCALLTYPE CubinShaderWrapper::QueryInterface(REFIID riid, void **ppvObject) {
+    if (riid == __uuidof(IUnknown)) {
+      *ppvObject = ref(this);
+      return S_OK;
+    }
+
+    Logger::warn("CubinShaderWrapper::QueryInterface: Unknown interface query");
+    Logger::warn(str::format(riid));
+    return E_NOINTERFACE;
+  }
+
+
+  void CubinShaderLaunchInfo::insertResource(ID3D11Resource* pResource, DxvkAccessFlags access) {
+    auto img = GetCommonTexture(pResource);
+    auto buf = GetCommonBuffer(pResource);
+
+    if (img)
+      insertUniqueResource(images, img->GetImage(), access);
+    if (buf)
+      insertUniqueResource(buffers, buf->GetBuffer(), access);
+  }
+
+
+  template<typename T>
+  void CubinShaderLaunchInfo::insertUniqueResource(std::vector<std::pair<T, DxvkAccessFlags>>& list, const T& resource, DxvkAccessFlags access) {
+    for (auto& entry : list) {
+      if (entry.first == resource) {
+        entry.second.set(access);
+        return;
+      }
+    }
+
+    list.push_back({ resource, access });
+  }
+
+}

src/d3d11/d3d11_cuda.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+
+#include "../dxvk/dxvk_memory.h"
+#include "../dxvk/dxvk_sparse.h"
+
+#include "../util/com/com_guid.h"
+#include "../util/com/com_object.h"
+
+#include "d3d11_buffer.h"
+#include "d3d11_texture.h"
+
+namespace dxvk {
+
+  class CubinShaderWrapper : public ComObject<IUnknown> {
+
+  public:
+
+    CubinShaderWrapper(const Rc<dxvk::DxvkDevice>& dxvkDevice, VkCuModuleNVX cuModule, VkCuFunctionNVX cuFunction, VkExtent3D blockDim);
+    ~CubinShaderWrapper();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+
+    VkCuModuleNVX cuModule() const {
+      return m_module;
+    }
+
+    VkCuFunctionNVX cuFunction() const {
+      return m_function;
+    }
+
+    VkExtent3D blockDim() const {
+      return m_blockDim;
+    }
+
+  private:
+
+    Rc<DxvkDevice>  m_dxvkDevice;
+    VkCuModuleNVX   m_module;
+    VkCuFunctionNVX m_function;
+    VkExtent3D      m_blockDim;
+
+  };
+
+
+  struct CubinShaderLaunchInfo {
+
+    CubinShaderLaunchInfo() = default;
+
+    CubinShaderLaunchInfo(CubinShaderLaunchInfo&& other) {
+      shader         = std::move(other.shader);
+      params         = std::move(other.params);
+      paramSize      = std::move(other.paramSize);
+      nvxLaunchInfo  = std::move(other.nvxLaunchInfo);
+      cuLaunchConfig = other.cuLaunchConfig;
+      buffers        = std::move(other.buffers);
+      images         = std::move(other.images);
+      other.cuLaunchConfig[1] = nullptr;
+      other.cuLaunchConfig[3] = nullptr;
+      other.nvxLaunchInfo.pExtras = nullptr;
+      // fix-up internally-pointing pointers
+      cuLaunchConfig[1] = params.data();
+      cuLaunchConfig[3] = &paramSize;
+      nvxLaunchInfo.pExtras = cuLaunchConfig.data();
+    }
+
+    Com<CubinShaderWrapper> shader;
+    std::vector<uint8_t>    params;
+    size_t                  paramSize;
+    VkCuLaunchInfoNVX       nvxLaunchInfo = { VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX };
+    std::array<void*, 5>    cuLaunchConfig;
+
+    std::vector<std::pair<Rc<DxvkBuffer>, DxvkAccessFlags>> buffers;
+    std::vector<std::pair<Rc<DxvkImage>, DxvkAccessFlags>> images;
+
+    void insertResource(ID3D11Resource* pResource, DxvkAccessFlags access);
+
+    template<typename T>
+    static void insertUniqueResource(std::vector<std::pair<T, DxvkAccessFlags>>& list, const T& resource, DxvkAccessFlags access);
+  };
+
+}

src/d3d11/d3d11_depth_stencil.cpp

@@ -6,7 +6,8 @@ namespace dxvk {
   D3D11DepthStencilState::D3D11DepthStencilState(
           D3D11Device*              device,
     const D3D11_DEPTH_STENCIL_DESC& desc)
-  : m_device(device), m_desc(desc), m_d3d10(this) {
+  : D3D11StateObject<ID3D11DepthStencilState>(device),
+    m_desc(desc), m_d3d10(this) {
     m_state.enableDepthTest   = desc.DepthEnable;
     m_state.enableDepthWrite  = desc.DepthWriteMask == D3D11_DEPTH_WRITE_MASK_ALL;
     m_state.enableStencilTest = desc.StencilEnable;
@@ -19,22 +20,6 @@ namespace dxvk {
   D3D11DepthStencilState::~D3D11DepthStencilState() {
     
   }
-  
-  
-  ULONG STDMETHODCALLTYPE D3D11DepthStencilState::AddRef() {
-    ULONG refCount = m_refCount++;
-    if (!refCount)
-      m_device->AddRef();
-    return refCount + 1;
-  }
-
-
-  ULONG STDMETHODCALLTYPE D3D11DepthStencilState::Release() {
-    ULONG refCount = --m_refCount;
-    if (!refCount)
-      m_device->Release();
-    return refCount;
-  }
 
 
   HRESULT STDMETHODCALLTYPE D3D11DepthStencilState::QueryInterface(REFIID riid, void** ppvObject) {
@@ -52,27 +37,25 @@ 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;
   }
   
   
-  void STDMETHODCALLTYPE D3D11DepthStencilState::GetDevice(ID3D11Device** ppDevice) {
-    *ppDevice = ref(m_device);
-  }
-  
-  
   void STDMETHODCALLTYPE D3D11DepthStencilState::GetDesc(D3D11_DEPTH_STENCIL_DESC* pDesc) {
     *pDesc = m_desc;
   }
   
   
-  void D3D11DepthStencilState::BindToContext(const Rc<DxvkContext>& ctx) {
+  void D3D11DepthStencilState::BindToContext(DxvkContext* ctx) {
     ctx->setDepthStencilState(m_state);
   }
   

src/d3d11/d3d11_depth_stencil.h

@@ -11,7 +11,7 @@ namespace dxvk {
   
   class D3D11Device;
   
-  class D3D11DepthStencilState : public D3D11DeviceChild<ID3D11DepthStencilState, NoWrapper> {
+  class D3D11DepthStencilState : public D3D11StateObject<ID3D11DepthStencilState> {
     
   public:
     
@@ -21,23 +21,15 @@ namespace dxvk {
             D3D11Device*              device,
       const D3D11_DEPTH_STENCIL_DESC& desc);
     ~D3D11DepthStencilState();
-    
-    ULONG STDMETHODCALLTYPE AddRef() final;
-
-    ULONG STDMETHODCALLTYPE Release() final;
 
     HRESULT STDMETHODCALLTYPE QueryInterface(
             REFIID  riid,
             void**  ppvObject) final;
     
-    void STDMETHODCALLTYPE GetDevice(
-            ID3D11Device **ppDevice) final;
-    
     void STDMETHODCALLTYPE GetDesc(
             D3D11_DEPTH_STENCIL_DESC* pDesc) final;
     
-    void BindToContext(
-      const Rc<DxvkContext>&  ctx);
+    void BindToContext(DxvkContext* ctx);
     
     D3D10DepthStencilState* GetD3D10Iface() {
       return &m_d3d10;
@@ -48,12 +40,9 @@ namespace dxvk {
     
   private:
     
-    D3D11Device* const        m_device;
     D3D11_DEPTH_STENCIL_DESC  m_desc;
     DxvkDepthStencilState     m_state;
     D3D10DepthStencilState    m_d3d10;
-
-    std::atomic<uint32_t> m_refCount = { 0u };
     
     VkStencilOpState DecodeStencilOpState(
       const D3D11_DEPTH_STENCILOP_DESC& StencilDesc,

src/d3d11/d3d11_device.h

@@ -9,15 +9,19 @@
 #include "../dxgi/dxgi_interfaces.h"
 
 #include "../dxvk/dxvk_cs.h"
+#include "../dxvk/dxvk_latency_reflex.h"
 
 #include "../d3d10/d3d10_device.h"
 
 #include "../util/com/com_private_data.h"
 
 #include "d3d11_cmdlist.h"
+#include "d3d11_cuda.h"
+#include "d3d11_features.h"
 #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"
@@ -30,7 +34,6 @@ namespace dxvk {
   class D3D11CommonShader;
   class D3D11CommonTexture;
   class D3D11Counter;
-  class D3D11DeviceContext;
   class D3D11DXGIDevice;
   class D3D11ImmediateContext;
   class D3D11Predicate;
@@ -85,6 +88,11 @@ namespace dxvk {
       const D3D11_SUBRESOURCE_DATA* pInitialData,
             ID3D11Texture2D1**      ppTexture2D);
     
+    HRESULT STDMETHODCALLTYPE CreateTexture2DBase(
+      const D3D11_TEXTURE2D_DESC1*  pDesc,
+      const D3D11_SUBRESOURCE_DATA* pInitialData,
+            ID3D11Texture2D1**      ppTexture2D);
+    
     HRESULT STDMETHODCALLTYPE CreateTexture3D(
       const D3D11_TEXTURE3D_DESC*   pDesc,
       const D3D11_SUBRESOURCE_DATA* pInitialData,
@@ -95,6 +103,11 @@ namespace dxvk {
       const D3D11_SUBRESOURCE_DATA* pInitialData,
             ID3D11Texture3D1**      ppTexture3D);
     
+    HRESULT STDMETHODCALLTYPE CreateTexture3DBase(
+      const D3D11_TEXTURE3D_DESC1*  pDesc,
+      const D3D11_SUBRESOURCE_DATA* pInitialData,
+            ID3D11Texture3D1**      ppTexture3D);
+    
     HRESULT STDMETHODCALLTYPE CreateShaderResourceView(
             ID3D11Resource*                   pResource,
       const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc,
@@ -105,6 +118,11 @@ namespace dxvk {
       const D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc,
             ID3D11ShaderResourceView1**       ppSRView);
     
+    HRESULT STDMETHODCALLTYPE CreateShaderResourceViewBase(
+            ID3D11Resource*                   pResource,
+      const D3D11_SHADER_RESOURCE_VIEW_DESC1* pDesc,
+            ID3D11ShaderResourceView1**       ppSRView);
+    
     HRESULT STDMETHODCALLTYPE CreateUnorderedAccessView(
             ID3D11Resource*                   pResource,
       const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
@@ -115,6 +133,11 @@ namespace dxvk {
       const D3D11_UNORDERED_ACCESS_VIEW_DESC1* pDesc,
             ID3D11UnorderedAccessView1**      ppUAView);
     
+    HRESULT STDMETHODCALLTYPE CreateUnorderedAccessViewBase(
+            ID3D11Resource*                   pResource,
+      const D3D11_UNORDERED_ACCESS_VIEW_DESC1* pDesc,
+            ID3D11UnorderedAccessView1**      ppUAView);
+    
     HRESULT STDMETHODCALLTYPE CreateRenderTargetView(
             ID3D11Resource*                   pResource,
       const D3D11_RENDER_TARGET_VIEW_DESC*    pDesc,
@@ -125,6 +148,11 @@ namespace dxvk {
       const D3D11_RENDER_TARGET_VIEW_DESC1*   pDesc,
             ID3D11RenderTargetView1**         ppRTView);
     
+    HRESULT STDMETHODCALLTYPE CreateRenderTargetViewBase(
+            ID3D11Resource*                   pResource,
+      const D3D11_RENDER_TARGET_VIEW_DESC1*   pDesc,
+            ID3D11RenderTargetView1**         ppRTView);
+    
     HRESULT STDMETHODCALLTYPE CreateDepthStencilView(
             ID3D11Resource*                   pResource,
       const D3D11_DEPTH_STENCIL_VIEW_DESC*    pDesc,
@@ -223,6 +251,10 @@ namespace dxvk {
       const D3D11_QUERY_DESC1*          pQueryDesc,
             ID3D11Query1**              ppQuery);
     
+    HRESULT STDMETHODCALLTYPE CreateQueryBase(
+      const D3D11_QUERY_DESC1*          pQueryDesc,
+            ID3D11Query1**              ppQuery);
+    
     HRESULT STDMETHODCALLTYPE CreatePredicate(
       const D3D11_QUERY_DESC*           pPredicateDesc,
             ID3D11Predicate**           ppPredicate);
@@ -259,7 +291,7 @@ namespace dxvk {
     HRESULT STDMETHODCALLTYPE CreateFence(
             UINT64                      InitialValue,
             D3D11_FENCE_FLAG            Flags,
-            REFIID                      ReturnedInterface,
+            REFIID                      riid,
             void**                      ppFence);
 
     void STDMETHODCALLTYPE ReadFromSubresource(
@@ -389,8 +421,21 @@ namespace dxvk {
       return m_dxvkDevice;
     }
     
-    void FlushInitContext();
+    void FlushInitCommands() {
+      m_initializer->FlushCsChunk();
+    }
+
+    void NotifyContextFlush() {
+      m_initializer->NotifyContextFlush();
+    }
     
+    void InitShaderIcb(
+            D3D11CommonShader*          pShader,
+            size_t                      IcbSize,
+      const void*                       pIcbData) {
+      return m_initializer->InitShaderIcb(pShader, IcbSize, pIcbData);
+    }
+
     VkPipelineStageFlags GetEnabledShaderStages() const {
       return m_dxvkDevice->getShaderPipelineStages();
     }
@@ -419,19 +464,35 @@ namespace dxvk {
     D3D10Device* GetD3D10Interface() const {
       return m_d3d10Device;
     }
-    
-    static bool CheckFeatureLevelSupport(
-      const Rc<DxvkInstance>& instance,
-      const Rc<DxvkAdapter>&  adapter,
-            D3D_FEATURE_LEVEL featureLevel);
+
+    D3D11ImmediateContext* GetContext() const {
+      return m_context.ptr();
+    }
+
+    bool Is11on12Device() const;
+
+    static D3D_FEATURE_LEVEL GetMaxFeatureLevel(
+      const Rc<DxvkInstance>& Instance,
+      const Rc<DxvkAdapter>&  Adapter);
     
     static DxvkDeviceFeatures GetDeviceFeatures(
-      const Rc<DxvkAdapter>&  adapter,
-            D3D_FEATURE_LEVEL featureLevel);
+      const Rc<DxvkAdapter>&  Adapter);
+
+    DxvkBarrierControlFlags GetOptionsBarrierControlFlags() {
+      DxvkBarrierControlFlags barrierControl = 0u;
+
+      if (m_d3d11Options.relaxedBarriers)
+        barrierControl.set(DxvkBarrierControl::ComputeAllowWriteOnlyOverlap);
+
+      if (m_d3d11Options.relaxedBarriers || m_d3d11Options.relaxedGraphicsBarriers)
+        barrierControl.set(DxvkBarrierControl::GraphicsAllowReadWriteOverlap);
+
+      return barrierControl;
+    }
     
   private:
     
-    IDXGIObject*                    m_container;
+    D3D11DXGIDevice*                m_container;
 
     D3D_FEATURE_LEVEL               m_featureLevel;
     UINT                            m_featureFlags;
@@ -446,15 +507,18 @@ namespace dxvk {
     DxvkCsChunkPool                 m_csChunkPool;
     
     D3D11Initializer*               m_initializer = nullptr;
-    D3D11ImmediateContext*          m_context     = nullptr;
     D3D10Device*                    m_d3d10Device = nullptr;
+    Com<D3D11ImmediateContext, false> m_context;
 
     D3D11StateObjectSet<D3D11BlendState>        m_bsStateObjects;
     D3D11StateObjectSet<D3D11DepthStencilState> m_dsStateObjects;
     D3D11StateObjectSet<D3D11RasterizerState>   m_rsStateObjects;
     D3D11StateObjectSet<D3D11SamplerState>      m_samplerObjects;
     D3D11ShaderModuleSet                        m_shaderModules;
-    
+
+    D3D_FEATURE_LEVEL               m_maxFeatureLevel;
+    D3D11DeviceFeatures             m_deviceFeatures;
+
     HRESULT CreateShaderModule(
             D3D11CommonShader*      pShaderModule,
             DxvkShaderKey           ShaderKey,
@@ -464,33 +528,41 @@ namespace dxvk {
       const DxbcModuleInfo*         pModuleInfo);
     
     HRESULT GetFormatSupportFlags(
-            DXGI_FORMAT Format,
-            UINT*       pFlags1,
-            UINT*       pFlags2) const;
+            DXGI_FORMAT             Format,
+            UINT*                   pFlags1,
+            UINT*                   pFlags2) const;
     
     BOOL GetImageTypeSupport(
-            VkFormat    Format,
-            VkImageType Type) const;
+            VkFormat                Format,
+            VkImageType             Type,
+            VkImageCreateFlags      Flags) const;
+
+    template<bool IsKmtHandle>
+    HRESULT OpenSharedResourceGeneric(
+            HANDLE      hResource,
+            REFIID      ReturnedInterface,
+            void**      ppResource);
+
+    uint32_t GetViewPlaneIndex(
+            ID3D11Resource*         pResource,
+            DXGI_FORMAT             ViewFormat);
     
     template<typename Void>
     void CopySubresourceData(
             Void*                       pData,
             UINT                        RowPitch,
             UINT                        DepthPitch,
-            ID3D11Resource*             pResource,
+            D3D11CommonTexture*         pTexture,
             UINT                        Subresource,
       const D3D11_BOX*                  pBox);
     
-    static D3D_FEATURE_LEVEL GetMaxFeatureLevel(
-      const Rc<DxvkInstance>&           pInstance);
-    
   };
   
   
   /**
    * \brief Extended D3D11 device
    */
-  class D3D11DeviceExt : public ID3D11VkExtDevice {
+  class D3D11DeviceExt : public ID3D11VkExtDevice1 {
     
   public:
     
@@ -509,48 +581,275 @@ namespace dxvk {
     BOOL STDMETHODCALLTYPE GetExtensionSupport(
             D3D11_VK_EXTENSION      Extension);
     
+    bool STDMETHODCALLTYPE GetCudaTextureObjectNVX(
+            uint32_t                srvDriverHandle,
+            uint32_t                samplerDriverHandle,
+            uint32_t*               pCudaTextureHandle);
+
+    bool STDMETHODCALLTYPE CreateCubinComputeShaderWithNameNVX(
+            const void*             pCubin,
+            uint32_t                size,
+            uint32_t                blockX,
+            uint32_t                blockY,
+            uint32_t                blockZ,
+            const char*             pShaderName,
+            IUnknown**              phShader);
+
+    bool STDMETHODCALLTYPE GetResourceHandleGPUVirtualAddressAndSizeNVX(
+            void*                   hObject,
+            uint64_t*               gpuVAStart,
+            uint64_t*               gpuVASize);
+
+     bool STDMETHODCALLTYPE CreateUnorderedAccessViewAndGetDriverHandleNVX(
+            ID3D11Resource*                         pResource,
+            const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
+            ID3D11UnorderedAccessView**             ppUAV,
+            uint32_t*                               pDriverHandle);
+
+     bool STDMETHODCALLTYPE CreateShaderResourceViewAndGetDriverHandleNVX(
+            ID3D11Resource*                        pResource,
+            const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
+            ID3D11ShaderResourceView**             ppSRV,
+            uint32_t*                              pDriverHandle);
+
+     bool STDMETHODCALLTYPE CreateSamplerStateAndGetDriverHandleNVX(
+            const D3D11_SAMPLER_DESC* pSamplerDesc,
+            ID3D11SamplerState**      ppSamplerState,
+            uint32_t*                 pDriverHandle);
+    
   private:
     
     D3D11DXGIDevice* m_container;
     D3D11Device*     m_device;
     
+    void AddSamplerAndHandleNVX(
+            ID3D11SamplerState*       pSampler,
+            uint32_t                  Handle);
+
+    ID3D11SamplerState* HandleToSamplerNVX(
+            uint32_t                  Handle);
+
+    void AddSrvAndHandleNVX(
+            ID3D11ShaderResourceView* pSrv,
+            uint32_t                  Handle);
+
+    ID3D11ShaderResourceView* HandleToSrvNVX(
+            uint32_t                  Handle);
+
+    bool LockImage(
+      const Rc<DxvkImage>&            Image,
+            VkImageUsageFlags         Usage);
+
+    void LockBuffer(
+      const Rc<DxvkBuffer>&           Buffer);
+
+    dxvk::mutex m_mapLock;
+    std::unordered_map<uint32_t, ID3D11SamplerState*> m_samplerHandleToPtr;
+    std::unordered_map<uint32_t, ID3D11ShaderResourceView*> m_srvHandleToPtr;
   };
-  
-  
+
+
   /**
-   * \brief DXGI swap chain factory
+   * \brief D3D11 video device
    */
-  class WineDXGISwapChainFactory : public IWineDXGISwapChainFactory {
-    
+  class D3D11VideoDevice : public ID3D11VideoDevice {
+
   public:
-    
-    WineDXGISwapChainFactory(
+
+    D3D11VideoDevice(
             D3D11DXGIDevice*        pContainer,
             D3D11Device*            pDevice);
-    
+
+    ~D3D11VideoDevice();
+
     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);
-    
+
+    HRESULT STDMETHODCALLTYPE CreateVideoDecoder(
+      const D3D11_VIDEO_DECODER_DESC*                     pVideoDesc,
+      const D3D11_VIDEO_DECODER_CONFIG*                   pConfig,
+            ID3D11VideoDecoder**                          ppDecoder);
+
+    HRESULT STDMETHODCALLTYPE CreateVideoProcessor(
+            ID3D11VideoProcessorEnumerator*               pEnum,
+            UINT                                          RateConversionIndex,
+            ID3D11VideoProcessor**                        ppVideoProcessor);
+
+    HRESULT STDMETHODCALLTYPE CreateAuthenticatedChannel(
+            D3D11_AUTHENTICATED_CHANNEL_TYPE              ChannelType,
+            ID3D11AuthenticatedChannel**                  ppAuthenticatedChannel);
+
+    HRESULT STDMETHODCALLTYPE CreateCryptoSession(
+      const GUID*                                         pCryptoType,
+      const GUID*                                         pDecoderProfile,
+      const GUID*                                         pKeyExchangeType,
+            ID3D11CryptoSession**                         ppCryptoSession);
+
+    HRESULT STDMETHODCALLTYPE CreateVideoDecoderOutputView(
+            ID3D11Resource*                               pResource,
+      const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC*         pDesc,
+            ID3D11VideoDecoderOutputView**                ppVDOVView);
+
+    HRESULT STDMETHODCALLTYPE CreateVideoProcessorInputView(
+            ID3D11Resource*                               pResource,
+            ID3D11VideoProcessorEnumerator*               pEnum,
+      const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC*        pDesc,
+            ID3D11VideoProcessorInputView**               ppVPIView);
+
+    HRESULT STDMETHODCALLTYPE CreateVideoProcessorOutputView(
+            ID3D11Resource*                               pResource,
+            ID3D11VideoProcessorEnumerator*               pEnum,
+      const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC*       pDesc,
+            ID3D11VideoProcessorOutputView**              ppVPOView);
+
+    HRESULT STDMETHODCALLTYPE CreateVideoProcessorEnumerator(
+      const D3D11_VIDEO_PROCESSOR_CONTENT_DESC*           pDesc,
+            ID3D11VideoProcessorEnumerator**              ppEnum);
+
+    UINT STDMETHODCALLTYPE GetVideoDecoderProfileCount();
+
+    HRESULT STDMETHODCALLTYPE GetVideoDecoderProfile(
+            UINT                                          Index,
+            GUID*                                         pDecoderProfile);
+
+    HRESULT STDMETHODCALLTYPE CheckVideoDecoderFormat(
+      const GUID*                                         pDecoderProfile,
+            DXGI_FORMAT                                   Format,
+            BOOL*                                         pSupported);
+
+    HRESULT STDMETHODCALLTYPE GetVideoDecoderConfigCount(
+      const D3D11_VIDEO_DECODER_DESC*                     pDesc,
+            UINT*                                         pCount);
+
+    HRESULT STDMETHODCALLTYPE GetVideoDecoderConfig(
+      const D3D11_VIDEO_DECODER_DESC*                     pDesc,
+            UINT                                          Index,
+            D3D11_VIDEO_DECODER_CONFIG*                   pConfig);
+
+    HRESULT STDMETHODCALLTYPE GetContentProtectionCaps(
+      const GUID*                                         pCryptoType,
+      const GUID*                                         pDecoderProfile,
+            D3D11_VIDEO_CONTENT_PROTECTION_CAPS*          pCaps);
+
+    HRESULT STDMETHODCALLTYPE CheckCryptoKeyExchange(
+      const GUID*                                         pCryptoType,
+      const GUID*                                         pDecoderProfile,
+            UINT                                          Index,
+            GUID*                                         pKeyExchangeType);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateData(
+            REFGUID                                       Name,
+            UINT                                          DataSize,
+      const void*                                         pData);
+
+    HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
+            REFGUID                                       Name,
+      const IUnknown*                                     pData);
+
   private:
-    
+
     D3D11DXGIDevice* m_container;
     D3D11Device*     m_device;
-    
+
   };
-  
+
+
+  /**
+   * \brief Nvidia Reflex interop
+   */
+  class D3D11ReflexDevice : public ID3DLowLatencyDevice {
+
+  public:
+
+    D3D11ReflexDevice(
+            D3D11DXGIDevice*        pContainer,
+            D3D11Device*            pDevice);
+
+    ~D3D11ReflexDevice();
+
+    ULONG STDMETHODCALLTYPE AddRef();
+
+    ULONG STDMETHODCALLTYPE Release();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                        riid,
+            void**                        ppvObject);
+
+    BOOL STDMETHODCALLTYPE SupportsLowLatency();
+
+    HRESULT STDMETHODCALLTYPE LatencySleep();
+
+    HRESULT STDMETHODCALLTYPE SetLatencySleepMode(
+            BOOL                          LowLatencyEnable,
+            BOOL                          LowLatencyBoost,
+            UINT32                        MinIntervalUs);
+
+    HRESULT STDMETHODCALLTYPE SetLatencyMarker(
+            UINT64                        FrameId,
+            UINT32                        MarkerType);
+
+    HRESULT STDMETHODCALLTYPE GetLatencyInfo(
+            D3D_LOW_LATENCY_RESULTS*      pLowLatencyResults);
+
+    void RegisterLatencyTracker(
+            Rc<DxvkLatencyTracker>          Tracker);
+
+    void UnregisterLatencyTracker(
+            Rc<DxvkLatencyTracker>          Tracker);
+
+  private:
+
+    D3D11DXGIDevice*  m_container;
+    D3D11Device*      m_device;
+
+    bool              m_reflexEnabled = false;
+
+    dxvk::mutex       m_mutex;
+
+    bool              m_enableLowLatency  = false;
+    bool              m_enableBoost       = false;
+    uint64_t          m_minIntervalUs     = 0u;
+
+    Rc<DxvkReflexLatencyTrackerNv>  m_tracker;
+  };
+
+
+  /**
+   * \brief DXVK swap chain factory
+   */
+  class DXGIVkSwapChainFactory : public IDXGIVkSwapChainFactory {
+
+  public:
+
+    DXGIVkSwapChainFactory(
+            D3D11DXGIDevice*        pContainer,
+            D3D11Device*            pDevice);
+
+    ULONG STDMETHODCALLTYPE AddRef();
+
+    ULONG STDMETHODCALLTYPE Release();
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID                  riid,
+            void**                  ppvObject);
+
+    HRESULT STDMETHODCALLTYPE CreateSwapChain(
+            IDXGIVkSurfaceFactory*    pSurfaceFactory,
+      const DXGI_SWAP_CHAIN_DESC1*    pDesc,
+            IDXGIVkSwapChain**        ppSwapChain);
+
+  private:
+
+    D3D11DXGIDevice* m_container;
+    D3D11Device*     m_device;
+
+  };
+
 
   /**
    * \brief D3D11 device metadata shenanigans
@@ -594,8 +893,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);
     
@@ -664,6 +966,10 @@ namespace dxvk {
     
     Rc<DxvkDevice> STDMETHODCALLTYPE GetDXVKDevice();
 
+    BOOL Is11on12Device() const {
+      return m_d3d11on12.Is11on12Device();
+    }
+
   private:
 
     Com<IDXGIAdapter>   m_dxgiAdapter;
@@ -675,14 +981,15 @@ namespace dxvk {
     D3D11Device         m_d3d11Device;
     D3D11DeviceExt      m_d3d11DeviceExt;
     D3D11VkInterop      m_d3d11Interop;
+    D3D11VideoDevice    m_d3d11Video;
+    D3D11ReflexDevice   m_d3d11Reflex;
+    D3D11on12Device     m_d3d11on12;
     DXGIDXVKDevice      m_metaDevice;
     
-    WineDXGISwapChainFactory m_wineFactory;
+    DXGIVkSwapChainFactory   m_dxvkFactory;
     
     uint32_t m_frameLatency = DefaultFrameLatency;
 
-    Rc<DxvkDevice> CreateDevice(D3D_FEATURE_LEVEL FeatureLevel);
-
   };
   
 }

src/d3d11/d3d11_device_child.h

@@ -5,39 +5,134 @@
 #include "../util/com/com_private_data.h"
 
 namespace dxvk {
-  
-  template<typename Base, template<class> class Wrapper = ComObject>
-  class D3D11DeviceChild : public Wrapper<Base> {
+
+  class D3D11Device;
+
+  template<typename Base>
+  class D3D11DeviceObject : public Base {
     
   public:
+
+    D3D11DeviceObject(D3D11Device* pDevice)
+    : m_parent(pDevice) {
+
+    }
     
     HRESULT STDMETHODCALLTYPE GetPrivateData(
-            REFGUID guid,
-            UINT    *pDataSize,
-            void    *pData) final {
+            REFGUID               guid,
+            UINT*                 pDataSize,
+            void*                 pData) final {
       return m_privateData.getData(
         guid, pDataSize, pData);
     }
     
     HRESULT STDMETHODCALLTYPE SetPrivateData(
-            REFGUID guid,
-            UINT    DataSize,
-      const void    *pData) final {
+            REFGUID               guid,
+            UINT                  DataSize,
+      const void*                 pData) final {
+      // WKPDID_D3DDebugObjectName, can't use directly due to MSVC link errors
+      if (guid == GUID{0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00})
+        SetDebugName(static_cast<const char*>(pData));
+
       return m_privateData.setData(
         guid, DataSize, pData);
     }
     
     HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
-            REFGUID  guid,
-      const IUnknown *pUnknown) final {
+            REFGUID               guid,
+      const IUnknown*             pUnknown) final {
       return m_privateData.setInterface(
         guid, pUnknown);
     }
+
+    void STDMETHODCALLTYPE GetDevice(
+            ID3D11Device**        ppDevice) final {
+      *ppDevice = ref(GetParentInterface());
+    }
+
+    virtual void STDMETHODCALLTYPE SetDebugName(const char* pName) {
+      // No-op by default
+    }
+
+  protected:
+
+    ID3D11Device* GetParentInterface() const {
+      // We don't know the definition of ID3D11Device
+      // here, because D3D11Device includes this file.
+      return reinterpret_cast<ID3D11Device*>(m_parent);
+    }
+
+    D3D11Device* const m_parent;
     
   private:
     
     ComPrivateData m_privateData;
     
   };
+
+  
+  template<typename Base>
+  class D3D11DeviceChild : public D3D11DeviceObject<ComObject<Base>> {
+    
+  public:
+
+    D3D11DeviceChild(D3D11Device* pDevice)
+    : D3D11DeviceObject<ComObject<Base>>(pDevice) {
+
+    }
+
+    ULONG STDMETHODCALLTYPE AddRef() {
+      uint32_t refCount = this->m_refCount++;
+      if (unlikely(!refCount)) {
+        this->AddRefPrivate();
+        this->GetParentInterface()->AddRef();
+      }
+
+      return refCount + 1;
+    }
+    
+    ULONG STDMETHODCALLTYPE Release() {
+      uint32_t refCount = --this->m_refCount;
+      if (unlikely(!refCount)) {
+        auto* parent = this->GetParentInterface();
+        this->ReleasePrivate();
+        parent->Release();
+      }
+      return refCount;
+    }
+    
+  };
+
+  template<typename Base>
+  class D3D11StateObject : public D3D11DeviceObject<Base> {
+    
+  public:
+
+    D3D11StateObject(D3D11Device* pDevice)
+    : D3D11DeviceObject<Base>(pDevice) {
+
+    }
+
+    ULONG STDMETHODCALLTYPE AddRef() {
+      uint32_t refCount = this->m_refCount++;
+      if (unlikely(!refCount))
+        this->GetParentInterface()->AddRef();
+
+      return refCount + 1;
+    }
+    
+    ULONG STDMETHODCALLTYPE Release() {
+      uint32_t refCount = --this->m_refCount;
+      if (unlikely(!refCount))
+        this->GetParentInterface()->Release();
+
+      return refCount;
+    }
+
+  private:
+
+    std::atomic<uint32_t> m_refCount = { 0u };
+    
+  };
   
 }

src/d3d11/d3d11_enums.cpp

@@ -9,6 +9,8 @@ std::ostream& operator << (std::ostream& os, D3D_FEATURE_LEVEL e) {
     ENUM_NAME(D3D_FEATURE_LEVEL_10_1);
     ENUM_NAME(D3D_FEATURE_LEVEL_11_0);
     ENUM_NAME(D3D_FEATURE_LEVEL_11_1);
+    ENUM_NAME(D3D_FEATURE_LEVEL_12_0);
+    ENUM_NAME(D3D_FEATURE_LEVEL_12_1);
     ENUM_DEFAULT(e);
   }
 }

src/d3d11/d3d11_features.cpp

@@ -0,0 +1,401 @@
+#include <array>
+
+#include "d3d11_features.h"
+
+namespace dxvk {
+
+  D3D11DeviceFeatures::D3D11DeviceFeatures() {
+
+  }
+
+
+  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()) {
+    // Assume no TBDR. DXVK does not optimize for TBDR architectures
+    // anyway, and D3D11 does not really provide meaningful support.
+    m_architectureInfo.TileBasedDeferredRenderer          = FALSE;
+
+    // D3D9 options. We unconditionally support all of these.
+    m_d3d9Options.FullNonPow2TextureSupport               = TRUE;
+
+    m_d3d9Options1.FullNonPow2TextureSupported            = TRUE;
+    m_d3d9Options1.DepthAsTextureWithLessEqualComparisonFilterSupported = TRUE;
+    m_d3d9Options1.SimpleInstancingSupported              = TRUE;
+    m_d3d9Options1.TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported = TRUE;
+
+    m_d3d9Shadow.SupportsDepthAsTextureWithLessEqualComparisonFilter = TRUE;
+
+    m_d3d9SimpleInstancing.SimpleInstancingSupported      = TRUE;
+
+    // D3D10 options. We unconditionally support compute shaders.
+    m_d3d10Options.ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x = TRUE;
+
+    // D3D11.1 options. All of these are required for Feature Level 11_1.
+    auto sharedResourceTier = DetermineSharedResourceTier(Adapter, FeatureLevel);
+
+    bool hasDoublePrecisionSupport = m_features.core.features.shaderFloat64
+                                  && m_features.core.features.shaderInt64;
+
+    m_d3d11Options.DiscardAPIsSeenByDriver                = TRUE;
+    m_d3d11Options.FlagsForUpdateAndCopySeenByDriver      = TRUE;
+    m_d3d11Options.ClearView                              = TRUE;
+    m_d3d11Options.CopyWithOverlap                        = TRUE;
+    m_d3d11Options.ConstantBufferPartialUpdate            = TRUE;
+    m_d3d11Options.ConstantBufferOffsetting               = TRUE;
+    m_d3d11Options.MapNoOverwriteOnDynamicConstantBuffer  = TRUE;
+    m_d3d11Options.MapNoOverwriteOnDynamicBufferSRV       = TRUE;
+    m_d3d11Options.ExtendedResourceSharing                = sharedResourceTier > D3D11_SHARED_RESOURCE_TIER_0;
+
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_10_0) {
+      m_d3d11Options.OutputMergerLogicOp                  = m_features.core.features.logicOp;
+      m_d3d11Options.MultisampleRTVWithForcedSampleCountOne = TRUE; // Not really
+    }
+
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_0) {
+      m_d3d11Options.UAVOnlyRenderingForcedSampleCount    = TRUE;
+      m_d3d11Options.SAD4ShaderInstructions               = TRUE;
+      m_d3d11Options.ExtendedDoublesShaderInstructions    = hasDoublePrecisionSupport;
+    }
+
+    // D3D11.2 options.
+    auto tiledResourcesTier = DetermineTiledResourcesTier(FeatureLevel);
+    m_d3d11Options1.TiledResourcesTier                    = tiledResourcesTier;
+    m_d3d11Options1.MinMaxFiltering                       = tiledResourcesTier >= D3D11_TILED_RESOURCES_TIER_2;
+    m_d3d11Options1.ClearViewAlsoSupportsDepthOnlyFormats = TRUE;
+
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_0)
+      m_d3d11Options1.MapOnDefaultBuffers                 = TRUE;
+
+    // D3D11.3 options
+    m_d3d11Options2.TypedUAVLoadAdditionalFormats         = DetermineUavExtendedTypedLoadSupport(Adapter, FeatureLevel);
+    m_d3d11Options2.ConservativeRasterizationTier         = DetermineConservativeRasterizationTier(FeatureLevel);
+    m_d3d11Options2.TiledResourcesTier                    = tiledResourcesTier;
+    m_d3d11Options2.StandardSwizzle                       = FALSE;
+    m_d3d11Options2.UnifiedMemoryArchitecture             = FALSE;
+
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_0)
+      m_d3d11Options2.MapOnDefaultTextures                = TRUE;
+
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_1) {
+      m_d3d11Options2.ROVsSupported                       = m_features.extFragmentShaderInterlock.fragmentShaderPixelInterlock;
+      m_d3d11Options2.PSSpecifiedStencilRefSupported      = m_features.extShaderStencilExport;
+    }
+
+    // More D3D11.3 options
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_0) {
+      m_d3d11Options3.VPAndRTArrayIndexFromAnyShaderFeedingRasterizer =
+        m_features.vk12.shaderOutputViewportIndex &&
+        m_features.vk12.shaderOutputLayer;
+    }
+
+    // D3D11.4 options
+    m_d3d11Options4.ExtendedNV12SharedTextureSupported    = sharedResourceTier > D3D11_SHARED_RESOURCE_TIER_0;
+
+    // More D3D11.4 options
+    m_d3d11Options5.SharedResourceTier                    = sharedResourceTier;
+
+    // Double-precision support
+    if (FeatureLevel >= D3D_FEATURE_LEVEL_11_0)
+      m_doubles.DoublePrecisionFloatShaderOps             = hasDoublePrecisionSupport;
+
+    // These numbers are not accurate, but we have no real way to query these
+    m_gpuVirtualAddress.MaxGPUVirtualAddressBitsPerResource = 32;
+    m_gpuVirtualAddress.MaxGPUVirtualAddressBitsPerProcess = 40;
+
+    // Marker support only depends on the debug utils extension
+    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.
+    m_shaderCache.SupportFlags = D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE
+                               | D3D11_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE;
+
+    // DXVK does not support min precision
+    m_shaderMinPrecision.PixelShaderMinPrecision          = 0;
+    m_shaderMinPrecision.AllOtherShaderStagesMinPrecision = 0;
+
+    // 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                        = Options.exposeDriverCommandLists;
+  }
+
+
+  D3D11DeviceFeatures::~D3D11DeviceFeatures() {
+
+  }
+
+
+  HRESULT D3D11DeviceFeatures::GetFeatureData(
+          D3D11_FEATURE         Feature,
+          UINT                  FeatureDataSize,
+          void*                 pFeatureData) const {
+    switch (Feature) {
+      case D3D11_FEATURE_ARCHITECTURE_INFO:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_architectureInfo);
+      case D3D11_FEATURE_D3D9_OPTIONS:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d9Options);
+      case D3D11_FEATURE_D3D9_OPTIONS1:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d9Options1);
+      case D3D11_FEATURE_D3D9_SHADOW_SUPPORT:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d9Shadow);
+      case D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d9SimpleInstancing);
+      case D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d10Options);
+      case D3D11_FEATURE_D3D11_OPTIONS:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options);
+      case D3D11_FEATURE_D3D11_OPTIONS1:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options1);
+      case D3D11_FEATURE_D3D11_OPTIONS2:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options2);
+      case D3D11_FEATURE_D3D11_OPTIONS3:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options3);
+      case D3D11_FEATURE_D3D11_OPTIONS4:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options4);
+      case D3D11_FEATURE_D3D11_OPTIONS5:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_d3d11Options5);
+      case D3D11_FEATURE_DOUBLES:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_doubles);
+      case D3D11_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_gpuVirtualAddress);
+      case D3D11_FEATURE_MARKER_SUPPORT:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_marker);
+      case D3D11_FEATURE_SHADER_CACHE:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_shaderCache);
+      case D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_shaderMinPrecision);
+      case D3D11_FEATURE_THREADING:
+        return GetTypedFeatureData(FeatureDataSize, pFeatureData, &m_threading);
+      default:
+        Logger::err(str::format("D3D11: Unknown feature: ", Feature));
+        return E_INVALIDARG;
+    }
+  }
+
+
+  D3D_FEATURE_LEVEL D3D11DeviceFeatures::GetMaxFeatureLevel(
+    const Rc<DxvkInstance>&     Instance,
+    const Rc<DxvkAdapter>&      Adapter) {
+    D3D11Options options(Instance->config());
+    D3D11DeviceFeatures features(Instance, Adapter, options, D3D_FEATURE_LEVEL_12_1);
+    return features.GetMaxFeatureLevel();
+  }
+
+
+  D3D11_CONSERVATIVE_RASTERIZATION_TIER D3D11DeviceFeatures::DetermineConservativeRasterizationTier(
+          D3D_FEATURE_LEVEL     FeatureLevel) {
+    if (FeatureLevel < D3D_FEATURE_LEVEL_11_1
+     || !m_features.extConservativeRasterization)
+      return D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED;
+
+    // We don't really have a way to query uncertainty regions,
+    // so just check degenerate triangle behaviour
+    if (!m_properties.extConservativeRasterization.degenerateTrianglesRasterized)
+      return D3D11_CONSERVATIVE_RASTERIZATION_TIER_1;
+
+    // Inner coverage is required for Tier 3 support
+    if (!m_properties.extConservativeRasterization.fullyCoveredFragmentShaderInputVariable)
+      return D3D11_CONSERVATIVE_RASTERIZATION_TIER_2;
+
+    return D3D11_CONSERVATIVE_RASTERIZATION_TIER_3;
+  }
+
+
+  D3D11_SHARED_RESOURCE_TIER D3D11DeviceFeatures::DetermineSharedResourceTier(
+    const Rc<DxvkAdapter>&      Adapter,
+          D3D_FEATURE_LEVEL     FeatureLevel) {
+    static std::atomic<bool> s_errorShown = { false };
+
+    // Lie about supporting Tier 1 since that's the
+    // minimum required tier for Feature Level 11_1
+    if (!Adapter->features().khrExternalMemoryWin32) {
+      if (!s_errorShown.exchange(true))
+        Logger::warn("D3D11DeviceFeatures: External memory features not supported");
+
+      return D3D11_SHARED_RESOURCE_TIER_1;
+    }
+
+    // Check support for extended formats. Ignore multi-plane
+    // formats here since driver support varies too much.
+    std::array<VkFormat, 30> requiredFormats = {{
+      VK_FORMAT_R16G16B16A16_SFLOAT,
+      VK_FORMAT_R32G32B32A32_SFLOAT,
+      VK_FORMAT_R32G32B32A32_UINT,
+      VK_FORMAT_R32G32B32A32_SINT,
+      VK_FORMAT_R16G16B16A16_SFLOAT,
+      VK_FORMAT_R16G16B16A16_UNORM,
+      VK_FORMAT_R16G16B16A16_UINT,
+      VK_FORMAT_R16G16B16A16_SNORM,
+      VK_FORMAT_R16G16B16A16_SINT,
+      VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+      VK_FORMAT_A2B10G10R10_UINT_PACK32,
+      VK_FORMAT_R8G8B8A8_UNORM,
+      VK_FORMAT_R8G8B8A8_SRGB,
+      VK_FORMAT_R8G8B8A8_UINT,
+      VK_FORMAT_R8G8B8A8_SNORM,
+      VK_FORMAT_R8G8B8A8_SINT,
+      VK_FORMAT_B8G8R8A8_UNORM,
+      VK_FORMAT_B8G8R8A8_SRGB,
+      VK_FORMAT_R32_SFLOAT,
+      VK_FORMAT_R32_UINT,
+      VK_FORMAT_R32_SINT,
+      VK_FORMAT_R16_SFLOAT,
+      VK_FORMAT_R16_UNORM,
+      VK_FORMAT_R16_UINT,
+      VK_FORMAT_R16_SNORM,
+      VK_FORMAT_R16_SINT,
+      VK_FORMAT_R8_UNORM,
+      VK_FORMAT_R8_UINT,
+      VK_FORMAT_R8_SNORM,
+      VK_FORMAT_R8_SINT,
+    }};
+
+    bool allKmtHandlesSupported = true;
+    bool allNtHandlesSupported = true;
+
+    for (auto f : requiredFormats) {
+      allKmtHandlesSupported &= CheckFormatSharingSupport(Adapter, f, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT);
+      allNtHandlesSupported &= CheckFormatSharingSupport(Adapter, f, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT);
+    }
+
+    // Again, lie about at least tier 1 support
+    if (!allKmtHandlesSupported) {
+      if (!s_errorShown.exchange(true))
+        Logger::warn("D3D11DeviceFeatures: Some formats not supported for resource sharing");
+      return D3D11_SHARED_RESOURCE_TIER_1;
+    }
+
+    // Tier 2 requires all the above formats to be shareable
+    // with NT handles in order to support D3D12 interop
+    if (!allNtHandlesSupported)
+      return D3D11_SHARED_RESOURCE_TIER_1;
+
+    // Tier 3 additionally requires R11G11B10 to be
+    // shareable with D3D12
+    if (!CheckFormatSharingSupport(Adapter, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT))
+      return D3D11_SHARED_RESOURCE_TIER_2;
+
+    return D3D11_SHARED_RESOURCE_TIER_3;
+  }
+
+
+  D3D11_TILED_RESOURCES_TIER D3D11DeviceFeatures::DetermineTiledResourcesTier(
+          D3D_FEATURE_LEVEL     FeatureLevel) {
+    if (FeatureLevel < D3D_FEATURE_LEVEL_11_0
+     || !m_features.core.features.sparseBinding
+     || !m_features.core.features.sparseResidencyBuffer
+     || !m_features.core.features.sparseResidencyImage2D
+     || !m_features.core.features.sparseResidencyAliased
+     || !m_properties.core.properties.sparseProperties.residencyStandard2DBlockShape)
+      return D3D11_TILED_RESOURCES_NOT_SUPPORTED;
+
+    if (FeatureLevel < D3D_FEATURE_LEVEL_11_1
+     || !m_features.core.features.shaderResourceResidency
+     || !m_features.core.features.shaderResourceMinLod
+     || !m_features.vk12.samplerFilterMinmax
+     || !m_properties.vk12.filterMinmaxSingleComponentFormats
+     || !m_properties.core.properties.sparseProperties.residencyNonResidentStrict
+     || m_properties.core.properties.sparseProperties.residencyAlignedMipSize)
+      return D3D11_TILED_RESOURCES_TIER_1;
+
+    if (!m_features.core.features.sparseResidencyImage3D
+     || !m_properties.core.properties.sparseProperties.residencyStandard3DBlockShape)
+      return D3D11_TILED_RESOURCES_TIER_2;
+
+    return D3D11_TILED_RESOURCES_TIER_3;
+  }
+
+
+  BOOL D3D11DeviceFeatures::DetermineUavExtendedTypedLoadSupport(
+    const Rc<DxvkAdapter>&      Adapter,
+          D3D_FEATURE_LEVEL     FeatureLevel) {
+    static const std::array<VkFormat, 18> s_formats = {{
+      VK_FORMAT_R32_SFLOAT,
+      VK_FORMAT_R32_UINT,
+      VK_FORMAT_R32_SINT,
+      VK_FORMAT_R32G32B32A32_SFLOAT,
+      VK_FORMAT_R32G32B32A32_UINT,
+      VK_FORMAT_R32G32B32A32_SINT,
+      VK_FORMAT_R16G16B16A16_SFLOAT,
+      VK_FORMAT_R16G16B16A16_UINT,
+      VK_FORMAT_R16G16B16A16_SINT,
+      VK_FORMAT_R8G8B8A8_UNORM,
+      VK_FORMAT_R8G8B8A8_UINT,
+      VK_FORMAT_R8G8B8A8_SINT,
+      VK_FORMAT_R16_SFLOAT,
+      VK_FORMAT_R16_UINT,
+      VK_FORMAT_R16_SINT,
+      VK_FORMAT_R8_UNORM,
+      VK_FORMAT_R8_UINT,
+      VK_FORMAT_R8_SINT,
+    }};
+
+    if (FeatureLevel < D3D_FEATURE_LEVEL_11_0)
+      return FALSE;
+
+    for (auto f : s_formats) {
+      DxvkFormatFeatures features = Adapter->getFormatFeatures(f);
+      VkFormatFeatureFlags2 imgFeatures = features.optimal | features.linear;
+
+      if (!(imgFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT))
+        return FALSE;
+    }
+
+    return TRUE;
+  }
+
+
+  BOOL D3D11DeviceFeatures::CheckFormatSharingSupport(
+    const Rc<DxvkAdapter>&      Adapter,
+          VkFormat              Format,
+          VkExternalMemoryHandleTypeFlagBits HandleType) {
+    DxvkFormatQuery query = { };
+    query.format = Format;
+    query.type = VK_IMAGE_TYPE_2D;
+    query.tiling = VK_IMAGE_TILING_OPTIMAL;
+    query.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    query.handleType = HandleType;
+
+    constexpr VkExternalMemoryFeatureFlags featureMask
+      = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
+      | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
+
+    auto limits = Adapter->getFormatLimits(query);
+    return limits && (limits->externalFeatures & featureMask);
+  }
+
+
+  D3D_FEATURE_LEVEL D3D11DeviceFeatures::GetMaxFeatureLevel() const {
+    // Check Feature Level 11_0 features
+    if (!m_features.core.features.drawIndirectFirstInstance
+     || !m_features.core.features.fragmentStoresAndAtomics
+     || !m_features.core.features.multiDrawIndirect
+     || !m_features.core.features.tessellationShader)
+      return D3D_FEATURE_LEVEL_10_1;
+
+    // Check Feature Level 11_1 features
+    if (!m_d3d11Options.OutputMergerLogicOp
+     || !m_features.core.features.vertexPipelineStoresAndAtomics)
+      return D3D_FEATURE_LEVEL_11_0;
+
+    // Check Feature Level 12_0 features
+    if (m_d3d11Options2.TiledResourcesTier < D3D11_TILED_RESOURCES_TIER_2
+     || !m_d3d11Options2.TypedUAVLoadAdditionalFormats)
+      return D3D_FEATURE_LEVEL_11_1;
+
+    // Check Feature Level 12_1 features
+    if (!m_d3d11Options2.ConservativeRasterizationTier
+     || !m_d3d11Options2.ROVsSupported)
+      return D3D_FEATURE_LEVEL_12_0;
+
+    return D3D_FEATURE_LEVEL_12_1;
+  }
+
+}

src/d3d11/d3d11_features.h

@@ -0,0 +1,126 @@
+#pragma once
+
+#include "d3d11_include.h"
+#include "d3d11_options.h"
+
+#include "../dxvk/dxvk_adapter.h"
+#include "../dxvk/dxvk_instance.h"
+
+namespace dxvk {
+
+  /**
+   * \brief Device features
+   *
+   * Stores D3D device feature structs.
+   */
+  class D3D11DeviceFeatures {
+
+  public:
+
+    D3D11DeviceFeatures();
+
+    D3D11DeviceFeatures(
+      const Rc<DxvkInstance>&     Instance,
+      const Rc<DxvkAdapter>&      Adapter,
+      const D3D11Options&         Options,
+            D3D_FEATURE_LEVEL     FeatureLevel);
+
+    ~D3D11DeviceFeatures();
+
+    /**
+     * \brief Retrieves feature support data
+     *
+     * \param [in] Feature D3D feature to query
+     * \param [in] FeatureDataSize Data size, in bytes
+     * \param [out] pFeatureData Data
+     * \returns Status of the operation
+     */
+    HRESULT GetFeatureData(
+            D3D11_FEATURE         Feature,
+            UINT                  FeatureDataSize,
+            void*                 pFeatureData) const;
+
+    /**
+     * \brief Queries tiled resources tier
+     * \returns Tiled resources tier
+     */
+    D3D11_TILED_RESOURCES_TIER GetTiledResourcesTier() const {
+      return m_d3d11Options2.TiledResourcesTier;
+    }
+
+    /**
+     * \brief Queries conservative rasterization tier
+     * \returns Conservative rasterization tier
+     */
+    D3D11_CONSERVATIVE_RASTERIZATION_TIER GetConservativeRasterizationTier() const {
+      return m_d3d11Options2.ConservativeRasterizationTier;
+    }
+
+    /**
+     * \brief Tests maximum supported feature level
+     *
+     * \param [in] Instance DXVK instance
+     * \param [in] Adapter DXVK adapter
+     * \returns Highest supported feature level
+     */
+    static D3D_FEATURE_LEVEL GetMaxFeatureLevel(
+      const Rc<DxvkInstance>&     Instance,
+      const Rc<DxvkAdapter>&      Adapter);
+
+  private:
+
+    DxvkDeviceFeatures  m_features;
+    DxvkDeviceInfo      m_properties;
+
+    D3D11_FEATURE_DATA_ARCHITECTURE_INFO              m_architectureInfo            = { };
+    D3D11_FEATURE_DATA_D3D9_OPTIONS                   m_d3d9Options                 = { };
+    D3D11_FEATURE_DATA_D3D9_OPTIONS1                  m_d3d9Options1                = { };
+    D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT            m_d3d9Shadow                  = { };
+    D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT m_d3d9SimpleInstancing        = { };
+    D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS       m_d3d10Options                = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS                  m_d3d11Options                = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS1                 m_d3d11Options1               = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS2                 m_d3d11Options2               = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS3                 m_d3d11Options3               = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS4                 m_d3d11Options4               = { };
+    D3D11_FEATURE_DATA_D3D11_OPTIONS5                 m_d3d11Options5               = { };
+    D3D11_FEATURE_DATA_DOUBLES                        m_doubles                     = { };
+    D3D11_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT    m_gpuVirtualAddress           = { };
+    D3D11_FEATURE_DATA_MARKER_SUPPORT                 m_marker                      = { };
+    D3D11_FEATURE_DATA_SHADER_CACHE                   m_shaderCache                 = { };
+    D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT   m_shaderMinPrecision          = { };
+    D3D11_FEATURE_DATA_THREADING                      m_threading                   = { };
+
+    template<typename T>
+    static HRESULT GetTypedFeatureData(UINT Size, void* pDstData, const T* pSrcData) {
+      if (Size != sizeof(T))
+        return E_INVALIDARG;
+
+      *(reinterpret_cast<T*>(pDstData)) = *pSrcData;
+      return S_OK;
+    }
+
+    D3D11_CONSERVATIVE_RASTERIZATION_TIER DetermineConservativeRasterizationTier(
+            D3D_FEATURE_LEVEL     FeatureLevel);
+
+    D3D11_SHARED_RESOURCE_TIER DetermineSharedResourceTier(
+      const Rc<DxvkAdapter>&      Adapter,
+            D3D_FEATURE_LEVEL     FeatureLevel);
+
+    D3D11_TILED_RESOURCES_TIER DetermineTiledResourcesTier(
+            D3D_FEATURE_LEVEL     FeatureLevel);
+
+    BOOL DetermineUavExtendedTypedLoadSupport(
+      const Rc<DxvkAdapter>&      Adapter,
+            D3D_FEATURE_LEVEL     FeatureLevel);
+
+    BOOL CheckFormatSharingSupport(
+      const Rc<DxvkAdapter>&      Adapter,
+            VkFormat              Format,
+            VkExternalMemoryHandleTypeFlagBits HandleType);
+
+    D3D_FEATURE_LEVEL GetMaxFeatureLevel() const;
+
+  };
+
+}

src/d3d11/d3d11_fence.cpp

@@ -0,0 +1,105 @@
+#include "d3d11_fence.h"
+#include "d3d11_device.h"
+#include "../util/util_win32_compat.h"
+
+namespace dxvk {
+  
+  D3D11Fence::D3D11Fence(
+          D3D11Device*        pDevice,
+          UINT64              InitialValue,
+          D3D11_FENCE_FLAG    Flags,
+          HANDLE              hFence)
+  : D3D11DeviceChild<ID3D11Fence>(pDevice) {
+    DxvkFenceCreateInfo fenceInfo;
+    fenceInfo.initialValue = InitialValue;
+    m_flags = Flags;
+
+    if (Flags & D3D11_FENCE_FLAG_SHARED) {
+      fenceInfo.sharedType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT;
+      if (hFence == nullptr)
+        hFence = INVALID_HANDLE_VALUE;
+      fenceInfo.sharedHandle = hFence;
+    }
+
+    if (Flags & ~D3D11_FENCE_FLAG_SHARED)
+      Logger::err(str::format("Fence flags 0x", std::hex, Flags, " not supported"));
+
+    m_fence = pDevice->GetDXVKDevice()->createFence(fenceInfo);
+  }
+
+
+  D3D11Fence::~D3D11Fence() {
+
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11Fence::QueryInterface(
+          REFIID              riid,
+          void**              ppvObject) {
+    if (ppvObject == nullptr)
+      return E_POINTER;
+
+    *ppvObject = nullptr;
+    
+    if (riid == __uuidof(IUnknown)
+     || riid == __uuidof(ID3D11DeviceChild)
+     || riid == __uuidof(ID3D11Fence)) {
+      *ppvObject = ref(this);
+      return S_OK;
+    }
+
+    if (logQueryInterfaceError(__uuidof(ID3D11Fence), riid)) {
+      Logger::warn("D3D11Fence: Unknown interface query");
+      Logger::warn(str::format(riid));
+    }
+
+    return E_NOINTERFACE;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11Fence::CreateSharedHandle(
+    const SECURITY_ATTRIBUTES* pAttributes,
+          DWORD               dwAccess,
+          LPCWSTR             lpName,
+          HANDLE*             pHandle) {
+    if (!(m_flags & D3D11_FENCE_FLAG_SHARED))
+      return E_INVALIDARG;
+
+    if (pAttributes)
+      Logger::warn(str::format("CreateSharedHandle: attributes ", pAttributes, " not handled"));
+    if (dwAccess)
+      Logger::warn(str::format("CreateSharedHandle: access ", dwAccess, " not handled"));
+    if (lpName)
+      Logger::warn(str::format("CreateSharedHandle: name ", dxvk::str::fromws(lpName), " not handled"));
+
+    HANDLE sharedHandle = m_fence->sharedHandle();
+    if (sharedHandle == INVALID_HANDLE_VALUE)
+      return E_INVALIDARG;
+
+    *pHandle = sharedHandle;
+    return S_OK;
+  }
+
+
+  HRESULT STDMETHODCALLTYPE D3D11Fence::SetEventOnCompletion(
+          UINT64              Value,
+          HANDLE              hEvent) {
+    if (hEvent) {
+      m_fence->enqueueWait(Value, [hEvent] {
+        SetEvent(hEvent);
+      });
+    } else {
+      m_fence->wait(Value);
+    }
+    return S_OK;
+  }
+
+
+  UINT64 STDMETHODCALLTYPE D3D11Fence::GetCompletedValue() {
+    // TODO in the case of rewinds, the stored value may be higher.
+    // For shared fences, calling vkGetSemaphoreCounterValue here could alleviate the issue.
+
+    return m_fence->getValue();
+  }
+  
+}

src/d3d11/d3d11_fence.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../dxvk/dxvk_fence.h"
+#include "../dxvk/dxvk_gpu_query.h"
+
+#include "d3d11_device_child.h"
+
+namespace dxvk {
+  
+  class D3D11Fence : public D3D11DeviceChild<ID3D11Fence> {
+
+  public:
+    
+    D3D11Fence(
+            D3D11Device*        pDevice,
+            UINT64              InitialValue,
+            D3D11_FENCE_FLAG    Flags,
+            HANDLE              hFence);
+
+    ~D3D11Fence();
+    
+    HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID              riid,
+            void**              ppvObject);
+
+    HRESULT STDMETHODCALLTYPE CreateSharedHandle(
+      const SECURITY_ATTRIBUTES* pAttributes,
+            DWORD               dwAccess,
+            LPCWSTR             lpName,
+            HANDLE*             pHandle);
+
+    HRESULT STDMETHODCALLTYPE SetEventOnCompletion(
+            UINT64              Value,
+            HANDLE              hEvent);
+
+    UINT64 STDMETHODCALLTYPE GetCompletedValue();
+
+    Rc<DxvkFence> GetFence() const {
+      return m_fence;
+    }
+    
+  private:
+    
+    Rc<DxvkFence> m_fence;
+    D3D11_FENCE_FLAG m_flags;
+
+  };
+  
+}