diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 236add1f..dba1e3d0 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.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/doitsujin/dxvk/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. \ No newline at end of file diff --git a/.github/workflows/artifacts.yml b/.github/workflows/artifacts.yml index 94162e1c..9fe6485a 100644 --- a/.github/workflows/artifacts.yml +++ b/.github/workflows/artifacts.yml @@ -3,23 +3,23 @@ name: Artifacts (Package) on: [push, pull_request, workflow_dispatch] jobs: - build-artifacts: + artifacts-mingw-w64: runs-on: ubuntu-20.04 steps: - name: Checkout code id: checkout-code - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: submodules: recursive fetch-depth: 0 - name: Setup problem matcher - uses: Joshua-Ashton/gcc-problem-matcher@v1 + uses: Joshua-Ashton/gcc-problem-matcher@v2 - name: Build release id: build-release - uses: Joshua-Ashton/arch-mingw-github-action@v7 + uses: Joshua-Ashton/arch-mingw-github-action@v8 with: command: | export VERSION_NAME="${GITHUB_REF##*/}-${GITHUB_SHA##*/}" @@ -28,8 +28,39 @@ jobs: - name: Upload artifacts id: upload-artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v3 with: name: dxvk-${{ env.VERSION_NAME }} path: build/dxvk-${{ env.VERSION_NAME }} if-no-files-found: error + + artifacts-steamrt-sniper: + runs-on: ubuntu-20.04 + container: registry.gitlab.steamos.cloud/steamrt/sniper/sdk:beta + + steps: + - name: Checkout code + id: checkout-code + uses: actions/checkout@v3 + with: + submodules: recursive + fetch-depth: 0 + + - name: Setup problem matcher + uses: Joshua-Ashton/gcc-problem-matcher@v2 + + - name: Build release + id: build-release + shell: bash + run: | + export VERSION_NAME="${GITHUB_REF##*/}-${GITHUB_SHA##*/}" + ./package-native.sh ${VERSION_NAME} build --no-package + echo "VERSION_NAME=${VERSION_NAME}" >> $GITHUB_ENV + + - name: Upload artifacts + id: upload-artifacts + uses: actions/upload-artifact@v3 + with: + name: dxvk-${{ env.VERSION_NAME }} + path: build/dxvk-native-${{ env.VERSION_NAME }} + if-no-files-found: error diff --git a/.github/workflows/test-build-windows.yml b/.github/workflows/test-build-windows.yml index 67c3bfd6..6d8489ad 100644 --- a/.github/workflows/test-build-windows.yml +++ b/.github/workflows/test-build-windows.yml @@ -9,16 +9,15 @@ jobs: steps: - name: Checkout code id: checkout-code - uses: actions/checkout@v2 + uses: actions/checkout@v3 with: submodules: recursive - name: Setup glslangValidator shell: pwsh run: | - choco install vulkan-sdk -y - Write-Output "$([System.Environment]::GetEnvironmentVariable('VULKAN_SDK', 'Machine'))\Bin" ` - | Out-File -FilePath "${Env:GITHUB_PATH}" -Append + Invoke-WebRequest -Uri "https://raw.githubusercontent.com/HansKristian-Work/vkd3d-proton-ci/main/glslangValidator.exe" -OutFile "glslangValidator.exe" + Write-Output "$pwd" | Out-File -FilePath "${Env:GITHUB_PATH}" -Append - name: Setup Meson shell: pwsh diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..25deda64 --- /dev/null +++ b/.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 diff --git a/LICENSE b/LICENSE index a9d4337e..253cadd6 100644 --- a/LICENSE +++ b/LICENSE @@ -1,5 +1,5 @@ - Copyright (c) 2017-2021 Philip Rebohle - Copyright (c) 2019-2021 Joshua Ashton + Copyright (c) 2017 Philip Rebohle + Copyright (c) 2019 Joshua Ashton zlib/libpng license diff --git a/README.md b/README.md index 7da0418e..7cc7f787 100644 --- a/README.md +++ b/README.md @@ -9,34 +9,45 @@ The most recent development builds can be found [here](https://github.com/doitsu Release builds can be found [here](https://github.com/doitsujin/dxvk/releases). ## How to use -In order to install a DXVK package obtained from the [release](https://github.com/doitsujin/dxvk/releases) page into a given wine prefix, run the following commands from within the DXVK directory: +In order to install a DXVK package obtained from the [release](https://github.com/doitsujin/dxvk/releases) page into a given wine prefix, copy or symlink the DLLs into the following directories as follows, then open `winecfg` and manually add DLL overrides for `d3d11`, `d3d10core`, `dxgi`, and `d3d9`. +In a default Wine prefix that would be as follows: ``` -export WINEPREFIX=/path/to/.wine-prefix -./setup_dxvk.sh install +export WINEPREFIX=/path/to/wineprefix +cp x64/*.dll $WINEPREFIX/drive_c/windows/system32 +cp x32/*.dll $WINEPREFIX/drive_c/windows/syswow64 +winecfg ``` -This will **copy** the DLLs into the `system32` and `syswow64` directories of your wine prefix and set up the required DLL overrides. Pure 32-bit prefixes are also supported. - -The setup script optionally takes the following arguments: -- `--symlink`: Create symbolic links to the DLL files instead of copying them. This is especially useful for development. -- `--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. - -Verify that your application uses DXVK instead of wined3d by checking for the presence of the log file `d3d9.log` or `d3d11.log` in the application's directory, or by enabling the HUD (see notes below). - -In order to remove DXVK from a prefix, run the following command: +For a pure 32-bit Wine prefix (non default) the 32-bit DLLs instead go to the `system32` directory: ``` -export WINEPREFIX=/path/to/.wine-prefix -./setup_dxvk.sh uninstall +export WINEPREFIX=/path/to/wineprefix +cp x32/*.dll $WINEPREFIX/drive_c/windows/system32 +winecfg ``` +Verify that your application uses DXVK instead of wined3d by enabling the HUD (see notes below). + +In order to remove DXVK from a prefix, remove the DLLs and DLL overrides, and run `wineboot -u` to restore the original DLL files. + +Tools such as Steam Play, Lutris, Bottles, Heroic Launcher, etc will automatically handle setup of dxvk on their own when enabled. + +### Notes on Vulkan drivers +Before reporting an issue, please check the [Wiki](https://github.com/doitsujin/dxvk/wiki/Driver-support) page on the current driver status and make sure you run a recent enough driver version for your hardware. + ## Build instructions +In order to pull in all submodules that are needed for building, clone the repository using the following command: +``` +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](https://www.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.49) +- [Mingw-w64](https://www.mingw-w64.org) compiler and headers (at least version 10.0) - [glslang](https://github.com/KhronosGroup/glslang) compiler ### Building DLLs @@ -60,19 +71,21 @@ 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. -### Notes on Vulkan drivers -Before reporting an issue, please check the [Wiki](https://github.com/doitsujin/dxvk/wiki/Driver-support) page on the current driver status and make sure you run a recent enough driver version for your hardware. - ### Online multi-player games Manipulation of Direct3D libraries in multi-player games may be considered cheating and can get your account **banned**. This may also apply to single-player games with an embedded or dedicated multiplayer portion. **Use at your own risk.** +### Logs +When used with Wine, DXVK will print log messages to `stderr`. Additionally, standalone log files can optionally be generated by setting the `DXVK_LOG_PATH` variable, where log files in the given directory will be called `app_d3d11.log`, `app_dxgi.log` etc., where `app` is the name of the game executable. + +On Windows, log files will be created in the game's working directory by default, which is usually next to the game executable. + ### HUD The `DXVK_HUD` environment variable controls a HUD which can display the framerate and some stat counters. It accepts a comma-separated list of the following options: - `devinfo`: Displays the name of the GPU and the driver version. @@ -81,6 +94,7 @@ The `DXVK_HUD` environment variable controls a HUD which can display the framera - `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. - `gpuload`: Shows estimated GPU load. May be inaccurate. - `version`: Shows DXVK version. @@ -89,6 +103,7 @@ The `DXVK_HUD` environment variable controls a HUD which can display the framera - `compiler`: Shows shader compiler activity - `samplers`: Shows the current number of sampler pairs used *[D3D9 Only]* - `scale=x`: Scales the HUD by a factor of `x` (e.g. `1.5`) +- `opacity=y`: Adjusts the HUD opacity by a factor of `y` (e.g. `0.5`, `1.0` being fully opaque). Additionally, `DXVK_HUD=1` has the same effect as `DXVK_HUD=devinfo,fps`, and `DXVK_HUD=full` enables all available HUD elements. @@ -101,20 +116,34 @@ Some applications do not provide a method to select a different GPU. In that cas **Note:** If the device filter is configured incorrectly, it may filter out all devices and applications will be unable to create a D3D device. +### Graphics Pipeline Library +On drivers which support `VK_EXT_graphics_pipeline_library` Vulkan shaders will be compiled at the time the game loads its D3D shaders, rather than at draw time. This reduces or eliminates shader compile stutter in many games when compared to the previous system. + +In games that load their shaders during loading screens or in the menu, this can lead to prolonged periods of very high CPU utilization, especially on weaker CPUs. For affected games it is recommended to wait for shader compilation to finish before starting the game to avoid stutter and low performance. Shader compiler activity can be monitored with `DXVK_HUD=compiler`. + +This feature largely replaces the state cache. + +**Note:** Games which only load their D3D shaders at draw time (e.g. most Unreal Engine games) will still exhibit some stutter, although it should still be less severe than without this feature. + ### State cache DXVK caches pipeline state by default, so that shaders can be recompiled ahead of time on subsequent runs of an application, even if the driver's own shader cache got invalidated in the meantime. This cache is enabled by default, and generally reduces stuttering. The following environment variables can be used to control the cache: -- `DXVK_STATE_CACHE=0` Disables the state 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` + ### 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_PERF_EVENTS=1` Enables use of the VK_EXT_debug_utils extension for translating performance event markers. +- `DXVK_CONFIG="dxgi.hideAmdGpu = True; dxgi.syncInterval = 0"` Can be used to set config variables through the environment instead of a configuration file using the same syntax. `;` is used as a seperator. ## Troubleshooting DXVK requires threading support from your mingw-w64 build environment. If you diff --git a/RELEASE b/RELEASE index 4dae2985..8bbe6cf7 100644 --- a/RELEASE +++ b/RELEASE @@ -1 +1 @@ -1.10.1 +2.2 diff --git a/VP_DXVK_requirements.json b/VP_DXVK_requirements.json new file mode 100644 index 00000000..d837465b --- /dev/null +++ b/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" + } + ] +} diff --git a/dxvk.conf b/dxvk.conf index e7a0614a..198188f6 100644 --- a/dxvk.conf +++ b/dxvk.conf @@ -1,3 +1,15 @@ +# Expose the HDR10 ColorSpace (DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020) +# to the application by default. +# This shows to the game that the global Windows 'HDR Mode' is enabled. +# Many (broken) games will need this to be set to consider exposing HDR output +# as determine it based on the DXGIOutput's current ColorSpace instead of +# using CheckColorSpaceSupport. +# This defaults to the value of the DXVK_HDR environment variable. +# +# Supported values: True, False + +# dxgi.enableHDR = True + # Create the VkSurface on the first call to IDXGISwapChain::Present, # rather than when creating the swap chain. Some games that start # rendering with a different graphics API may require this option, @@ -19,9 +31,10 @@ # d3d9.maxFrameLatency = 0 -# Enables a frame rate limiter, unless the game is already -# limited to the same refresh rate by vertical synchronization. -# +# 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 : Any non-negative integer # dxgi.maxFrameRate = 0 @@ -48,14 +61,31 @@ # d3d9.customDeviceDesc = "" -# Report Nvidia GPUs as AMD GPUs by default. This is enabled by default -# to work around issues with NVAPI, but may cause issues in some games. +# Report Nvidia GPUs as AMD GPUs. Unless NVAPI support is explicitly +# enabled through proton, this is done by default in order to work +# around crashes or low performance with Nvidia-speciic code paths +# in games, especially Unreal Engine. # -# Supported values: True, False +# Supported values: Auto, True, False -# dxgi.nvapiHack = True +# dxgi.hideNvidiaGpu = Auto +# Report 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 @@ -109,17 +139,7 @@ # # Supported values: Auto, True, False -# dxgi.tearFree = Auto -# d3d9.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. -# -# Supported values: True, False - -# d3d11.constantBufferRangeCheck = False +# dxvk.tearFree = Auto # Assume single-use mode for command lists created on deferred contexts. @@ -135,9 +155,9 @@ # 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 @@ -178,6 +198,26 @@ # 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 # potential Z-fighting issues at a small performance cost. # @@ -187,6 +227,16 @@ # d3d9.invariantPosition = True +# Forces per-sample rate shading when MSAA is enabled, rather than per-pixel +# shading. May improve visual clarity at a significant performance cost, but +# may also introduce visual issues in some games. +# +# Supported values: True, False + +# d3d11.forceSampleRateShading = False +# d3d9.forceSampleRateShading = False + + # Forces the sample count of all textures to 1, and performs # the needed fixups in resolve operations and shaders. # @@ -234,10 +284,22 @@ # 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 + + # 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 @@ -258,18 +320,43 @@ # dxvk.useRawSsbo = Auto -# Controls Nvidia HVV behaviour. +# Changes memory chunk size. # -# Disables the host-visible, device-local heap on Nvidia drivers. This -# is used to avoid NVIDIA driver bug 3114283 on affected drivers, as -# well as in specific games on newer drivers.being enabled on all -# affected drivers. +# Can be used to override the maximum memory chunk size. # # Supported values: -# - Auto: Don't change the default -# - True, False: Always enable / disable +# - 0 to use the defaults +# - any positive integer to limit the chunk size, in MiB -# dxvk.shrinkNvidiaHvvHeap = Auto +# dxvk.maxChunkSize = 0 + + +# 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: 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.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 # Sets enabled HUD elements @@ -294,17 +381,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 @@ -405,16 +481,6 @@ # d3d9.longMad = False -# Alpha Test Wiggle Room -# -# Workaround for games using alpha test == 1.0, etc due to wonky interpolation or -# misc. imprecision on some vendors -# -# Supported values: -# - True/False - -# d3d9.alphaTestWiggleRoom = False - # Device Local Constant Buffers # # Enables using device local, host accessible memory for constant buffers in D3D9. @@ -426,15 +492,6 @@ # d3d9.deviceLocalConstantBuffers = False -# No Explicit Front Buffer -# -# Disables the front buffer -# -# Supported values: -# - True/False - -# d3d9.noExplicitFrontBuffer = False - # Support DF formats # # Support the vendor extension DF floating point depth formats @@ -444,10 +501,19 @@ # 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 horrible game made by complete morons. +# The Sims 2 is a very broken game. # # Supported values: # - True/False @@ -466,7 +532,7 @@ # Disable A8 as a Render Target # # Disable support for A8 format render targets -# Once again, The Sims 2 is a horrible game made by complete morons. +# Once again, The Sims 2 is a very broken game. # # Supported values: # - True/False @@ -506,26 +572,6 @@ # d3d9.forceAspectRatio = "" -# Allow Do Not Wait -# -# Allow the do not wait lock flag to be used -# Useful if some apps use this incorrectly. -# -# Supported values: -# - True/False - -# d3d9.allowDoNotWait = True - -# Allow Discard -# -# Allow the discard lock flag to be used -# Useful if some apps use this incorrectly. -# -# Supported values: -# - True/False - -# d3d9.allowDiscard = True - # Enumerate by Displays # # Whether we should enumerate D3D9 adapters by display (windows behaviour) @@ -537,23 +583,43 @@ # d3d9.enumerateByDisplays = True -# APITrace Mode +# Cached Dynamic Buffers # -# Makes all host visible buffers cached and coherent -# Improves performance when apitracing, but also can impact -# some dumb games. +# Allocates dynamic resources in D3DPOOL_DEFAULT in +# cached system memory rather than uncached memory or host-visible +# VRAM, in order to allow fast readback from the CPU. This is only +# useful for buggy applications, and may reduce GPU-bound performance. # # Supported values: # - True/False -# d3d9.apitraceMode = False +# d3d9.cachedDynamicBuffers = False + +# Seamless Cubes +# +# 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_PERF_EVENTS=1 environment variable. +# 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 diff --git a/include/native/directx b/include/native/directx new file mode 160000 index 00000000..9df86f23 --- /dev/null +++ b/include/native/directx @@ -0,0 +1 @@ +Subproject commit 9df86f2341616ef1888ae59919feaa6d4fad693d diff --git a/include/native/windows/oaidl.h b/include/native/windows/oaidl.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/oaidl.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/objbase.h b/include/native/windows/objbase.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/objbase.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/ocidl.h b/include/native/windows/ocidl.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/ocidl.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/ole2.h b/include/native/windows/ole2.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/ole2.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/poppack.h b/include/native/windows/poppack.h new file mode 100644 index 00000000..163af228 --- /dev/null +++ b/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 diff --git a/include/native/windows/pshpack4.h b/include/native/windows/pshpack4.h new file mode 100644 index 00000000..59fdbbc5 --- /dev/null +++ b/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 diff --git a/include/native/windows/rpc.h b/include/native/windows/rpc.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/rpc.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/rpcndr.h b/include/native/windows/rpcndr.h new file mode 100644 index 00000000..549fe36f --- /dev/null +++ b/include/native/windows/rpcndr.h @@ -0,0 +1,3 @@ +#pragma once + +// Don't care. \ No newline at end of file diff --git a/include/native/windows/unknwn.h b/include/native/windows/unknwn.h new file mode 100644 index 00000000..71216db9 --- /dev/null +++ b/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 + 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(*pp); return reinterpret_cast(pp); }(ppType) diff --git a/include/native/windows/windows.h b/include/native/windows/windows.h new file mode 100644 index 00000000..5ffa7b21 --- /dev/null +++ b/include/native/windows/windows.h @@ -0,0 +1,4 @@ +#pragma once + +#include "windows_base.h" +#include "unknwn.h" \ No newline at end of file diff --git a/include/native/windows/windows_base.h b/include/native/windows/windows_base.h new file mode 100644 index 00000000..0f6e0c39 --- /dev/null +++ b/include/native/windows/windows_base.h @@ -0,0 +1,386 @@ +#pragma once + +#ifdef __cplusplus +#include +#include +#else +#include +#include +#include +#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 uint64_t ULONGLONG; + +typedef intptr_t LONG_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 +constexpr GUID __uuidof_helper(); + +#define __uuidof(T) __uuidof_helper() +#define __uuidof_var(T) __uuidof_helper() + +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() { return GUID{a,b,c,{d,e,f,g,h,i,j,k}}; } } \ + extern "C++" { template <> constexpr GUID __uuidof_helper() { return __uuidof_helper(); } } \ + extern "C++" { template <> constexpr GUID __uuidof_helper() { return __uuidof_helper(); } } \ + extern "C++" { template <> constexpr GUID __uuidof_helper() { return __uuidof_helper(); } } \ + extern "C++" { template <> constexpr GUID __uuidof_helper() { return __uuidof_helper(); } } + +#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 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 +#define DECLARE_INTERFACE(x) \ + typedef interface x { \ + const struct x##Vtbl *lpVtbl; \ + } x; \ + typedef const struct x##Vtbl x##Vtbl; \ + const struct x##Vtbl +#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 */ diff --git a/include/native/wsi/native_glfw.h b/include/native/wsi/native_glfw.h new file mode 100644 index 00000000..e4946e02 --- /dev/null +++ b/include/native/wsi/native_glfw.h @@ -0,0 +1,25 @@ +#include + +#include + +namespace dxvk::wsi { + + inline GLFWwindow* fromHwnd(HWND hWindow) { + return reinterpret_cast(hWindow); + } + + inline HWND toHwnd(GLFWwindow* pWindow) { + return reinterpret_cast(pWindow); + } + + // Offset so null HMONITORs go to -1 + inline int32_t fromHmonitor(HMONITOR hMonitor) { + return static_cast(reinterpret_cast(hMonitor)) - 1; + } + + // Offset so -1 display id goes to 0 == NULL + inline HMONITOR toHmonitor(int32_t displayId) { + return reinterpret_cast(static_cast(displayId + 1)); + } + +} \ No newline at end of file diff --git a/include/native/wsi/native_sdl2.h b/include/native/wsi/native_sdl2.h new file mode 100644 index 00000000..b197d952 --- /dev/null +++ b/include/native/wsi/native_sdl2.h @@ -0,0 +1,25 @@ +#include + +#include + +namespace dxvk::wsi { + + inline SDL_Window* fromHwnd(HWND hWindow) { + return reinterpret_cast(hWindow); + } + + inline HWND toHwnd(SDL_Window* pWindow) { + return reinterpret_cast(pWindow); + } + + // Offset so null HMONITORs go to -1 + inline int32_t fromHmonitor(HMONITOR hMonitor) { + return static_cast(reinterpret_cast(hMonitor)) - 1; + } + + // Offset so -1 display id goes to 0 == NULL + inline HMONITOR toHmonitor(int32_t displayId) { + return reinterpret_cast(static_cast(displayId + 1)); + } + +} \ No newline at end of file diff --git a/include/native/wsi/native_wsi.h b/include/native/wsi/native_wsi.h new file mode 100644 index 00000000..cfb64f12 --- /dev/null +++ b/include/native/wsi/native_wsi.h @@ -0,0 +1,11 @@ +#pragma once + +#ifdef DXVK_WSI_WIN32 +#error You shouldnt be using this code path. +#elif DXVK_WSI_SDL2 +#include "wsi/native_sdl2.h" +#elif DXVK_WSI_GLFW +#include "wsi/native_glfw.h" +#else +#error Unknown wsi! +#endif \ No newline at end of file diff --git a/include/spirv b/include/spirv new file mode 160000 index 00000000..0bcc6249 --- /dev/null +++ b/include/spirv @@ -0,0 +1 @@ +Subproject commit 0bcc624926a25a2a273d07877fd25a6ff5ba1cfb diff --git a/include/spirv/GLSL.std.450.h b/include/spirv/GLSL.std.450.h deleted file mode 100644 index 54cc00e9..00000000 --- a/include/spirv/GLSL.std.450.h +++ /dev/null @@ -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 diff --git a/include/spirv/GLSL.std.450.hpp b/include/spirv/GLSL.std.450.hpp deleted file mode 100644 index 18643668..00000000 --- a/include/spirv/GLSL.std.450.hpp +++ /dev/null @@ -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 \ No newline at end of file diff --git a/include/spirv/spirv.hpp b/include/spirv/spirv.hpp deleted file mode 100644 index 50cc20da..00000000 --- a/include/spirv/spirv.hpp +++ /dev/null @@ -1,1934 +0,0 @@ -// Copyright (c) 2014-2019 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. - -// This header is automatically generated by the same tool that creates -// the Binary Section of the SPIR-V specification. - -// Enumeration tokens for SPIR-V, in various styles: -// C, C++, C++11, JSON, Lua, Python, C#, D -// -// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL -// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL -// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL -// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL -// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] -// - C# will use enum classes in the Specification class located in the "Spv" namespace, -// e.g.: Spv.Specification.SourceLanguage.GLSL -// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL -// -// Some tokens act like mask values, which can be OR'd together, -// while others are mutually exclusive. The mask-like ones have -// "Mask" in their name, and a parallel enum that has the shift -// amount (1 << x) for each corresponding enumerant. - -#ifndef spirv_HPP -#define spirv_HPP - -namespace spv { - -typedef unsigned int Id; - -#define SPV_VERSION 0x10400 -#define SPV_REVISION 1 - -static const unsigned int MagicNumber = 0x07230203; -static const unsigned int Version = 0x00010400; -static const unsigned int Revision = 1; -static const unsigned int OpCodeMask = 0xffff; -static const unsigned int WordCountShift = 16; - -enum SourceLanguage { - SourceLanguageUnknown = 0, - SourceLanguageESSL = 1, - SourceLanguageGLSL = 2, - SourceLanguageOpenCL_C = 3, - SourceLanguageOpenCL_CPP = 4, - SourceLanguageHLSL = 5, - SourceLanguageMax = 0x7fffffff, -}; - -enum ExecutionModel { - ExecutionModelVertex = 0, - ExecutionModelTessellationControl = 1, - ExecutionModelTessellationEvaluation = 2, - ExecutionModelGeometry = 3, - ExecutionModelFragment = 4, - ExecutionModelGLCompute = 5, - ExecutionModelKernel = 6, - ExecutionModelTaskNV = 5267, - ExecutionModelMeshNV = 5268, - ExecutionModelRayGenerationNV = 5313, - ExecutionModelIntersectionNV = 5314, - ExecutionModelAnyHitNV = 5315, - ExecutionModelClosestHitNV = 5316, - ExecutionModelMissNV = 5317, - ExecutionModelCallableNV = 5318, - ExecutionModelMax = 0x7fffffff, -}; - -enum AddressingModel { - AddressingModelLogical = 0, - AddressingModelPhysical32 = 1, - AddressingModelPhysical64 = 2, - AddressingModelPhysicalStorageBuffer64EXT = 5348, - AddressingModelMax = 0x7fffffff, -}; - -enum MemoryModel { - MemoryModelSimple = 0, - MemoryModelGLSL450 = 1, - MemoryModelOpenCL = 2, - MemoryModelVulkanKHR = 3, - MemoryModelMax = 0x7fffffff, -}; - -enum ExecutionMode { - ExecutionModeInvocations = 0, - ExecutionModeSpacingEqual = 1, - ExecutionModeSpacingFractionalEven = 2, - ExecutionModeSpacingFractionalOdd = 3, - ExecutionModeVertexOrderCw = 4, - ExecutionModeVertexOrderCcw = 5, - ExecutionModePixelCenterInteger = 6, - ExecutionModeOriginUpperLeft = 7, - ExecutionModeOriginLowerLeft = 8, - ExecutionModeEarlyFragmentTests = 9, - ExecutionModePointMode = 10, - ExecutionModeXfb = 11, - ExecutionModeDepthReplacing = 12, - ExecutionModeDepthGreater = 14, - ExecutionModeDepthLess = 15, - ExecutionModeDepthUnchanged = 16, - ExecutionModeLocalSize = 17, - ExecutionModeLocalSizeHint = 18, - ExecutionModeInputPoints = 19, - ExecutionModeInputLines = 20, - ExecutionModeInputLinesAdjacency = 21, - ExecutionModeTriangles = 22, - ExecutionModeInputTrianglesAdjacency = 23, - ExecutionModeQuads = 24, - ExecutionModeIsolines = 25, - ExecutionModeOutputVertices = 26, - ExecutionModeOutputPoints = 27, - ExecutionModeOutputLineStrip = 28, - ExecutionModeOutputTriangleStrip = 29, - ExecutionModeVecTypeHint = 30, - ExecutionModeContractionOff = 31, - ExecutionModeInitializer = 33, - ExecutionModeFinalizer = 34, - ExecutionModeSubgroupSize = 35, - ExecutionModeSubgroupsPerWorkgroup = 36, - ExecutionModeSubgroupsPerWorkgroupId = 37, - ExecutionModeLocalSizeId = 38, - ExecutionModeLocalSizeHintId = 39, - ExecutionModePostDepthCoverage = 4446, - ExecutionModeDenormPreserve = 4459, - ExecutionModeDenormFlushToZero = 4460, - ExecutionModeSignedZeroInfNanPreserve = 4461, - ExecutionModeRoundingModeRTE = 4462, - ExecutionModeRoundingModeRTZ = 4463, - ExecutionModeStencilRefReplacingEXT = 5027, - ExecutionModeOutputLinesNV = 5269, - ExecutionModeOutputPrimitivesNV = 5270, - ExecutionModeDerivativeGroupQuadsNV = 5289, - ExecutionModeDerivativeGroupLinearNV = 5290, - ExecutionModeOutputTrianglesNV = 5298, - ExecutionModePixelInterlockOrderedEXT = 5366, - ExecutionModePixelInterlockUnorderedEXT = 5367, - ExecutionModeSampleInterlockOrderedEXT = 5368, - ExecutionModeSampleInterlockUnorderedEXT = 5369, - ExecutionModeShadingRateInterlockOrderedEXT = 5370, - ExecutionModeShadingRateInterlockUnorderedEXT = 5371, - ExecutionModeMax = 0x7fffffff, -}; - -enum StorageClass { - StorageClassUniformConstant = 0, - StorageClassInput = 1, - StorageClassUniform = 2, - StorageClassOutput = 3, - StorageClassWorkgroup = 4, - StorageClassCrossWorkgroup = 5, - StorageClassPrivate = 6, - StorageClassFunction = 7, - StorageClassGeneric = 8, - StorageClassPushConstant = 9, - StorageClassAtomicCounter = 10, - StorageClassImage = 11, - StorageClassStorageBuffer = 12, - StorageClassCallableDataNV = 5328, - StorageClassIncomingCallableDataNV = 5329, - StorageClassRayPayloadNV = 5338, - StorageClassHitAttributeNV = 5339, - StorageClassIncomingRayPayloadNV = 5342, - StorageClassShaderRecordBufferNV = 5343, - StorageClassPhysicalStorageBufferEXT = 5349, - StorageClassMax = 0x7fffffff, -}; - -enum Dim { - Dim1D = 0, - Dim2D = 1, - Dim3D = 2, - DimCube = 3, - DimRect = 4, - DimBuffer = 5, - DimSubpassData = 6, - DimMax = 0x7fffffff, -}; - -enum SamplerAddressingMode { - SamplerAddressingModeNone = 0, - SamplerAddressingModeClampToEdge = 1, - SamplerAddressingModeClamp = 2, - SamplerAddressingModeRepeat = 3, - SamplerAddressingModeRepeatMirrored = 4, - SamplerAddressingModeMax = 0x7fffffff, -}; - -enum SamplerFilterMode { - SamplerFilterModeNearest = 0, - SamplerFilterModeLinear = 1, - SamplerFilterModeMax = 0x7fffffff, -}; - -enum ImageFormat { - ImageFormatUnknown = 0, - ImageFormatRgba32f = 1, - ImageFormatRgba16f = 2, - ImageFormatR32f = 3, - ImageFormatRgba8 = 4, - ImageFormatRgba8Snorm = 5, - ImageFormatRg32f = 6, - ImageFormatRg16f = 7, - ImageFormatR11fG11fB10f = 8, - ImageFormatR16f = 9, - ImageFormatRgba16 = 10, - ImageFormatRgb10A2 = 11, - ImageFormatRg16 = 12, - ImageFormatRg8 = 13, - ImageFormatR16 = 14, - ImageFormatR8 = 15, - ImageFormatRgba16Snorm = 16, - ImageFormatRg16Snorm = 17, - ImageFormatRg8Snorm = 18, - ImageFormatR16Snorm = 19, - ImageFormatR8Snorm = 20, - ImageFormatRgba32i = 21, - ImageFormatRgba16i = 22, - ImageFormatRgba8i = 23, - ImageFormatR32i = 24, - ImageFormatRg32i = 25, - ImageFormatRg16i = 26, - ImageFormatRg8i = 27, - ImageFormatR16i = 28, - ImageFormatR8i = 29, - ImageFormatRgba32ui = 30, - ImageFormatRgba16ui = 31, - ImageFormatRgba8ui = 32, - ImageFormatR32ui = 33, - ImageFormatRgb10a2ui = 34, - ImageFormatRg32ui = 35, - ImageFormatRg16ui = 36, - ImageFormatRg8ui = 37, - ImageFormatR16ui = 38, - ImageFormatR8ui = 39, - ImageFormatMax = 0x7fffffff, -}; - -enum ImageChannelOrder { - ImageChannelOrderR = 0, - ImageChannelOrderA = 1, - ImageChannelOrderRG = 2, - ImageChannelOrderRA = 3, - ImageChannelOrderRGB = 4, - ImageChannelOrderRGBA = 5, - ImageChannelOrderBGRA = 6, - ImageChannelOrderARGB = 7, - ImageChannelOrderIntensity = 8, - ImageChannelOrderLuminance = 9, - ImageChannelOrderRx = 10, - ImageChannelOrderRGx = 11, - ImageChannelOrderRGBx = 12, - ImageChannelOrderDepth = 13, - ImageChannelOrderDepthStencil = 14, - ImageChannelOrdersRGB = 15, - ImageChannelOrdersRGBx = 16, - ImageChannelOrdersRGBA = 17, - ImageChannelOrdersBGRA = 18, - ImageChannelOrderABGR = 19, - ImageChannelOrderMax = 0x7fffffff, -}; - -enum ImageChannelDataType { - ImageChannelDataTypeSnormInt8 = 0, - ImageChannelDataTypeSnormInt16 = 1, - ImageChannelDataTypeUnormInt8 = 2, - ImageChannelDataTypeUnormInt16 = 3, - ImageChannelDataTypeUnormShort565 = 4, - ImageChannelDataTypeUnormShort555 = 5, - ImageChannelDataTypeUnormInt101010 = 6, - ImageChannelDataTypeSignedInt8 = 7, - ImageChannelDataTypeSignedInt16 = 8, - ImageChannelDataTypeSignedInt32 = 9, - ImageChannelDataTypeUnsignedInt8 = 10, - ImageChannelDataTypeUnsignedInt16 = 11, - ImageChannelDataTypeUnsignedInt32 = 12, - ImageChannelDataTypeHalfFloat = 13, - ImageChannelDataTypeFloat = 14, - ImageChannelDataTypeUnormInt24 = 15, - ImageChannelDataTypeUnormInt101010_2 = 16, - ImageChannelDataTypeMax = 0x7fffffff, -}; - -enum ImageOperandsShift { - ImageOperandsBiasShift = 0, - ImageOperandsLodShift = 1, - ImageOperandsGradShift = 2, - ImageOperandsConstOffsetShift = 3, - ImageOperandsOffsetShift = 4, - ImageOperandsConstOffsetsShift = 5, - ImageOperandsSampleShift = 6, - ImageOperandsMinLodShift = 7, - ImageOperandsMakeTexelAvailableKHRShift = 8, - ImageOperandsMakeTexelVisibleKHRShift = 9, - ImageOperandsNonPrivateTexelKHRShift = 10, - ImageOperandsVolatileTexelKHRShift = 11, - ImageOperandsSignExtendShift = 12, - ImageOperandsZeroExtendShift = 13, - ImageOperandsMax = 0x7fffffff, -}; - -enum ImageOperandsMask { - ImageOperandsMaskNone = 0, - ImageOperandsBiasMask = 0x00000001, - ImageOperandsLodMask = 0x00000002, - ImageOperandsGradMask = 0x00000004, - ImageOperandsConstOffsetMask = 0x00000008, - ImageOperandsOffsetMask = 0x00000010, - ImageOperandsConstOffsetsMask = 0x00000020, - ImageOperandsSampleMask = 0x00000040, - ImageOperandsMinLodMask = 0x00000080, - ImageOperandsMakeTexelAvailableKHRMask = 0x00000100, - ImageOperandsMakeTexelVisibleKHRMask = 0x00000200, - ImageOperandsNonPrivateTexelKHRMask = 0x00000400, - ImageOperandsVolatileTexelKHRMask = 0x00000800, - ImageOperandsSignExtendMask = 0x00001000, - ImageOperandsZeroExtendMask = 0x00002000, -}; - -enum FPFastMathModeShift { - FPFastMathModeNotNaNShift = 0, - FPFastMathModeNotInfShift = 1, - FPFastMathModeNSZShift = 2, - FPFastMathModeAllowRecipShift = 3, - FPFastMathModeFastShift = 4, - FPFastMathModeMax = 0x7fffffff, -}; - -enum FPFastMathModeMask { - FPFastMathModeMaskNone = 0, - FPFastMathModeNotNaNMask = 0x00000001, - FPFastMathModeNotInfMask = 0x00000002, - FPFastMathModeNSZMask = 0x00000004, - FPFastMathModeAllowRecipMask = 0x00000008, - FPFastMathModeFastMask = 0x00000010, -}; - -enum FPRoundingMode { - FPRoundingModeRTE = 0, - FPRoundingModeRTZ = 1, - FPRoundingModeRTP = 2, - FPRoundingModeRTN = 3, - FPRoundingModeMax = 0x7fffffff, -}; - -enum LinkageType { - LinkageTypeExport = 0, - LinkageTypeImport = 1, - LinkageTypeMax = 0x7fffffff, -}; - -enum AccessQualifier { - AccessQualifierReadOnly = 0, - AccessQualifierWriteOnly = 1, - AccessQualifierReadWrite = 2, - AccessQualifierMax = 0x7fffffff, -}; - -enum FunctionParameterAttribute { - FunctionParameterAttributeZext = 0, - FunctionParameterAttributeSext = 1, - FunctionParameterAttributeByVal = 2, - FunctionParameterAttributeSret = 3, - FunctionParameterAttributeNoAlias = 4, - FunctionParameterAttributeNoCapture = 5, - FunctionParameterAttributeNoWrite = 6, - FunctionParameterAttributeNoReadWrite = 7, - FunctionParameterAttributeMax = 0x7fffffff, -}; - -enum Decoration { - DecorationRelaxedPrecision = 0, - DecorationSpecId = 1, - DecorationBlock = 2, - DecorationBufferBlock = 3, - DecorationRowMajor = 4, - DecorationColMajor = 5, - DecorationArrayStride = 6, - DecorationMatrixStride = 7, - DecorationGLSLShared = 8, - DecorationGLSLPacked = 9, - DecorationCPacked = 10, - DecorationBuiltIn = 11, - DecorationNoPerspective = 13, - DecorationFlat = 14, - DecorationPatch = 15, - DecorationCentroid = 16, - DecorationSample = 17, - DecorationInvariant = 18, - DecorationRestrict = 19, - DecorationAliased = 20, - DecorationVolatile = 21, - DecorationConstant = 22, - DecorationCoherent = 23, - DecorationNonWritable = 24, - DecorationNonReadable = 25, - DecorationUniform = 26, - DecorationUniformId = 27, - DecorationSaturatedConversion = 28, - DecorationStream = 29, - DecorationLocation = 30, - DecorationComponent = 31, - DecorationIndex = 32, - DecorationBinding = 33, - DecorationDescriptorSet = 34, - DecorationOffset = 35, - DecorationXfbBuffer = 36, - DecorationXfbStride = 37, - DecorationFuncParamAttr = 38, - DecorationFPRoundingMode = 39, - DecorationFPFastMathMode = 40, - DecorationLinkageAttributes = 41, - DecorationNoContraction = 42, - DecorationInputAttachmentIndex = 43, - DecorationAlignment = 44, - DecorationMaxByteOffset = 45, - DecorationAlignmentId = 46, - DecorationMaxByteOffsetId = 47, - DecorationNoSignedWrap = 4469, - DecorationNoUnsignedWrap = 4470, - DecorationExplicitInterpAMD = 4999, - DecorationOverrideCoverageNV = 5248, - DecorationPassthroughNV = 5250, - DecorationViewportRelativeNV = 5252, - DecorationSecondaryViewportRelativeNV = 5256, - DecorationPerPrimitiveNV = 5271, - DecorationPerViewNV = 5272, - DecorationPerTaskNV = 5273, - DecorationPerVertexNV = 5285, - DecorationNonUniformEXT = 5300, - DecorationRestrictPointerEXT = 5355, - DecorationAliasedPointerEXT = 5356, - DecorationCounterBuffer = 5634, - DecorationHlslCounterBufferGOOGLE = 5634, - DecorationHlslSemanticGOOGLE = 5635, - DecorationUserSemantic = 5635, - DecorationUserTypeGOOGLE = 5636, - DecorationMax = 0x7fffffff, -}; - -enum BuiltIn { - BuiltInPosition = 0, - BuiltInPointSize = 1, - BuiltInClipDistance = 3, - BuiltInCullDistance = 4, - BuiltInVertexId = 5, - BuiltInInstanceId = 6, - BuiltInPrimitiveId = 7, - BuiltInInvocationId = 8, - BuiltInLayer = 9, - BuiltInViewportIndex = 10, - BuiltInTessLevelOuter = 11, - BuiltInTessLevelInner = 12, - BuiltInTessCoord = 13, - BuiltInPatchVertices = 14, - BuiltInFragCoord = 15, - BuiltInPointCoord = 16, - BuiltInFrontFacing = 17, - BuiltInSampleId = 18, - BuiltInSamplePosition = 19, - BuiltInSampleMask = 20, - BuiltInFragDepth = 22, - BuiltInHelperInvocation = 23, - BuiltInNumWorkgroups = 24, - BuiltInWorkgroupSize = 25, - BuiltInWorkgroupId = 26, - BuiltInLocalInvocationId = 27, - BuiltInGlobalInvocationId = 28, - BuiltInLocalInvocationIndex = 29, - BuiltInWorkDim = 30, - BuiltInGlobalSize = 31, - BuiltInEnqueuedWorkgroupSize = 32, - BuiltInGlobalOffset = 33, - BuiltInGlobalLinearId = 34, - BuiltInSubgroupSize = 36, - BuiltInSubgroupMaxSize = 37, - BuiltInNumSubgroups = 38, - BuiltInNumEnqueuedSubgroups = 39, - BuiltInSubgroupId = 40, - BuiltInSubgroupLocalInvocationId = 41, - BuiltInVertexIndex = 42, - BuiltInInstanceIndex = 43, - BuiltInSubgroupEqMask = 4416, - BuiltInSubgroupEqMaskKHR = 4416, - BuiltInSubgroupGeMask = 4417, - BuiltInSubgroupGeMaskKHR = 4417, - BuiltInSubgroupGtMask = 4418, - BuiltInSubgroupGtMaskKHR = 4418, - BuiltInSubgroupLeMask = 4419, - BuiltInSubgroupLeMaskKHR = 4419, - BuiltInSubgroupLtMask = 4420, - BuiltInSubgroupLtMaskKHR = 4420, - BuiltInBaseVertex = 4424, - BuiltInBaseInstance = 4425, - BuiltInDrawIndex = 4426, - BuiltInDeviceIndex = 4438, - BuiltInViewIndex = 4440, - BuiltInBaryCoordNoPerspAMD = 4992, - BuiltInBaryCoordNoPerspCentroidAMD = 4993, - BuiltInBaryCoordNoPerspSampleAMD = 4994, - BuiltInBaryCoordSmoothAMD = 4995, - BuiltInBaryCoordSmoothCentroidAMD = 4996, - BuiltInBaryCoordSmoothSampleAMD = 4997, - BuiltInBaryCoordPullModelAMD = 4998, - BuiltInFragStencilRefEXT = 5014, - BuiltInViewportMaskNV = 5253, - BuiltInSecondaryPositionNV = 5257, - BuiltInSecondaryViewportMaskNV = 5258, - BuiltInPositionPerViewNV = 5261, - BuiltInViewportMaskPerViewNV = 5262, - BuiltInFullyCoveredEXT = 5264, - BuiltInTaskCountNV = 5274, - BuiltInPrimitiveCountNV = 5275, - BuiltInPrimitiveIndicesNV = 5276, - BuiltInClipDistancePerViewNV = 5277, - BuiltInCullDistancePerViewNV = 5278, - BuiltInLayerPerViewNV = 5279, - BuiltInMeshViewCountNV = 5280, - BuiltInMeshViewIndicesNV = 5281, - BuiltInBaryCoordNV = 5286, - BuiltInBaryCoordNoPerspNV = 5287, - BuiltInFragSizeEXT = 5292, - BuiltInFragmentSizeNV = 5292, - BuiltInFragInvocationCountEXT = 5293, - BuiltInInvocationsPerPixelNV = 5293, - BuiltInLaunchIdNV = 5319, - BuiltInLaunchSizeNV = 5320, - BuiltInWorldRayOriginNV = 5321, - BuiltInWorldRayDirectionNV = 5322, - BuiltInObjectRayOriginNV = 5323, - BuiltInObjectRayDirectionNV = 5324, - BuiltInRayTminNV = 5325, - BuiltInRayTmaxNV = 5326, - BuiltInInstanceCustomIndexNV = 5327, - BuiltInObjectToWorldNV = 5330, - BuiltInWorldToObjectNV = 5331, - BuiltInHitTNV = 5332, - BuiltInHitKindNV = 5333, - BuiltInIncomingRayFlagsNV = 5351, - BuiltInWarpsPerSMNV = 5374, - BuiltInSMCountNV = 5375, - BuiltInWarpIDNV = 5376, - BuiltInSMIDNV = 5377, - BuiltInMax = 0x7fffffff, -}; - -enum SelectionControlShift { - SelectionControlFlattenShift = 0, - SelectionControlDontFlattenShift = 1, - SelectionControlMax = 0x7fffffff, -}; - -enum SelectionControlMask { - SelectionControlMaskNone = 0, - SelectionControlFlattenMask = 0x00000001, - SelectionControlDontFlattenMask = 0x00000002, -}; - -enum LoopControlShift { - LoopControlUnrollShift = 0, - LoopControlDontUnrollShift = 1, - LoopControlDependencyInfiniteShift = 2, - LoopControlDependencyLengthShift = 3, - LoopControlMinIterationsShift = 4, - LoopControlMaxIterationsShift = 5, - LoopControlIterationMultipleShift = 6, - LoopControlPeelCountShift = 7, - LoopControlPartialCountShift = 8, - LoopControlMax = 0x7fffffff, -}; - -enum LoopControlMask { - LoopControlMaskNone = 0, - LoopControlUnrollMask = 0x00000001, - LoopControlDontUnrollMask = 0x00000002, - LoopControlDependencyInfiniteMask = 0x00000004, - LoopControlDependencyLengthMask = 0x00000008, - LoopControlMinIterationsMask = 0x00000010, - LoopControlMaxIterationsMask = 0x00000020, - LoopControlIterationMultipleMask = 0x00000040, - LoopControlPeelCountMask = 0x00000080, - LoopControlPartialCountMask = 0x00000100, -}; - -enum FunctionControlShift { - FunctionControlInlineShift = 0, - FunctionControlDontInlineShift = 1, - FunctionControlPureShift = 2, - FunctionControlConstShift = 3, - FunctionControlMax = 0x7fffffff, -}; - -enum FunctionControlMask { - FunctionControlMaskNone = 0, - FunctionControlInlineMask = 0x00000001, - FunctionControlDontInlineMask = 0x00000002, - FunctionControlPureMask = 0x00000004, - FunctionControlConstMask = 0x00000008, -}; - -enum MemorySemanticsShift { - MemorySemanticsAcquireShift = 1, - MemorySemanticsReleaseShift = 2, - MemorySemanticsAcquireReleaseShift = 3, - MemorySemanticsSequentiallyConsistentShift = 4, - MemorySemanticsUniformMemoryShift = 6, - MemorySemanticsSubgroupMemoryShift = 7, - MemorySemanticsWorkgroupMemoryShift = 8, - MemorySemanticsCrossWorkgroupMemoryShift = 9, - MemorySemanticsAtomicCounterMemoryShift = 10, - MemorySemanticsImageMemoryShift = 11, - MemorySemanticsOutputMemoryKHRShift = 12, - MemorySemanticsMakeAvailableKHRShift = 13, - MemorySemanticsMakeVisibleKHRShift = 14, - MemorySemanticsVolatileShift = 15, - MemorySemanticsMax = 0x7fffffff, -}; - -enum MemorySemanticsMask { - MemorySemanticsMaskNone = 0, - MemorySemanticsAcquireMask = 0x00000002, - MemorySemanticsReleaseMask = 0x00000004, - MemorySemanticsAcquireReleaseMask = 0x00000008, - MemorySemanticsSequentiallyConsistentMask = 0x00000010, - MemorySemanticsUniformMemoryMask = 0x00000040, - MemorySemanticsSubgroupMemoryMask = 0x00000080, - MemorySemanticsWorkgroupMemoryMask = 0x00000100, - MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, - MemorySemanticsAtomicCounterMemoryMask = 0x00000400, - MemorySemanticsImageMemoryMask = 0x00000800, - MemorySemanticsOutputMemoryKHRMask = 0x00001000, - MemorySemanticsMakeAvailableKHRMask = 0x00002000, - MemorySemanticsMakeVisibleKHRMask = 0x00004000, - MemorySemanticsVolatileMask = 0x00008000, -}; - -enum MemoryAccessShift { - MemoryAccessVolatileShift = 0, - MemoryAccessAlignedShift = 1, - MemoryAccessNontemporalShift = 2, - MemoryAccessMakePointerAvailableKHRShift = 3, - MemoryAccessMakePointerVisibleKHRShift = 4, - MemoryAccessNonPrivatePointerKHRShift = 5, - MemoryAccessMax = 0x7fffffff, -}; - -enum MemoryAccessMask { - MemoryAccessMaskNone = 0, - MemoryAccessVolatileMask = 0x00000001, - MemoryAccessAlignedMask = 0x00000002, - MemoryAccessNontemporalMask = 0x00000004, - MemoryAccessMakePointerAvailableKHRMask = 0x00000008, - MemoryAccessMakePointerVisibleKHRMask = 0x00000010, - MemoryAccessNonPrivatePointerKHRMask = 0x00000020, -}; - -enum Scope { - ScopeCrossDevice = 0, - ScopeDevice = 1, - ScopeWorkgroup = 2, - ScopeSubgroup = 3, - ScopeInvocation = 4, - ScopeQueueFamilyKHR = 5, - ScopeMax = 0x7fffffff, -}; - -enum GroupOperation { - GroupOperationReduce = 0, - GroupOperationInclusiveScan = 1, - GroupOperationExclusiveScan = 2, - GroupOperationClusteredReduce = 3, - GroupOperationPartitionedReduceNV = 6, - GroupOperationPartitionedInclusiveScanNV = 7, - GroupOperationPartitionedExclusiveScanNV = 8, - GroupOperationMax = 0x7fffffff, -}; - -enum KernelEnqueueFlags { - KernelEnqueueFlagsNoWait = 0, - KernelEnqueueFlagsWaitKernel = 1, - KernelEnqueueFlagsWaitWorkGroup = 2, - KernelEnqueueFlagsMax = 0x7fffffff, -}; - -enum KernelProfilingInfoShift { - KernelProfilingInfoCmdExecTimeShift = 0, - KernelProfilingInfoMax = 0x7fffffff, -}; - -enum KernelProfilingInfoMask { - KernelProfilingInfoMaskNone = 0, - KernelProfilingInfoCmdExecTimeMask = 0x00000001, -}; - -enum Capability { - CapabilityMatrix = 0, - CapabilityShader = 1, - CapabilityGeometry = 2, - CapabilityTessellation = 3, - CapabilityAddresses = 4, - CapabilityLinkage = 5, - CapabilityKernel = 6, - CapabilityVector16 = 7, - CapabilityFloat16Buffer = 8, - CapabilityFloat16 = 9, - CapabilityFloat64 = 10, - CapabilityInt64 = 11, - CapabilityInt64Atomics = 12, - CapabilityImageBasic = 13, - CapabilityImageReadWrite = 14, - CapabilityImageMipmap = 15, - CapabilityPipes = 17, - CapabilityGroups = 18, - CapabilityDeviceEnqueue = 19, - CapabilityLiteralSampler = 20, - CapabilityAtomicStorage = 21, - CapabilityInt16 = 22, - CapabilityTessellationPointSize = 23, - CapabilityGeometryPointSize = 24, - CapabilityImageGatherExtended = 25, - CapabilityStorageImageMultisample = 27, - CapabilityUniformBufferArrayDynamicIndexing = 28, - CapabilitySampledImageArrayDynamicIndexing = 29, - CapabilityStorageBufferArrayDynamicIndexing = 30, - CapabilityStorageImageArrayDynamicIndexing = 31, - CapabilityClipDistance = 32, - CapabilityCullDistance = 33, - CapabilityImageCubeArray = 34, - CapabilitySampleRateShading = 35, - CapabilityImageRect = 36, - CapabilitySampledRect = 37, - CapabilityGenericPointer = 38, - CapabilityInt8 = 39, - CapabilityInputAttachment = 40, - CapabilitySparseResidency = 41, - CapabilityMinLod = 42, - CapabilitySampled1D = 43, - CapabilityImage1D = 44, - CapabilitySampledCubeArray = 45, - CapabilitySampledBuffer = 46, - CapabilityImageBuffer = 47, - CapabilityImageMSArray = 48, - CapabilityStorageImageExtendedFormats = 49, - CapabilityImageQuery = 50, - CapabilityDerivativeControl = 51, - CapabilityInterpolationFunction = 52, - CapabilityTransformFeedback = 53, - CapabilityGeometryStreams = 54, - CapabilityStorageImageReadWithoutFormat = 55, - CapabilityStorageImageWriteWithoutFormat = 56, - CapabilityMultiViewport = 57, - CapabilitySubgroupDispatch = 58, - CapabilityNamedBarrier = 59, - CapabilityPipeStorage = 60, - CapabilityGroupNonUniform = 61, - CapabilityGroupNonUniformVote = 62, - CapabilityGroupNonUniformArithmetic = 63, - CapabilityGroupNonUniformBallot = 64, - CapabilityGroupNonUniformShuffle = 65, - CapabilityGroupNonUniformShuffleRelative = 66, - CapabilityGroupNonUniformClustered = 67, - CapabilityGroupNonUniformQuad = 68, - CapabilitySubgroupBallotKHR = 4423, - CapabilityDrawParameters = 4427, - CapabilitySubgroupVoteKHR = 4431, - CapabilityStorageBuffer16BitAccess = 4433, - CapabilityStorageUniformBufferBlock16 = 4433, - CapabilityStorageUniform16 = 4434, - CapabilityUniformAndStorageBuffer16BitAccess = 4434, - CapabilityStoragePushConstant16 = 4435, - CapabilityStorageInputOutput16 = 4436, - CapabilityDeviceGroup = 4437, - CapabilityMultiView = 4439, - CapabilityVariablePointersStorageBuffer = 4441, - CapabilityVariablePointers = 4442, - CapabilityAtomicStorageOps = 4445, - CapabilitySampleMaskPostDepthCoverage = 4447, - CapabilityStorageBuffer8BitAccess = 4448, - CapabilityUniformAndStorageBuffer8BitAccess = 4449, - CapabilityStoragePushConstant8 = 4450, - CapabilityDenormPreserve = 4464, - CapabilityDenormFlushToZero = 4465, - CapabilitySignedZeroInfNanPreserve = 4466, - CapabilityRoundingModeRTE = 4467, - CapabilityRoundingModeRTZ = 4468, - CapabilityFloat16ImageAMD = 5008, - CapabilityImageGatherBiasLodAMD = 5009, - CapabilityFragmentMaskAMD = 5010, - CapabilityStencilExportEXT = 5013, - CapabilityImageReadWriteLodAMD = 5015, - CapabilitySampleMaskOverrideCoverageNV = 5249, - CapabilityGeometryShaderPassthroughNV = 5251, - CapabilityShaderViewportIndexLayerEXT = 5254, - CapabilityShaderViewportIndexLayerNV = 5254, - CapabilityShaderViewportMaskNV = 5255, - CapabilityShaderStereoViewNV = 5259, - CapabilityPerViewAttributesNV = 5260, - CapabilityFragmentFullyCoveredEXT = 5265, - CapabilityMeshShadingNV = 5266, - CapabilityImageFootprintNV = 5282, - CapabilityFragmentBarycentricNV = 5284, - CapabilityComputeDerivativeGroupQuadsNV = 5288, - CapabilityFragmentDensityEXT = 5291, - CapabilityShadingRateNV = 5291, - CapabilityGroupNonUniformPartitionedNV = 5297, - CapabilityShaderNonUniformEXT = 5301, - CapabilityRuntimeDescriptorArrayEXT = 5302, - CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, - CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, - CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, - CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, - CapabilitySampledImageArrayNonUniformIndexingEXT = 5307, - CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, - CapabilityStorageImageArrayNonUniformIndexingEXT = 5309, - CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, - CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, - CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, - CapabilityRayTracingNV = 5340, - CapabilityVulkanMemoryModelKHR = 5345, - CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, - CapabilityPhysicalStorageBufferAddressesEXT = 5347, - CapabilityComputeDerivativeGroupLinearNV = 5350, - CapabilityCooperativeMatrixNV = 5357, - CapabilityFragmentShaderSampleInterlockEXT = 5363, - CapabilityFragmentShaderShadingRateInterlockEXT = 5372, - CapabilityShaderSMBuiltinsNV = 5373, - CapabilityFragmentShaderPixelInterlockEXT = 5378, - CapabilityDemoteToHelperInvocationEXT = 5379, - CapabilitySubgroupShuffleINTEL = 5568, - CapabilitySubgroupBufferBlockIOINTEL = 5569, - CapabilitySubgroupImageBlockIOINTEL = 5570, - CapabilitySubgroupImageMediaBlockIOINTEL = 5579, - CapabilityIntegerFunctions2INTEL = 5584, - CapabilitySubgroupAvcMotionEstimationINTEL = 5696, - CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, - CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, - CapabilityMax = 0x7fffffff, -}; - -enum Op { - OpNop = 0, - OpUndef = 1, - OpSourceContinued = 2, - OpSource = 3, - OpSourceExtension = 4, - OpName = 5, - OpMemberName = 6, - OpString = 7, - OpLine = 8, - OpExtension = 10, - OpExtInstImport = 11, - OpExtInst = 12, - OpMemoryModel = 14, - OpEntryPoint = 15, - OpExecutionMode = 16, - OpCapability = 17, - OpTypeVoid = 19, - OpTypeBool = 20, - OpTypeInt = 21, - OpTypeFloat = 22, - OpTypeVector = 23, - OpTypeMatrix = 24, - OpTypeImage = 25, - OpTypeSampler = 26, - OpTypeSampledImage = 27, - OpTypeArray = 28, - OpTypeRuntimeArray = 29, - OpTypeStruct = 30, - OpTypeOpaque = 31, - OpTypePointer = 32, - OpTypeFunction = 33, - OpTypeEvent = 34, - OpTypeDeviceEvent = 35, - OpTypeReserveId = 36, - OpTypeQueue = 37, - OpTypePipe = 38, - OpTypeForwardPointer = 39, - OpConstantTrue = 41, - OpConstantFalse = 42, - OpConstant = 43, - OpConstantComposite = 44, - OpConstantSampler = 45, - OpConstantNull = 46, - OpSpecConstantTrue = 48, - OpSpecConstantFalse = 49, - OpSpecConstant = 50, - OpSpecConstantComposite = 51, - OpSpecConstantOp = 52, - OpFunction = 54, - OpFunctionParameter = 55, - OpFunctionEnd = 56, - OpFunctionCall = 57, - OpVariable = 59, - OpImageTexelPointer = 60, - OpLoad = 61, - OpStore = 62, - OpCopyMemory = 63, - OpCopyMemorySized = 64, - OpAccessChain = 65, - OpInBoundsAccessChain = 66, - OpPtrAccessChain = 67, - OpArrayLength = 68, - OpGenericPtrMemSemantics = 69, - OpInBoundsPtrAccessChain = 70, - OpDecorate = 71, - OpMemberDecorate = 72, - OpDecorationGroup = 73, - OpGroupDecorate = 74, - OpGroupMemberDecorate = 75, - OpVectorExtractDynamic = 77, - OpVectorInsertDynamic = 78, - OpVectorShuffle = 79, - OpCompositeConstruct = 80, - OpCompositeExtract = 81, - OpCompositeInsert = 82, - OpCopyObject = 83, - OpTranspose = 84, - OpSampledImage = 86, - OpImageSampleImplicitLod = 87, - OpImageSampleExplicitLod = 88, - OpImageSampleDrefImplicitLod = 89, - OpImageSampleDrefExplicitLod = 90, - OpImageSampleProjImplicitLod = 91, - OpImageSampleProjExplicitLod = 92, - OpImageSampleProjDrefImplicitLod = 93, - OpImageSampleProjDrefExplicitLod = 94, - OpImageFetch = 95, - OpImageGather = 96, - OpImageDrefGather = 97, - OpImageRead = 98, - OpImageWrite = 99, - OpImage = 100, - OpImageQueryFormat = 101, - OpImageQueryOrder = 102, - OpImageQuerySizeLod = 103, - OpImageQuerySize = 104, - OpImageQueryLod = 105, - OpImageQueryLevels = 106, - OpImageQuerySamples = 107, - OpConvertFToU = 109, - OpConvertFToS = 110, - OpConvertSToF = 111, - OpConvertUToF = 112, - OpUConvert = 113, - OpSConvert = 114, - OpFConvert = 115, - OpQuantizeToF16 = 116, - OpConvertPtrToU = 117, - OpSatConvertSToU = 118, - OpSatConvertUToS = 119, - OpConvertUToPtr = 120, - OpPtrCastToGeneric = 121, - OpGenericCastToPtr = 122, - OpGenericCastToPtrExplicit = 123, - OpBitcast = 124, - OpSNegate = 126, - OpFNegate = 127, - OpIAdd = 128, - OpFAdd = 129, - OpISub = 130, - OpFSub = 131, - OpIMul = 132, - OpFMul = 133, - OpUDiv = 134, - OpSDiv = 135, - OpFDiv = 136, - OpUMod = 137, - OpSRem = 138, - OpSMod = 139, - OpFRem = 140, - OpFMod = 141, - OpVectorTimesScalar = 142, - OpMatrixTimesScalar = 143, - OpVectorTimesMatrix = 144, - OpMatrixTimesVector = 145, - OpMatrixTimesMatrix = 146, - OpOuterProduct = 147, - OpDot = 148, - OpIAddCarry = 149, - OpISubBorrow = 150, - OpUMulExtended = 151, - OpSMulExtended = 152, - OpAny = 154, - OpAll = 155, - OpIsNan = 156, - OpIsInf = 157, - OpIsFinite = 158, - OpIsNormal = 159, - OpSignBitSet = 160, - OpLessOrGreater = 161, - OpOrdered = 162, - OpUnordered = 163, - OpLogicalEqual = 164, - OpLogicalNotEqual = 165, - OpLogicalOr = 166, - OpLogicalAnd = 167, - OpLogicalNot = 168, - OpSelect = 169, - OpIEqual = 170, - OpINotEqual = 171, - OpUGreaterThan = 172, - OpSGreaterThan = 173, - OpUGreaterThanEqual = 174, - OpSGreaterThanEqual = 175, - OpULessThan = 176, - OpSLessThan = 177, - OpULessThanEqual = 178, - OpSLessThanEqual = 179, - OpFOrdEqual = 180, - OpFUnordEqual = 181, - OpFOrdNotEqual = 182, - OpFUnordNotEqual = 183, - OpFOrdLessThan = 184, - OpFUnordLessThan = 185, - OpFOrdGreaterThan = 186, - OpFUnordGreaterThan = 187, - OpFOrdLessThanEqual = 188, - OpFUnordLessThanEqual = 189, - OpFOrdGreaterThanEqual = 190, - OpFUnordGreaterThanEqual = 191, - OpShiftRightLogical = 194, - OpShiftRightArithmetic = 195, - OpShiftLeftLogical = 196, - OpBitwiseOr = 197, - OpBitwiseXor = 198, - OpBitwiseAnd = 199, - OpNot = 200, - OpBitFieldInsert = 201, - OpBitFieldSExtract = 202, - OpBitFieldUExtract = 203, - OpBitReverse = 204, - OpBitCount = 205, - OpDPdx = 207, - OpDPdy = 208, - OpFwidth = 209, - OpDPdxFine = 210, - OpDPdyFine = 211, - OpFwidthFine = 212, - OpDPdxCoarse = 213, - OpDPdyCoarse = 214, - OpFwidthCoarse = 215, - OpEmitVertex = 218, - OpEndPrimitive = 219, - OpEmitStreamVertex = 220, - OpEndStreamPrimitive = 221, - OpControlBarrier = 224, - OpMemoryBarrier = 225, - OpAtomicLoad = 227, - OpAtomicStore = 228, - OpAtomicExchange = 229, - OpAtomicCompareExchange = 230, - OpAtomicCompareExchangeWeak = 231, - OpAtomicIIncrement = 232, - OpAtomicIDecrement = 233, - OpAtomicIAdd = 234, - OpAtomicISub = 235, - OpAtomicSMin = 236, - OpAtomicUMin = 237, - OpAtomicSMax = 238, - OpAtomicUMax = 239, - OpAtomicAnd = 240, - OpAtomicOr = 241, - OpAtomicXor = 242, - OpPhi = 245, - OpLoopMerge = 246, - OpSelectionMerge = 247, - OpLabel = 248, - OpBranch = 249, - OpBranchConditional = 250, - OpSwitch = 251, - OpKill = 252, - OpReturn = 253, - OpReturnValue = 254, - OpUnreachable = 255, - OpLifetimeStart = 256, - OpLifetimeStop = 257, - OpGroupAsyncCopy = 259, - OpGroupWaitEvents = 260, - OpGroupAll = 261, - OpGroupAny = 262, - OpGroupBroadcast = 263, - OpGroupIAdd = 264, - OpGroupFAdd = 265, - OpGroupFMin = 266, - OpGroupUMin = 267, - OpGroupSMin = 268, - OpGroupFMax = 269, - OpGroupUMax = 270, - OpGroupSMax = 271, - OpReadPipe = 274, - OpWritePipe = 275, - OpReservedReadPipe = 276, - OpReservedWritePipe = 277, - OpReserveReadPipePackets = 278, - OpReserveWritePipePackets = 279, - OpCommitReadPipe = 280, - OpCommitWritePipe = 281, - OpIsValidReserveId = 282, - OpGetNumPipePackets = 283, - OpGetMaxPipePackets = 284, - OpGroupReserveReadPipePackets = 285, - OpGroupReserveWritePipePackets = 286, - OpGroupCommitReadPipe = 287, - OpGroupCommitWritePipe = 288, - OpEnqueueMarker = 291, - OpEnqueueKernel = 292, - OpGetKernelNDrangeSubGroupCount = 293, - OpGetKernelNDrangeMaxSubGroupSize = 294, - OpGetKernelWorkGroupSize = 295, - OpGetKernelPreferredWorkGroupSizeMultiple = 296, - OpRetainEvent = 297, - OpReleaseEvent = 298, - OpCreateUserEvent = 299, - OpIsValidEvent = 300, - OpSetUserEventStatus = 301, - OpCaptureEventProfilingInfo = 302, - OpGetDefaultQueue = 303, - OpBuildNDRange = 304, - OpImageSparseSampleImplicitLod = 305, - OpImageSparseSampleExplicitLod = 306, - OpImageSparseSampleDrefImplicitLod = 307, - OpImageSparseSampleDrefExplicitLod = 308, - OpImageSparseSampleProjImplicitLod = 309, - OpImageSparseSampleProjExplicitLod = 310, - OpImageSparseSampleProjDrefImplicitLod = 311, - OpImageSparseSampleProjDrefExplicitLod = 312, - OpImageSparseFetch = 313, - OpImageSparseGather = 314, - OpImageSparseDrefGather = 315, - OpImageSparseTexelsResident = 316, - OpNoLine = 317, - OpAtomicFlagTestAndSet = 318, - OpAtomicFlagClear = 319, - OpImageSparseRead = 320, - OpSizeOf = 321, - OpTypePipeStorage = 322, - OpConstantPipeStorage = 323, - OpCreatePipeFromPipeStorage = 324, - OpGetKernelLocalSizeForSubgroupCount = 325, - OpGetKernelMaxNumSubgroups = 326, - OpTypeNamedBarrier = 327, - OpNamedBarrierInitialize = 328, - OpMemoryNamedBarrier = 329, - OpModuleProcessed = 330, - OpExecutionModeId = 331, - OpDecorateId = 332, - OpGroupNonUniformElect = 333, - OpGroupNonUniformAll = 334, - OpGroupNonUniformAny = 335, - OpGroupNonUniformAllEqual = 336, - OpGroupNonUniformBroadcast = 337, - OpGroupNonUniformBroadcastFirst = 338, - OpGroupNonUniformBallot = 339, - OpGroupNonUniformInverseBallot = 340, - OpGroupNonUniformBallotBitExtract = 341, - OpGroupNonUniformBallotBitCount = 342, - OpGroupNonUniformBallotFindLSB = 343, - OpGroupNonUniformBallotFindMSB = 344, - OpGroupNonUniformShuffle = 345, - OpGroupNonUniformShuffleXor = 346, - OpGroupNonUniformShuffleUp = 347, - OpGroupNonUniformShuffleDown = 348, - OpGroupNonUniformIAdd = 349, - OpGroupNonUniformFAdd = 350, - OpGroupNonUniformIMul = 351, - OpGroupNonUniformFMul = 352, - OpGroupNonUniformSMin = 353, - OpGroupNonUniformUMin = 354, - OpGroupNonUniformFMin = 355, - OpGroupNonUniformSMax = 356, - OpGroupNonUniformUMax = 357, - OpGroupNonUniformFMax = 358, - OpGroupNonUniformBitwiseAnd = 359, - OpGroupNonUniformBitwiseOr = 360, - OpGroupNonUniformBitwiseXor = 361, - OpGroupNonUniformLogicalAnd = 362, - OpGroupNonUniformLogicalOr = 363, - OpGroupNonUniformLogicalXor = 364, - OpGroupNonUniformQuadBroadcast = 365, - OpGroupNonUniformQuadSwap = 366, - OpCopyLogical = 400, - OpPtrEqual = 401, - OpPtrNotEqual = 402, - OpPtrDiff = 403, - OpSubgroupBallotKHR = 4421, - OpSubgroupFirstInvocationKHR = 4422, - OpSubgroupAllKHR = 4428, - OpSubgroupAnyKHR = 4429, - OpSubgroupAllEqualKHR = 4430, - OpSubgroupReadInvocationKHR = 4432, - OpGroupIAddNonUniformAMD = 5000, - OpGroupFAddNonUniformAMD = 5001, - OpGroupFMinNonUniformAMD = 5002, - OpGroupUMinNonUniformAMD = 5003, - OpGroupSMinNonUniformAMD = 5004, - OpGroupFMaxNonUniformAMD = 5005, - OpGroupUMaxNonUniformAMD = 5006, - OpGroupSMaxNonUniformAMD = 5007, - OpFragmentMaskFetchAMD = 5011, - OpFragmentFetchAMD = 5012, - OpImageSampleFootprintNV = 5283, - OpGroupNonUniformPartitionNV = 5296, - OpWritePackedPrimitiveIndices4x8NV = 5299, - OpReportIntersectionNV = 5334, - OpIgnoreIntersectionNV = 5335, - OpTerminateRayNV = 5336, - OpTraceNV = 5337, - OpTypeAccelerationStructureNV = 5341, - OpExecuteCallableNV = 5344, - OpTypeCooperativeMatrixNV = 5358, - OpCooperativeMatrixLoadNV = 5359, - OpCooperativeMatrixStoreNV = 5360, - OpCooperativeMatrixMulAddNV = 5361, - OpCooperativeMatrixLengthNV = 5362, - OpBeginInvocationInterlockEXT = 5364, - OpEndInvocationInterlockEXT = 5365, - OpDemoteToHelperInvocationEXT = 5380, - OpIsHelperInvocationEXT = 5381, - OpSubgroupShuffleINTEL = 5571, - OpSubgroupShuffleDownINTEL = 5572, - OpSubgroupShuffleUpINTEL = 5573, - OpSubgroupShuffleXorINTEL = 5574, - OpSubgroupBlockReadINTEL = 5575, - OpSubgroupBlockWriteINTEL = 5576, - OpSubgroupImageBlockReadINTEL = 5577, - OpSubgroupImageBlockWriteINTEL = 5578, - OpSubgroupImageMediaBlockReadINTEL = 5580, - OpSubgroupImageMediaBlockWriteINTEL = 5581, - OpUCountLeadingZerosINTEL = 5585, - OpUCountTrailingZerosINTEL = 5586, - OpAbsISubINTEL = 5587, - OpAbsUSubINTEL = 5588, - OpIAddSatINTEL = 5589, - OpUAddSatINTEL = 5590, - OpIAverageINTEL = 5591, - OpUAverageINTEL = 5592, - OpIAverageRoundedINTEL = 5593, - OpUAverageRoundedINTEL = 5594, - OpISubSatINTEL = 5595, - OpUSubSatINTEL = 5596, - OpIMul32x16INTEL = 5597, - OpUMul32x16INTEL = 5598, - OpDecorateString = 5632, - OpDecorateStringGOOGLE = 5632, - OpMemberDecorateString = 5633, - OpMemberDecorateStringGOOGLE = 5633, - OpVmeImageINTEL = 5699, - OpTypeVmeImageINTEL = 5700, - OpTypeAvcImePayloadINTEL = 5701, - OpTypeAvcRefPayloadINTEL = 5702, - OpTypeAvcSicPayloadINTEL = 5703, - OpTypeAvcMcePayloadINTEL = 5704, - OpTypeAvcMceResultINTEL = 5705, - OpTypeAvcImeResultINTEL = 5706, - OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, - OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, - OpTypeAvcImeSingleReferenceStreaminINTEL = 5709, - OpTypeAvcImeDualReferenceStreaminINTEL = 5710, - OpTypeAvcRefResultINTEL = 5711, - OpTypeAvcSicResultINTEL = 5712, - OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, - OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, - OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, - OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, - OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, - OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, - OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, - OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, - OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, - OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, - OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, - OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, - OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, - OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, - OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, - OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, - OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, - OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, - OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, - OpSubgroupAvcMceConvertToImePayloadINTEL = 5732, - OpSubgroupAvcMceConvertToImeResultINTEL = 5733, - OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, - OpSubgroupAvcMceConvertToRefResultINTEL = 5735, - OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, - OpSubgroupAvcMceConvertToSicResultINTEL = 5737, - OpSubgroupAvcMceGetMotionVectorsINTEL = 5738, - OpSubgroupAvcMceGetInterDistortionsINTEL = 5739, - OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, - OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, - OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, - OpSubgroupAvcMceGetInterDirectionsINTEL = 5743, - OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, - OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, - OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, - OpSubgroupAvcImeInitializeINTEL = 5747, - OpSubgroupAvcImeSetSingleReferenceINTEL = 5748, - OpSubgroupAvcImeSetDualReferenceINTEL = 5749, - OpSubgroupAvcImeRefWindowSizeINTEL = 5750, - OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, - OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, - OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, - OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, - OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, - OpSubgroupAvcImeSetWeightedSadINTEL = 5756, - OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, - OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, - OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, - OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, - OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, - OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, - OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, - OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, - OpSubgroupAvcImeConvertToMceResultINTEL = 5765, - OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, - OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, - OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, - OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, - OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, - OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, - OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, - OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, - OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, - OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, - OpSubgroupAvcImeGetBorderReachedINTEL = 5776, - OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, - OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, - OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, - OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, - OpSubgroupAvcFmeInitializeINTEL = 5781, - OpSubgroupAvcBmeInitializeINTEL = 5782, - OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, - OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, - OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, - OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, - OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, - OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, - OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, - OpSubgroupAvcRefConvertToMceResultINTEL = 5790, - OpSubgroupAvcSicInitializeINTEL = 5791, - OpSubgroupAvcSicConfigureSkcINTEL = 5792, - OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, - OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, - OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, - OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, - OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, - OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, - OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, - OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, - OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, - OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, - OpSubgroupAvcSicEvaluateIpeINTEL = 5803, - OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, - OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, - OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, - OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, - OpSubgroupAvcSicConvertToMceResultINTEL = 5808, - OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, - OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, - OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, - OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, - OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, - OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, - OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, - OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, - OpMax = 0x7fffffff, -}; - -#ifdef SPV_ENABLE_UTILITY_CODE -inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { - *hasResult = *hasResultType = false; - switch (opcode) { - default: /* unknown opcode */ break; - case OpNop: *hasResult = false; *hasResultType = false; break; - case OpUndef: *hasResult = true; *hasResultType = true; break; - case OpSourceContinued: *hasResult = false; *hasResultType = false; break; - case OpSource: *hasResult = false; *hasResultType = false; break; - case OpSourceExtension: *hasResult = false; *hasResultType = false; break; - case OpName: *hasResult = false; *hasResultType = false; break; - case OpMemberName: *hasResult = false; *hasResultType = false; break; - case OpString: *hasResult = true; *hasResultType = false; break; - case OpLine: *hasResult = false; *hasResultType = false; break; - case OpExtension: *hasResult = false; *hasResultType = false; break; - case OpExtInstImport: *hasResult = true; *hasResultType = false; break; - case OpExtInst: *hasResult = true; *hasResultType = true; break; - case OpMemoryModel: *hasResult = false; *hasResultType = false; break; - case OpEntryPoint: *hasResult = false; *hasResultType = false; break; - case OpExecutionMode: *hasResult = false; *hasResultType = false; break; - case OpCapability: *hasResult = false; *hasResultType = false; break; - case OpTypeVoid: *hasResult = true; *hasResultType = false; break; - case OpTypeBool: *hasResult = true; *hasResultType = false; break; - case OpTypeInt: *hasResult = true; *hasResultType = false; break; - case OpTypeFloat: *hasResult = true; *hasResultType = false; break; - case OpTypeVector: *hasResult = true; *hasResultType = false; break; - case OpTypeMatrix: *hasResult = true; *hasResultType = false; break; - case OpTypeImage: *hasResult = true; *hasResultType = false; break; - case OpTypeSampler: *hasResult = true; *hasResultType = false; break; - case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break; - case OpTypeArray: *hasResult = true; *hasResultType = false; break; - case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; - case OpTypeStruct: *hasResult = true; *hasResultType = false; break; - case OpTypeOpaque: *hasResult = true; *hasResultType = false; break; - case OpTypePointer: *hasResult = true; *hasResultType = false; break; - case OpTypeFunction: *hasResult = true; *hasResultType = false; break; - case OpTypeEvent: *hasResult = true; *hasResultType = false; break; - case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; - case OpTypeReserveId: *hasResult = true; *hasResultType = false; break; - case OpTypeQueue: *hasResult = true; *hasResultType = false; break; - case OpTypePipe: *hasResult = true; *hasResultType = false; break; - case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; - case OpConstantTrue: *hasResult = true; *hasResultType = true; break; - case OpConstantFalse: *hasResult = true; *hasResultType = true; break; - case OpConstant: *hasResult = true; *hasResultType = true; break; - case OpConstantComposite: *hasResult = true; *hasResultType = true; break; - case OpConstantSampler: *hasResult = true; *hasResultType = true; break; - case OpConstantNull: *hasResult = true; *hasResultType = true; break; - case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; - case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; - case OpSpecConstant: *hasResult = true; *hasResultType = true; break; - case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; - case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break; - case OpFunction: *hasResult = true; *hasResultType = true; break; - case OpFunctionParameter: *hasResult = true; *hasResultType = true; break; - case OpFunctionEnd: *hasResult = false; *hasResultType = false; break; - case OpFunctionCall: *hasResult = true; *hasResultType = true; break; - case OpVariable: *hasResult = true; *hasResultType = true; break; - case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break; - case OpLoad: *hasResult = true; *hasResultType = true; break; - case OpStore: *hasResult = false; *hasResultType = false; break; - case OpCopyMemory: *hasResult = false; *hasResultType = false; break; - case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break; - case OpAccessChain: *hasResult = true; *hasResultType = true; break; - case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; - case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break; - case OpArrayLength: *hasResult = true; *hasResultType = true; break; - case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; - case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; - case OpDecorate: *hasResult = false; *hasResultType = false; break; - case OpMemberDecorate: *hasResult = false; *hasResultType = false; break; - case OpDecorationGroup: *hasResult = true; *hasResultType = false; break; - case OpGroupDecorate: *hasResult = false; *hasResultType = false; break; - case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; - case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; - case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; - case OpVectorShuffle: *hasResult = true; *hasResultType = true; break; - case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break; - case OpCompositeExtract: *hasResult = true; *hasResultType = true; break; - case OpCompositeInsert: *hasResult = true; *hasResultType = true; break; - case OpCopyObject: *hasResult = true; *hasResultType = true; break; - case OpTranspose: *hasResult = true; *hasResultType = true; break; - case OpSampledImage: *hasResult = true; *hasResultType = true; break; - case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageFetch: *hasResult = true; *hasResultType = true; break; - case OpImageGather: *hasResult = true; *hasResultType = true; break; - case OpImageDrefGather: *hasResult = true; *hasResultType = true; break; - case OpImageRead: *hasResult = true; *hasResultType = true; break; - case OpImageWrite: *hasResult = false; *hasResultType = false; break; - case OpImage: *hasResult = true; *hasResultType = true; break; - case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break; - case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break; - case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; - case OpImageQuerySize: *hasResult = true; *hasResultType = true; break; - case OpImageQueryLod: *hasResult = true; *hasResultType = true; break; - case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break; - case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break; - case OpConvertFToU: *hasResult = true; *hasResultType = true; break; - case OpConvertFToS: *hasResult = true; *hasResultType = true; break; - case OpConvertSToF: *hasResult = true; *hasResultType = true; break; - case OpConvertUToF: *hasResult = true; *hasResultType = true; break; - case OpUConvert: *hasResult = true; *hasResultType = true; break; - case OpSConvert: *hasResult = true; *hasResultType = true; break; - case OpFConvert: *hasResult = true; *hasResultType = true; break; - case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break; - case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break; - case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break; - case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break; - case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break; - case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; - case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; - case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; - case OpBitcast: *hasResult = true; *hasResultType = true; break; - case OpSNegate: *hasResult = true; *hasResultType = true; break; - case OpFNegate: *hasResult = true; *hasResultType = true; break; - case OpIAdd: *hasResult = true; *hasResultType = true; break; - case OpFAdd: *hasResult = true; *hasResultType = true; break; - case OpISub: *hasResult = true; *hasResultType = true; break; - case OpFSub: *hasResult = true; *hasResultType = true; break; - case OpIMul: *hasResult = true; *hasResultType = true; break; - case OpFMul: *hasResult = true; *hasResultType = true; break; - case OpUDiv: *hasResult = true; *hasResultType = true; break; - case OpSDiv: *hasResult = true; *hasResultType = true; break; - case OpFDiv: *hasResult = true; *hasResultType = true; break; - case OpUMod: *hasResult = true; *hasResultType = true; break; - case OpSRem: *hasResult = true; *hasResultType = true; break; - case OpSMod: *hasResult = true; *hasResultType = true; break; - case OpFRem: *hasResult = true; *hasResultType = true; break; - case OpFMod: *hasResult = true; *hasResultType = true; break; - case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; - case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; - case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; - case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; - case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; - case OpOuterProduct: *hasResult = true; *hasResultType = true; break; - case OpDot: *hasResult = true; *hasResultType = true; break; - case OpIAddCarry: *hasResult = true; *hasResultType = true; break; - case OpISubBorrow: *hasResult = true; *hasResultType = true; break; - case OpUMulExtended: *hasResult = true; *hasResultType = true; break; - case OpSMulExtended: *hasResult = true; *hasResultType = true; break; - case OpAny: *hasResult = true; *hasResultType = true; break; - case OpAll: *hasResult = true; *hasResultType = true; break; - case OpIsNan: *hasResult = true; *hasResultType = true; break; - case OpIsInf: *hasResult = true; *hasResultType = true; break; - case OpIsFinite: *hasResult = true; *hasResultType = true; break; - case OpIsNormal: *hasResult = true; *hasResultType = true; break; - case OpSignBitSet: *hasResult = true; *hasResultType = true; break; - case OpLessOrGreater: *hasResult = true; *hasResultType = true; break; - case OpOrdered: *hasResult = true; *hasResultType = true; break; - case OpUnordered: *hasResult = true; *hasResultType = true; break; - case OpLogicalEqual: *hasResult = true; *hasResultType = true; break; - case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; - case OpLogicalOr: *hasResult = true; *hasResultType = true; break; - case OpLogicalAnd: *hasResult = true; *hasResultType = true; break; - case OpLogicalNot: *hasResult = true; *hasResultType = true; break; - case OpSelect: *hasResult = true; *hasResultType = true; break; - case OpIEqual: *hasResult = true; *hasResultType = true; break; - case OpINotEqual: *hasResult = true; *hasResultType = true; break; - case OpUGreaterThan: *hasResult = true; *hasResultType = true; break; - case OpSGreaterThan: *hasResult = true; *hasResultType = true; break; - case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; - case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; - case OpULessThan: *hasResult = true; *hasResultType = true; break; - case OpSLessThan: *hasResult = true; *hasResultType = true; break; - case OpULessThanEqual: *hasResult = true; *hasResultType = true; break; - case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break; - case OpFOrdEqual: *hasResult = true; *hasResultType = true; break; - case OpFUnordEqual: *hasResult = true; *hasResultType = true; break; - case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; - case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; - case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break; - case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break; - case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; - case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; - case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; - case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; - case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; - case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; - case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break; - case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; - case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; - case OpBitwiseOr: *hasResult = true; *hasResultType = true; break; - case OpBitwiseXor: *hasResult = true; *hasResultType = true; break; - case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break; - case OpNot: *hasResult = true; *hasResultType = true; break; - case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break; - case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; - case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; - case OpBitReverse: *hasResult = true; *hasResultType = true; break; - case OpBitCount: *hasResult = true; *hasResultType = true; break; - case OpDPdx: *hasResult = true; *hasResultType = true; break; - case OpDPdy: *hasResult = true; *hasResultType = true; break; - case OpFwidth: *hasResult = true; *hasResultType = true; break; - case OpDPdxFine: *hasResult = true; *hasResultType = true; break; - case OpDPdyFine: *hasResult = true; *hasResultType = true; break; - case OpFwidthFine: *hasResult = true; *hasResultType = true; break; - case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break; - case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break; - case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break; - case OpEmitVertex: *hasResult = false; *hasResultType = false; break; - case OpEndPrimitive: *hasResult = false; *hasResultType = false; break; - case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; - case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; - case OpControlBarrier: *hasResult = false; *hasResultType = false; break; - case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break; - case OpAtomicLoad: *hasResult = true; *hasResultType = true; break; - case OpAtomicStore: *hasResult = false; *hasResultType = false; break; - case OpAtomicExchange: *hasResult = true; *hasResultType = true; break; - case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; - case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; - case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; - case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; - case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break; - case OpAtomicISub: *hasResult = true; *hasResultType = true; break; - case OpAtomicSMin: *hasResult = true; *hasResultType = true; break; - case OpAtomicUMin: *hasResult = true; *hasResultType = true; break; - case OpAtomicSMax: *hasResult = true; *hasResultType = true; break; - case OpAtomicUMax: *hasResult = true; *hasResultType = true; break; - case OpAtomicAnd: *hasResult = true; *hasResultType = true; break; - case OpAtomicOr: *hasResult = true; *hasResultType = true; break; - case OpAtomicXor: *hasResult = true; *hasResultType = true; break; - case OpPhi: *hasResult = true; *hasResultType = true; break; - case OpLoopMerge: *hasResult = false; *hasResultType = false; break; - case OpSelectionMerge: *hasResult = false; *hasResultType = false; break; - case OpLabel: *hasResult = true; *hasResultType = false; break; - case OpBranch: *hasResult = false; *hasResultType = false; break; - case OpBranchConditional: *hasResult = false; *hasResultType = false; break; - case OpSwitch: *hasResult = false; *hasResultType = false; break; - case OpKill: *hasResult = false; *hasResultType = false; break; - case OpReturn: *hasResult = false; *hasResultType = false; break; - case OpReturnValue: *hasResult = false; *hasResultType = false; break; - case OpUnreachable: *hasResult = false; *hasResultType = false; break; - case OpLifetimeStart: *hasResult = false; *hasResultType = false; break; - case OpLifetimeStop: *hasResult = false; *hasResultType = false; break; - case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; - case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; - case OpGroupAll: *hasResult = true; *hasResultType = true; break; - case OpGroupAny: *hasResult = true; *hasResultType = true; break; - case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break; - case OpGroupIAdd: *hasResult = true; *hasResultType = true; break; - case OpGroupFAdd: *hasResult = true; *hasResultType = true; break; - case OpGroupFMin: *hasResult = true; *hasResultType = true; break; - case OpGroupUMin: *hasResult = true; *hasResultType = true; break; - case OpGroupSMin: *hasResult = true; *hasResultType = true; break; - case OpGroupFMax: *hasResult = true; *hasResultType = true; break; - case OpGroupUMax: *hasResult = true; *hasResultType = true; break; - case OpGroupSMax: *hasResult = true; *hasResultType = true; break; - case OpReadPipe: *hasResult = true; *hasResultType = true; break; - case OpWritePipe: *hasResult = true; *hasResultType = true; break; - case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break; - case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break; - case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; - case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; - case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break; - case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break; - case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break; - case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; - case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; - case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; - case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; - case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; - case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; - case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break; - case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break; - case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; - case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; - case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; - case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; - case OpRetainEvent: *hasResult = false; *hasResultType = false; break; - case OpReleaseEvent: *hasResult = false; *hasResultType = false; break; - case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break; - case OpIsValidEvent: *hasResult = true; *hasResultType = true; break; - case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; - case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; - case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; - case OpBuildNDRange: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; - case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break; - case OpImageSparseGather: *hasResult = true; *hasResultType = true; break; - case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; - case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; - case OpNoLine: *hasResult = false; *hasResultType = false; break; - case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; - case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; - case OpImageSparseRead: *hasResult = true; *hasResultType = true; break; - case OpSizeOf: *hasResult = true; *hasResultType = true; break; - case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break; - case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; - case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; - case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; - case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; - case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; - case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; - case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; - case OpModuleProcessed: *hasResult = false; *hasResultType = false; break; - case OpExecutionModeId: *hasResult = false; *hasResultType = false; break; - case OpDecorateId: *hasResult = false; *hasResultType = false; break; - case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; - case OpCopyLogical: *hasResult = true; *hasResultType = true; break; - case OpPtrEqual: *hasResult = true; *hasResultType = true; break; - case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; - case OpPtrDiff: *hasResult = true; *hasResultType = true; break; - case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; - case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; - case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; - case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; - case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; - case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; - case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; - case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; - case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; - case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; - case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; - case OpTraceNV: *hasResult = false; *hasResultType = false; break; - case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; - case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; - case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; - case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; - case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; - case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; - case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; - case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; - case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; - case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; - case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; - case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; - case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; - case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; - case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; - case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; - case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; - case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; - case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; - case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break; - case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break; - case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; - case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; - case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break; - case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; - case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; - case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; - case OpDecorateString: *hasResult = false; *hasResultType = false; break; - case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break; - case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; - case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; - case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; - case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; - case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; - } -} -#endif /* SPV_ENABLE_UTILITY_CODE */ - -// Overload operator| for mask bit combining - -inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); } -inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); } -inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); } -inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); } -inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); } -inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); } -inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); } -inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); } - -} // end namespace spv - -#endif // #ifndef spirv_HPP - diff --git a/include/vulkan b/include/vulkan new file mode 160000 index 00000000..85c2334e --- /dev/null +++ b/include/vulkan @@ -0,0 +1 @@ +Subproject commit 85c2334e92e215cce34e8e0ed8b2dce4700f4a50 diff --git a/include/vulkan/vk_platform.h b/include/vulkan/vk_platform.h deleted file mode 100644 index 18b913ab..00000000 --- a/include/vulkan/vk_platform.h +++ /dev/null @@ -1,84 +0,0 @@ -// -// File: vk_platform.h -// -/* -** Copyright 2014-2021 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - - -#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 - -#if !defined(VK_NO_STDDEF_H) - #include -#endif // !defined(VK_NO_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 - #endif -#endif // !defined(VK_NO_STDINT_H) - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif diff --git a/include/vulkan/vulkan.h b/include/vulkan/vulkan.h deleted file mode 100644 index 3f7cdba5..00000000 --- a/include/vulkan/vulkan.h +++ /dev/null @@ -1,92 +0,0 @@ -#ifndef VULKAN_H_ -#define VULKAN_H_ 1 - -/* -** Copyright 2015-2021 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -#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 -#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 -#include "vulkan_wayland.h" -#endif - - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#include -#include "vulkan_win32.h" -#endif - - -#ifdef VK_USE_PLATFORM_XCB_KHR -#include -#include "vulkan_xcb.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_KHR -#include -#include "vulkan_xlib.h" -#endif - - -#ifdef VK_USE_PLATFORM_DIRECTFB_EXT -#include -#include "vulkan_directfb.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -#include -#include -#include "vulkan_xlib_xrandr.h" -#endif - - -#ifdef VK_USE_PLATFORM_GGP -#include -#include "vulkan_ggp.h" -#endif - - -#ifdef VK_USE_PLATFORM_SCREEN_QNX -#include -#include "vulkan_screen.h" -#endif - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#include "vulkan_beta.h" -#endif - -#endif // VULKAN_H_ diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h deleted file mode 100644 index a2f4e771..00000000 --- a/include/vulkan/vulkan_core.h +++ /dev/null @@ -1,13540 +0,0 @@ -#ifndef VULKAN_CORE_H_ -#define VULKAN_CORE_H_ 1 - -/* -** Copyright 2015-2021 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -#define VK_VERSION_1_0 1 -#include "vk_platform.h" - -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; - - -#ifndef VK_USE_64_BIT_PTR_DEFINES - #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) - #define VK_USE_64_BIT_PTR_DEFINES 1 - #else - #define VK_USE_64_BIT_PTR_DEFINES 0 - #endif -#endif - - -#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE - #if (VK_USE_64_BIT_PTR_DEFINES==1) - #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) - #define VK_NULL_HANDLE nullptr - #else - #define VK_NULL_HANDLE ((void*)0) - #endif - #else - #define VK_NULL_HANDLE 0ULL - #endif -#endif -#ifndef VK_NULL_HANDLE - #define VK_NULL_HANDLE 0 -#endif - - -#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE - #if (VK_USE_64_BIT_PTR_DEFINES==1) - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; - #else - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; - #endif -#endif - -// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead. -#define VK_MAKE_VERSION(major, minor, patch) \ - ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) - -// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead. -//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0 - -#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ - ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) - -// Vulkan 1.0 version number -#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 - -// Version of this file -#define VK_HEADER_VERSION 197 - -// Complete version of this file -#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION) - -// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. -#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) - -// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. -#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) - -// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead. -#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) - -#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29) -#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU) -#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU) -#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) -typedef uint32_t VkBool32; -typedef uint64_t VkDeviceAddress; -typedef uint64_t VkDeviceSize; -typedef uint32_t VkFlags; -typedef uint32_t VkSampleMask; -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) -VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalDevice) -VK_DEFINE_HANDLE(VkDevice) -VK_DEFINE_HANDLE(VkQueue) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) -VK_DEFINE_HANDLE(VkCommandBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) -#define VK_UUID_SIZE 16U -#define VK_ATTACHMENT_UNUSED (~0U) -#define VK_FALSE 0U -#define VK_LOD_CLAMP_NONE 1000.0F -#define VK_QUEUE_FAMILY_IGNORED (~0U) -#define VK_REMAINING_ARRAY_LAYERS (~0U) -#define VK_REMAINING_MIP_LEVELS (~0U) -#define VK_SUBPASS_EXTERNAL (~0U) -#define VK_TRUE 1U -#define VK_WHOLE_SIZE (~0ULL) -#define VK_MAX_MEMORY_TYPES 32U -#define VK_MAX_MEMORY_HEAPS 16U -#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U -#define VK_MAX_EXTENSION_NAME_SIZE 256U -#define VK_MAX_DESCRIPTION_SIZE 256U - -typedef enum VkResult { - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - VK_ERROR_OUT_OF_HOST_MEMORY = -1, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_DEVICE_LOST = -4, - VK_ERROR_MEMORY_MAP_FAILED = -5, - VK_ERROR_LAYER_NOT_PRESENT = -6, - VK_ERROR_EXTENSION_NOT_PRESENT = -7, - VK_ERROR_FEATURE_NOT_PRESENT = -8, - VK_ERROR_INCOMPATIBLE_DRIVER = -9, - VK_ERROR_TOO_MANY_OBJECTS = -10, - VK_ERROR_FORMAT_NOT_SUPPORTED = -11, - VK_ERROR_FRAGMENTED_POOL = -12, - VK_ERROR_UNKNOWN = -13, - VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, - VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, - VK_ERROR_FRAGMENTATION = -1000161000, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, - VK_ERROR_SURFACE_LOST_KHR = -1000000000, - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, - VK_SUBOPTIMAL_KHR = 1000001003, - VK_ERROR_OUT_OF_DATE_KHR = -1000001004, - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, - VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, - VK_ERROR_INVALID_SHADER_NV = -1000012000, - VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, - VK_ERROR_NOT_PERMITTED_EXT = -1000174001, - VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, - VK_THREAD_IDLE_KHR = 1000268000, - VK_THREAD_DONE_KHR = 1000268001, - VK_OPERATION_DEFERRED_KHR = 1000268002, - VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, - VK_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000, - VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, - VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, - VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED_EXT, - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum VkStructureType { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, - VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, -#endif - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, - VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, - VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, - VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, - VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT = 1000038001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT = 1000039001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT = 1000039006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT = 1000039007, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT = 1000039008, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT = 1000039009, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT = 1000040001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040006, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040007, -#endif - VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = 1000044000, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = 1000044001, - VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = 1000044002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = 1000044003, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = 1000044004, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, - VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, - VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, - VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, - VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, - VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, - VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, - VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, - VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, - VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, - VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, - VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, - VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, - VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, - VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, - VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, - VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, - VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, -#endif - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, - VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, - VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, - VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, - VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, - VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, - VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, - VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT = 1000187001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187004, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187005, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187006, -#endif - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, - VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, - VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, - VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, - VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, - VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, - VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, - VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, - VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, - VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, - VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, - VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, - VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, - VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, - VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000, - VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, - VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, - VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, - VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = 1000280000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = 1000280001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, - VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, - VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, - VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, - VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, - VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000, - VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001, - VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, -#endif - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, - VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = 1000314000, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = 1000314001, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = 1000314002, - VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = 1000314003, - VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = 1000314004, - VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = 1000314005, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = 1000314006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = 1000314007, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = 1000325000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, - VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, - VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, - VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, - VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, - VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, - VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, - VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, - VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, - VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, - VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = 1000360000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, - VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, - VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, - VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, - VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, - VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, - VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, - VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, - VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = 1000388000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = 1000388001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, - VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = 1000413000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = 1000413001, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = 1000413002, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = 1000413003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum VkImageLayout { - VK_IMAGE_LAYOUT_UNDEFINED = 0, - VK_IMAGE_LAYOUT_GENERAL = 1, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, -#endif - VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, - VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, - VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, -#endif - VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = 1000314000, - VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = 1000314001, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum VkObjectType { - VK_OBJECT_TYPE_UNKNOWN = 0, - VK_OBJECT_TYPE_INSTANCE = 1, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, - VK_OBJECT_TYPE_DEVICE = 3, - VK_OBJECT_TYPE_QUEUE = 4, - VK_OBJECT_TYPE_SEMAPHORE = 5, - VK_OBJECT_TYPE_COMMAND_BUFFER = 6, - VK_OBJECT_TYPE_FENCE = 7, - VK_OBJECT_TYPE_DEVICE_MEMORY = 8, - VK_OBJECT_TYPE_BUFFER = 9, - VK_OBJECT_TYPE_IMAGE = 10, - VK_OBJECT_TYPE_EVENT = 11, - VK_OBJECT_TYPE_QUERY_POOL = 12, - VK_OBJECT_TYPE_BUFFER_VIEW = 13, - VK_OBJECT_TYPE_IMAGE_VIEW = 14, - VK_OBJECT_TYPE_SHADER_MODULE = 15, - VK_OBJECT_TYPE_PIPELINE_CACHE = 16, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, - VK_OBJECT_TYPE_RENDER_PASS = 18, - VK_OBJECT_TYPE_PIPELINE = 19, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, - VK_OBJECT_TYPE_SAMPLER = 21, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, - VK_OBJECT_TYPE_FRAMEBUFFER = 24, - VK_OBJECT_TYPE_COMMAND_POOL = 25, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, - VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, - VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, - VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, - VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, - VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, -#endif - VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, - VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, - VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, - VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = 1000295000, - VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkObjectType; - -typedef enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheHeaderVersion; - -typedef enum VkVendorId { - VK_VENDOR_ID_VIV = 0x10001, - VK_VENDOR_ID_VSI = 0x10002, - VK_VENDOR_ID_KAZAN = 0x10003, - VK_VENDOR_ID_CODEPLAY = 0x10004, - VK_VENDOR_ID_MESA = 0x10005, - VK_VENDOR_ID_POCL = 0x10006, - VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF -} VkVendorId; - -typedef enum VkSystemAllocationScope { - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, - VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocationScope; - -typedef enum VkInternalAllocationType { - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, - VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkInternalAllocationType; - -typedef enum VkFormat { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, - VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, - VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, - VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, - VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, - VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, - VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, - VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, - VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, - VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, - VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, - VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, - VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, - VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002, - VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003, - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000, - VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001, - VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, - VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, - VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum VkImageTiling { - VK_IMAGE_TILING_OPTIMAL = 0, - VK_IMAGE_TILING_LINEAR = 1, - VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum VkImageType { - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum VkPhysicalDeviceType { - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, - VK_PHYSICAL_DEVICE_TYPE_CPU = 4, - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum VkQueryType { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_TIMESTAMP = 2, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, -#endif - VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, - VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000, -#endif - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum VkSharingMode { - VK_SHARING_MODE_EXCLUSIVE = 0, - VK_SHARING_MODE_CONCURRENT = 1, - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum VkComponentSwizzle { - VK_COMPONENT_SWIZZLE_IDENTITY = 0, - VK_COMPONENT_SWIZZLE_ZERO = 1, - VK_COMPONENT_SWIZZLE_ONE = 2, - VK_COMPONENT_SWIZZLE_R = 3, - VK_COMPONENT_SWIZZLE_G = 4, - VK_COMPONENT_SWIZZLE_B = 5, - VK_COMPONENT_SWIZZLE_A = 6, - VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkComponentSwizzle; - -typedef enum VkImageViewType { - VK_IMAGE_VIEW_TYPE_1D = 0, - VK_IMAGE_VIEW_TYPE_2D = 1, - VK_IMAGE_VIEW_TYPE_3D = 2, - VK_IMAGE_VIEW_TYPE_CUBE = 3, - VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, - VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF -} VkBlendFactor; - -typedef enum VkBlendOp { - VK_BLEND_OP_ADD = 0, - VK_BLEND_OP_SUBTRACT = 1, - VK_BLEND_OP_REVERSE_SUBTRACT = 2, - VK_BLEND_OP_MIN = 3, - VK_BLEND_OP_MAX = 4, - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, - VK_BLEND_OP_DARKEN_EXT = 1000148015, - VK_BLEND_OP_LIGHTEN_EXT = 1000148016, - VK_BLEND_OP_COLORDODGE_EXT = 1000148017, - VK_BLEND_OP_COLORBURN_EXT = 1000148018, - VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, - VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, - VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, - VK_BLEND_OP_EXCLUSION_EXT = 1000148022, - VK_BLEND_OP_INVERT_EXT = 1000148023, - VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, - VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, - VK_BLEND_OP_LINEARBURN_EXT = 1000148026, - VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, - VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, - VK_BLEND_OP_PINLIGHT_EXT = 1000148029, - VK_BLEND_OP_HARDMIX_EXT = 1000148030, - VK_BLEND_OP_HSL_HUE_EXT = 1000148031, - VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, - VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, - VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, - VK_BLEND_OP_PLUS_EXT = 1000148035, - VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, - VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, - VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, - VK_BLEND_OP_MINUS_EXT = 1000148039, - VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, - VK_BLEND_OP_CONTRAST_EXT = 1000148041, - VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, - VK_BLEND_OP_RED_EXT = 1000148043, - VK_BLEND_OP_GREEN_EXT = 1000148044, - VK_BLEND_OP_BLUE_EXT = 1000148045, - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum VkDynamicState { - VK_DYNAMIC_STATE_VIEWPORT = 0, - VK_DYNAMIC_STATE_SCISSOR = 1, - VK_DYNAMIC_STATE_LINE_WIDTH = 2, - VK_DYNAMIC_STATE_DEPTH_BIAS = 3, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, - VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, - VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, - VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, - VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, - VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, - VK_DYNAMIC_STATE_CULL_MODE_EXT = 1000267000, - VK_DYNAMIC_STATE_FRONT_FACE_EXT = 1000267001, - VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = 1000267002, - VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = 1000267003, - VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = 1000267004, - VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = 1000267005, - VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = 1000267006, - VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = 1000267007, - VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = 1000267008, - VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = 1000267009, - VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = 1000267010, - VK_DYNAMIC_STATE_STENCIL_OP_EXT = 1000267011, - VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, - VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, - VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = 1000377001, - VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = 1000377002, - VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, - VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = 1000377004, - VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, - VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF -} VkDynamicState; - -typedef enum VkFrontFace { - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, - VK_FRONT_FACE_CLOCKWISE = 1, - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum VkVertexInputRate { - VK_VERTEX_INPUT_RATE_VERTEX = 0, - VK_VERTEX_INPUT_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputRate; - -typedef enum VkPrimitiveTopology { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum VkPolygonMode { - VK_POLYGON_MODE_FILL = 0, - VK_POLYGON_MODE_LINE = 1, - VK_POLYGON_MODE_POINT = 2, - VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, - VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF -} VkPolygonMode; - -typedef enum VkStencilOp { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum VkLogicOp { - VK_LOGIC_OP_CLEAR = 0, - VK_LOGIC_OP_AND = 1, - VK_LOGIC_OP_AND_REVERSE = 2, - VK_LOGIC_OP_COPY = 3, - VK_LOGIC_OP_AND_INVERTED = 4, - VK_LOGIC_OP_NO_OP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIVALENT = 9, - VK_LOGIC_OP_INVERT = 10, - VK_LOGIC_OP_OR_REVERSE = 11, - VK_LOGIC_OP_COPY_INVERTED = 12, - VK_LOGIC_OP_OR_INVERTED = 13, - VK_LOGIC_OP_NAND = 14, - VK_LOGIC_OP_SET = 15, - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, - VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, - VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum VkFilter { - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_IMG = 1000015000, - VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG, - VK_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkFilter; - -typedef enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerAddressMode; - -typedef enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerMipmapMode; - -typedef enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = 1000138000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000, - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum VkAttachmentLoadOp { - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum VkAttachmentStoreOp { - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, - VK_ATTACHMENT_STORE_OP_NONE_KHR = 1000301000, - VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE_KHR, - VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE_KHR, - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, - VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, - VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, - VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferLevel; - -typedef enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_UINT8_EXT = 1000265000, - VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum VkSubpassContents { - VK_SUBPASS_CONTENTS_INLINE = 0, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassContents; - -typedef enum VkAccessFlagBits { - VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, - VK_ACCESS_INDEX_READ_BIT = 0x00000002, - VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, - VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, - VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, - VK_ACCESS_SHADER_READ_BIT = 0x00000020, - VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, - VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, - VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, - VK_ACCESS_HOST_READ_BIT = 0x00002000, - VK_ACCESS_HOST_WRITE_BIT = 0x00004000, - VK_ACCESS_MEMORY_READ_BIT = 0x00008000, - VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, - VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, - VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, - VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, - VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, - VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, - VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, - VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, - VK_ACCESS_NONE_KHR = 0, - VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAccessFlagBits; -typedef VkFlags VkAccessFlags; - -typedef enum VkImageAspectFlagBits { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, - VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, - VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, - VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, - VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, - VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, - VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum VkFormatFeatureFlagBits { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, - VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, - VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, -#endif - VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, - VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, - VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, -#endif - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum VkImageCreateFlagBits { - VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, - VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, - VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, - VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, - VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, - VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, - VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, - VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, - VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum VkSampleCountFlagBits { - VK_SAMPLE_COUNT_1_BIT = 0x00000001, - VK_SAMPLE_COUNT_2_BIT = 0x00000002, - VK_SAMPLE_COUNT_4_BIT = 0x00000004, - VK_SAMPLE_COUNT_8_BIT = 0x00000008, - VK_SAMPLE_COUNT_16_BIT = 0x00000010, - VK_SAMPLE_COUNT_32_BIT = 0x00000020, - VK_SAMPLE_COUNT_64_BIT = 0x00000040, - VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSampleCountFlagBits; -typedef VkFlags VkSampleCountFlags; - -typedef enum VkImageUsageFlagBits { - VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, -#endif - VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, - VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, -#endif - VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, - VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; -typedef VkFlags VkInstanceCreateFlags; - -typedef enum VkMemoryHeapFlagBits { - VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; - -typedef enum VkMemoryPropertyFlagBits { - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, - VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, - VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, - VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, - VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, - VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum VkQueueFlagBits { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_TRANSFER_BIT = 0x00000004, - VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, - VK_QUEUE_PROTECTED_BIT = 0x00000010, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, -#endif - VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; -typedef VkFlags VkDeviceCreateFlags; - -typedef enum VkDeviceQueueCreateFlagBits { - VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, - VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDeviceQueueCreateFlagBits; -typedef VkFlags VkDeviceQueueCreateFlags; - -typedef enum VkPipelineStageFlagBits { - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, - VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, - VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, - VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000, - VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, - VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, - VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, - VK_PIPELINE_STAGE_NONE_KHR = 0, - VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum VkSparseMemoryBindFlagBits { - VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, - VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum VkSparseImageFormatFlagBits { - VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, - VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum VkFenceCreateFlagBits { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; - -typedef enum VkEventCreateFlagBits { - VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = 0x00000001, - VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkEventCreateFlagBits; -typedef VkFlags VkEventCreateFlags; - -typedef enum VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, - VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; -typedef VkFlags VkQueryPoolCreateFlags; - -typedef enum VkQueryResultFlagBits { - VK_QUERY_RESULT_64_BIT = 0x00000001, - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, -#endif - VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum VkBufferCreateFlagBits { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum VkBufferUsageFlagBits { - VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, -#endif - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, - VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, - VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, -#endif - VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; -typedef VkFlags VkBufferViewCreateFlags; - -typedef enum VkImageViewCreateFlagBits { - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, - VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageViewCreateFlagBits; -typedef VkFlags VkImageViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; - -typedef enum VkPipelineCacheCreateFlagBits { - VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = 0x00000001, - VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheCreateFlagBits; -typedef VkFlags VkPipelineCacheCreateFlags; - -typedef enum VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, - VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkColorComponentFlagBits; -typedef VkFlags VkColorComponentFlags; - -typedef enum VkPipelineCreateFlagBits { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, - VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, - VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, - VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, - VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, - VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, - VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, - VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = 0x00000100, - VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = 0x00000200, - VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, - VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, - VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum VkPipelineShaderStageCreateFlagBits { - VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000001, - VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000002, - VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineShaderStageCreateFlagBits; -typedef VkFlags VkPipelineShaderStageCreateFlags; - -typedef enum VkShaderStageFlagBits { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, - VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, - VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, - VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, - VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, - VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040, - VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080, - VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, - VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, - VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, - VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, - VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, - VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, - VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkShaderStageFlagBits; - -typedef enum VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCullModeFlagBits; -typedef VkFlags VkCullModeFlags; -typedef VkFlags VkPipelineVertexInputStateCreateFlags; -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; -typedef VkFlags VkPipelineTessellationStateCreateFlags; -typedef VkFlags VkPipelineViewportStateCreateFlags; -typedef VkFlags VkPipelineRasterizationStateCreateFlags; -typedef VkFlags VkPipelineMultisampleStateCreateFlags; -typedef VkFlags VkPipelineDepthStencilStateCreateFlags; -typedef VkFlags VkPipelineColorBlendStateCreateFlags; -typedef VkFlags VkPipelineDynamicStateCreateFlags; -typedef VkFlags VkPipelineLayoutCreateFlags; -typedef VkFlags VkShaderStageFlags; - -typedef enum VkSamplerCreateFlagBits { - VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, - VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, - VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSamplerCreateFlagBits; -typedef VkFlags VkSamplerCreateFlags; - -typedef enum VkDescriptorPoolCreateFlagBits { - VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolCreateFlagBits; -typedef VkFlags VkDescriptorPoolCreateFlags; -typedef VkFlags VkDescriptorPoolResetFlags; - -typedef enum VkDescriptorSetLayoutCreateFlagBits { - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetLayoutCreateFlagBits; -typedef VkFlags VkDescriptorSetLayoutCreateFlags; - -typedef enum VkAttachmentDescriptionFlagBits { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, - VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentDescriptionFlagBits; -typedef VkFlags VkAttachmentDescriptionFlags; - -typedef enum VkDependencyFlagBits { - VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, - VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, - VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, - VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, - VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, - VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDependencyFlagBits; -typedef VkFlags VkDependencyFlags; - -typedef enum VkFramebufferCreateFlagBits { - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, - VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFramebufferCreateFlagBits; -typedef VkFlags VkFramebufferCreateFlags; - -typedef enum VkRenderPassCreateFlagBits { - VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, - VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassCreateFlagBits; -typedef VkFlags VkRenderPassCreateFlags; - -typedef enum VkSubpassDescriptionFlagBits { - VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, - VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, - VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, - VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, - VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, - VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolCreateFlagBits; -typedef VkFlags VkCommandPoolCreateFlags; - -typedef enum VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolResetFlagBits; -typedef VkFlags VkCommandPoolResetFlags; - -typedef enum VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, - VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferUsageFlagBits; -typedef VkFlags VkCommandBufferUsageFlags; - -typedef enum VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, - VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferResetFlagBits; -typedef VkFlags VkCommandBufferResetFlags; - -typedef enum VkStencilFaceFlagBits { - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, - VK_STENCIL_FACE_BACK_BIT = 0x00000002, - VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, - VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, - VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkStencilFaceFlagBits; -typedef VkFlags VkStencilFaceFlags; -typedef struct VkExtent2D { - uint32_t width; - uint32_t height; -} VkExtent2D; - -typedef struct VkExtent3D { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkExtent3D; - -typedef struct VkOffset2D { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct VkOffset3D { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct VkRect2D { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct VkBaseInStructure { - VkStructureType sType; - const struct VkBaseInStructure* pNext; -} VkBaseInStructure; - -typedef struct VkBaseOutStructure { - VkStructureType sType; - struct VkBaseOutStructure* pNext; -} VkBaseOutStructure; - -typedef struct VkBufferMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct VkDispatchIndirectCommand { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkDrawIndexedIndirectCommand { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; - -typedef struct VkDrawIndirectCommand { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCommand; - -typedef struct VkImageSubresourceRange { - VkImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceRange; - -typedef struct VkImageMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct VkMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier; - -typedef struct VkPipelineCacheHeaderVersionOne { - uint32_t headerSize; - VkPipelineCacheHeaderVersion headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; -} VkPipelineCacheHeaderVersionOne; - -typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - -typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); -typedef struct VkAllocationCallbacks { - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; -} VkAllocationCallbacks; - -typedef struct VkApplicationInfo { - VkStructureType sType; - const void* pNext; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef struct VkFormatProperties { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; - VkFormatFeatureFlags bufferFeatures; -} VkFormatProperties; - -typedef struct VkImageFormatProperties { - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize maxResourceSize; -} VkImageFormatProperties; - -typedef struct VkInstanceCreateInfo { - VkStructureType sType; - const void* pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct VkMemoryHeap { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct VkMemoryType { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct VkPhysicalDeviceFeatures { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSrcBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 drawIndirectFirstInstance; - VkBool32 depthClamp; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 alphaToOne; - VkBool32 multiViewport; - VkBool32 samplerAnisotropy; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryPrecise; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexPipelineStoresAndAtomics; - VkBool32 fragmentStoresAndAtomics; - VkBool32 shaderTessellationAndGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageImageReadWithoutFormat; - VkBool32 shaderStorageImageWriteWithoutFormat; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLod; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; - VkBool32 variableMultisampleRate; - VkBool32 inheritedQueries; -} VkPhysicalDeviceFeatures; - -typedef struct VkPhysicalDeviceLimits { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize bufferImageGranularity; - VkDeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - VkDeviceSize minTexelBufferOffsetAlignment; - VkDeviceSize minUniformBufferOffsetAlignment; - VkDeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize optimalBufferCopyOffsetAlignment; - VkDeviceSize optimalBufferCopyRowPitchAlignment; - VkDeviceSize nonCoherentAtomSize; -} VkPhysicalDeviceLimits; - -typedef struct VkPhysicalDeviceMemoryProperties { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef struct VkPhysicalDeviceSparseProperties { - VkBool32 residencyStandard2DBlockShape; - VkBool32 residencyStandard2DMultisampleBlockShape; - VkBool32 residencyStandard3DBlockShape; - VkBool32 residencyAlignedMipSize; - VkBool32 residencyNonResidentStrict; -} VkPhysicalDeviceSparseProperties; - -typedef struct VkPhysicalDeviceProperties { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - VkPhysicalDeviceLimits limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; - -typedef struct VkQueueFamilyProperties { - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; - -typedef struct VkDeviceQueueCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; -} VkDeviceQueueCreateInfo; - -typedef struct VkDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct VkExtensionProperties { - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct VkLayerProperties { - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkLayerProperties; - -typedef struct VkSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - const VkPipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const VkCommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkSubmitInfo; - -typedef struct VkMappedMemoryRange { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct VkMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo; - -typedef struct VkMemoryRequirements { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct VkSparseMemoryBind { - VkDeviceSize resourceOffset; - VkDeviceSize size; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBind; - -typedef struct VkSparseBufferMemoryBindInfo { - VkBuffer buffer; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseBufferMemoryBindInfo; - -typedef struct VkSparseImageOpaqueMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseImageOpaqueMemoryBindInfo; - -typedef struct VkImageSubresource { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; -} VkImageSubresource; - -typedef struct VkSparseImageMemoryBind { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBind; - -typedef struct VkSparseImageMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseImageMemoryBind* pBinds; -} VkSparseImageMemoryBindInfo; - -typedef struct VkBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const VkSparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const VkSparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkBindSparseInfo; - -typedef struct VkSparseImageFormatProperties { - VkImageAspectFlags aspectMask; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct VkSparseImageMemoryRequirements { - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct VkFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct VkSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct VkEventCreateInfo { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct VkQueryPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct VkBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct VkBufferViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferViewCreateFlags flags; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct VkImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - -typedef struct VkSubresourceLayout { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize arrayPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct VkComponentMapping { - VkComponentSwizzle r; - VkComponentSwizzle g; - VkComponentSwizzle b; - VkComponentSwizzle a; -} VkComponentMapping; - -typedef struct VkImageViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageViewCreateFlags flags; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct VkShaderModuleCreateInfo { - VkStructureType sType; - const void* pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; -} VkShaderModuleCreateInfo; - -typedef struct VkPipelineCacheCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; -} VkPipelineCacheCreateInfo; - -typedef struct VkSpecializationMapEntry { - uint32_t constantID; - uint32_t offset; - size_t size; -} VkSpecializationMapEntry; - -typedef struct VkSpecializationInfo { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct VkPipelineShaderStageCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule module; - const char* pName; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct VkComputePipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo stage; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct VkVertexInputBindingDescription { - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; -} VkVertexInputBindingDescription; - -typedef struct VkVertexInputAttributeDescription { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription; - -typedef struct VkPipelineVertexInputStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct VkPipelineInputAssemblyStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct VkPipelineTessellationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct VkViewport { - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct VkPipelineViewportStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport* pViewports; - uint32_t scissorCount; - const VkRect2D* pScissors; -} VkPipelineViewportStateCreateInfo; - -typedef struct VkPipelineRasterizationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateCreateFlags flags; - VkBool32 depthClampEnable; - VkBool32 rasterizerDiscardEnable; - VkPolygonMode polygonMode; - VkCullModeFlags cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; -} VkPipelineRasterizationStateCreateInfo; - -typedef struct VkPipelineMultisampleStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineMultisampleStateCreateFlags flags; - VkSampleCountFlagBits rasterizationSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - const VkSampleMask* pSampleMask; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct VkStencilOpState { - VkStencilOp failOp; - VkStencilOp passOp; - VkStencilOp depthFailOp; - VkCompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; -} VkStencilOpState; - -typedef struct VkPipelineDepthStencilStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct VkPipelineColorBlendAttachmentState { - VkBool32 blendEnable; - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; - VkColorComponentFlags colorWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct VkPipelineColorBlendStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct VkPipelineDynamicStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const VkDynamicState* pDynamicStates; -} VkPipelineDynamicStateCreateInfo; - -typedef struct VkGraphicsPipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterizationStateCreateInfo* pRasterizationState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct VkPushConstantRange { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; - -typedef struct VkPipelineLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct VkCopyDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet; - -typedef struct VkDescriptorBufferInfo { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct VkDescriptorImageInfo { - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDescriptorPoolSize { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; - -typedef struct VkDescriptorPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize* pPoolSizes; -} VkDescriptorPoolCreateInfo; - -typedef struct VkDescriptorSetAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkDescriptorSetAllocateInfo; - -typedef struct VkDescriptorSetLayoutBinding { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const VkDescriptorSetLayoutBinding* pBindings; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkWriteDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo* pImageInfo; - const VkDescriptorBufferInfo* pBufferInfo; - const VkBufferView* pTexelBufferView; -} VkWriteDescriptorSet; - -typedef struct VkAttachmentDescription { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; - -typedef struct VkAttachmentReference { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct VkFramebufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkFramebufferCreateFlags flags; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct VkSubpassDescription { - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const VkAttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference* pColorAttachments; - const VkAttachmentReference* pResolveAttachments; - const VkAttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription; - -typedef struct VkSubpassDependency { - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; - -typedef struct VkRenderPassCreateInfo { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct VkCommandPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkCommandBufferAllocateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPool commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo; - -typedef struct VkCommandBufferInheritanceInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; - -typedef struct VkCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo* pInheritanceInfo; -} VkCommandBufferBeginInfo; - -typedef struct VkBufferCopy { - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy; - -typedef struct VkImageSubresourceLayers { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceLayers; - -typedef struct VkBufferImageCopy { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union VkClearColorValue { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - -typedef struct VkClearDepthStencilValue { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef union VkClearValue { - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -} VkClearValue; - -typedef struct VkClearAttachment { - VkImageAspectFlags aspectMask; - uint32_t colorAttachment; - VkClearValue clearValue; -} VkClearAttachment; - -typedef struct VkClearRect { - VkRect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkClearRect; - -typedef struct VkImageBlit { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit; - -typedef struct VkImageCopy { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct VkImageResolve { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct VkRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue* pClearValues; -} VkRenderPassBeginInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); -typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); -typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); -typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); -typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); -typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); -typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); -typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); -typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); -typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance); - -VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( - VkQueue queue); - -VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( - VkDevice device); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory); - -VKAPI_ATTR void VKAPI_CALL vkFreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( - VkDevice device, - VkDeviceMemory memory); - -VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore); - -VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent); - -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule); - -VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData); - -VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler); - -VKAPI_ATTR void VKAPI_CALL vkDestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects); - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); -#endif - - -#define VK_VERSION_1_1 1 -// Vulkan 1.1 version number -#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 - -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) -#define VK_MAX_DEVICE_GROUP_SIZE 32U -#define VK_LUID_SIZE 8U -#define VK_QUEUE_FAMILY_EXTERNAL (~1U) - -typedef enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPointClippingBehavior; - -typedef enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF -} VkTessellationDomainOrigin; - -typedef enum VkSamplerYcbcrModelConversion { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrModelConversion; - -typedef enum VkSamplerYcbcrRange { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrRange; - -typedef enum VkChromaLocation { - VK_CHROMA_LOCATION_COSITED_EVEN = 0, - VK_CHROMA_LOCATION_MIDPOINT = 1, - VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, - VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, - VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF -} VkChromaLocation; - -typedef enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorUpdateTemplateType; - -typedef enum VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, - VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubgroupFeatureFlagBits; -typedef VkFlags VkSubgroupFeatureFlags; - -typedef enum VkPeerMemoryFeatureFlagBits { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, - VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPeerMemoryFeatureFlagBits; -typedef VkFlags VkPeerMemoryFeatureFlags; - -typedef enum VkMemoryAllocateFlagBits { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryAllocateFlagBits; -typedef VkFlags VkMemoryAllocateFlags; -typedef VkFlags VkCommandPoolTrimFlags; -typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; - -typedef enum VkExternalMemoryHandleTypeFlagBits { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBits; -typedef VkFlags VkExternalMemoryHandleTypeFlags; - -typedef enum VkExternalMemoryFeatureFlagBits { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBits; -typedef VkFlags VkExternalMemoryFeatureFlags; - -typedef enum VkExternalFenceHandleTypeFlagBits { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceHandleTypeFlagBits; -typedef VkFlags VkExternalFenceHandleTypeFlags; - -typedef enum VkExternalFenceFeatureFlagBits { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceFeatureFlagBits; -typedef VkFlags VkExternalFenceFeatureFlags; - -typedef enum VkFenceImportFlagBits { - VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, - VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceImportFlagBits; -typedef VkFlags VkFenceImportFlags; - -typedef enum VkSemaphoreImportFlagBits { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, - VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreImportFlagBits; -typedef VkFlags VkSemaphoreImportFlags; - -typedef enum VkExternalSemaphoreHandleTypeFlagBits { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreHandleTypeFlagBits; -typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - -typedef enum VkExternalSemaphoreFeatureFlagBits { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreFeatureFlagBits; -typedef VkFlags VkExternalSemaphoreFeatureFlags; -typedef struct VkPhysicalDeviceSubgroupProperties { - VkStructureType sType; - void* pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties; - -typedef struct VkBindBufferMemoryInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindBufferMemoryInfo; - -typedef struct VkBindImageMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindImageMemoryInfo; - -typedef struct VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; - -typedef struct VkMemoryDedicatedRequirements { - VkStructureType sType; - void* pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements; - -typedef struct VkMemoryDedicatedAllocateInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkMemoryDedicatedAllocateInfo; - -typedef struct VkMemoryAllocateFlagsInfo { - VkStructureType sType; - const void* pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo; - -typedef struct VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D* pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - -typedef struct VkDeviceGroupCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; -} VkDeviceGroupCommandBufferBeginInfo; - -typedef struct VkDeviceGroupSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; -} VkDeviceGroupSubmitInfo; - -typedef struct VkDeviceGroupBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo; - -typedef struct VkBindBufferMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo; - -typedef struct VkBindImageMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const VkRect2D* pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo; - -typedef struct VkPhysicalDeviceGroupProperties { - VkStructureType sType; - void* pNext; - uint32_t physicalDeviceCount; - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties; - -typedef struct VkDeviceGroupDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t physicalDeviceCount; - const VkPhysicalDevice* pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo; - -typedef struct VkBufferMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferMemoryRequirementsInfo2; - -typedef struct VkImageMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageMemoryRequirementsInfo2; - -typedef struct VkImageSparseMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageSparseMemoryRequirementsInfo2; - -typedef struct VkMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkMemoryRequirements memoryRequirements; -} VkMemoryRequirements2; - -typedef struct VkSparseImageMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkSparseImageMemoryRequirements memoryRequirements; -} VkSparseImageMemoryRequirements2; - -typedef struct VkPhysicalDeviceFeatures2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceFeatures features; -} VkPhysicalDeviceFeatures2; - -typedef struct VkPhysicalDeviceProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceProperties properties; -} VkPhysicalDeviceProperties2; - -typedef struct VkFormatProperties2 { - VkStructureType sType; - void* pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; - -typedef struct VkImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkImageFormatProperties imageFormatProperties; -} VkImageFormatProperties2; - -typedef struct VkPhysicalDeviceImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo2; - -typedef struct VkQueueFamilyProperties2 { - VkStructureType sType; - void* pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties2; - -typedef struct VkPhysicalDeviceMemoryProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceMemoryProperties memoryProperties; -} VkPhysicalDeviceMemoryProperties2; - -typedef struct VkSparseImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties2; - -typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkSampleCountFlagBits samples; - VkImageUsageFlags usage; - VkImageTiling tiling; -} VkPhysicalDeviceSparseImageFormatInfo2; - -typedef struct VkPhysicalDevicePointClippingProperties { - VkStructureType sType; - void* pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties; - -typedef struct VkInputAttachmentAspectReference { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; - -typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference* pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; - -typedef struct VkImageViewUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; - -typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo; - -typedef struct VkRenderPassMultiviewCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; - -typedef struct VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType; - void* pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; - -typedef struct VkPhysicalDeviceMultiviewProperties { - VkStructureType sType; - void* pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties; - -typedef struct VkPhysicalDeviceVariablePointersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointersFeatures; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 protectedMemory; -} VkPhysicalDeviceProtectedMemoryFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryProperties { - VkStructureType sType; - void* pNext; - VkBool32 protectedNoFault; -} VkPhysicalDeviceProtectedMemoryProperties; - -typedef struct VkDeviceQueueInfo2 { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -} VkDeviceQueueInfo2; - -typedef struct VkProtectedSubmitInfo { - VkStructureType sType; - const void* pNext; - VkBool32 protectedSubmit; -} VkProtectedSubmitInfo; - -typedef struct VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionInfo { - VkStructureType sType; - const void* pNext; - VkSamplerYcbcrConversion conversion; -} VkSamplerYcbcrConversionInfo; - -typedef struct VkBindImagePlaneMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo; - -typedef struct VkImagePlaneMemoryRequirementsInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkImagePlaneMemoryRequirementsInfo; - -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType; - void* pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType; - void* pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; - -typedef struct VkDescriptorUpdateTemplateEntry { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - size_t offset; - size_t stride; -} VkDescriptorUpdateTemplateEntry; - -typedef struct VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; - -typedef struct VkExternalMemoryProperties { - VkExternalMemoryFeatureFlags externalMemoryFeatures; - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlags compatibleHandleTypes; -} VkExternalMemoryProperties; - -typedef struct VkPhysicalDeviceExternalImageFormatInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo; - -typedef struct VkExternalImageFormatProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties; - -typedef struct VkPhysicalDeviceExternalBufferInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo; - -typedef struct VkExternalBufferProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties; - -typedef struct VkPhysicalDeviceIDProperties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties; - -typedef struct VkExternalMemoryImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryImageCreateInfo; - -typedef struct VkExternalMemoryBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryBufferCreateInfo; - -typedef struct VkExportMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo; - -typedef struct VkPhysicalDeviceExternalFenceInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo; - -typedef struct VkExternalFenceProperties { - VkStructureType sType; - void* pNext; - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - VkExternalFenceHandleTypeFlags compatibleHandleTypes; - VkExternalFenceFeatureFlags externalFenceFeatures; -} VkExternalFenceProperties; - -typedef struct VkExportFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo; - -typedef struct VkExportSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo; - -typedef struct VkExternalSemaphoreProperties { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; -} VkExternalSemaphoreProperties; - -typedef struct VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType; - void* pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties; - -typedef struct VkDescriptorSetLayoutSupport { - VkStructureType sType; - void* pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; - -typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParametersFeatures; - -typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( - uint32_t* pApiVersion); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); -#endif - - -#define VK_VERSION_1_2 1 -// Vulkan 1.2 version number -#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 - -#define VK_MAX_DRIVER_NAME_SIZE 256U -#define VK_MAX_DRIVER_INFO_SIZE 256U - -typedef enum VkDriverId { - VK_DRIVER_ID_AMD_PROPRIETARY = 1, - VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, - VK_DRIVER_ID_MESA_RADV = 3, - VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, - VK_DRIVER_ID_ARM_PROPRIETARY = 9, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, - VK_DRIVER_ID_GGP_PROPRIETARY = 11, - VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, - VK_DRIVER_ID_MESA_LLVMPIPE = 13, - VK_DRIVER_ID_MOLTENVK = 14, - VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, - VK_DRIVER_ID_JUICE_PROPRIETARY = 16, - VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, - VK_DRIVER_ID_MESA_TURNIP = 18, - VK_DRIVER_ID_MESA_V3DV = 19, - VK_DRIVER_ID_MESA_PANVK = 20, - VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, - VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, - VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, - VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, - VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, - VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, - VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, - VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF -} VkDriverId; - -typedef enum VkShaderFloatControlsIndependence { - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF -} VkShaderFloatControlsIndependence; - -typedef enum VkSamplerReductionMode { - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, - VK_SAMPLER_REDUCTION_MODE_MIN = 1, - VK_SAMPLER_REDUCTION_MODE_MAX = 2, - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, - VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, - VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, - VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerReductionMode; - -typedef enum VkSemaphoreType { - VK_SEMAPHORE_TYPE_BINARY = 0, - VK_SEMAPHORE_TYPE_TIMELINE = 1, - VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, - VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, - VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreType; - -typedef enum VkResolveModeFlagBits { - VK_RESOLVE_MODE_NONE = 0, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, - VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, - VK_RESOLVE_MODE_MIN_BIT = 0x00000004, - VK_RESOLVE_MODE_MAX_BIT = 0x00000008, - VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, - VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, - VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, - VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, - VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkResolveModeFlagBits; -typedef VkFlags VkResolveModeFlags; - -typedef enum VkDescriptorBindingFlagBits { - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, - VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorBindingFlagBits; -typedef VkFlags VkDescriptorBindingFlags; - -typedef enum VkSemaphoreWaitFlagBits { - VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, - VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, - VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreWaitFlagBits; -typedef VkFlags VkSemaphoreWaitFlags; -typedef struct VkPhysicalDeviceVulkan11Features { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; - VkBool32 protectedMemory; - VkBool32 samplerYcbcrConversion; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceVulkan11Features; - -typedef struct VkPhysicalDeviceVulkan11Properties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; - uint32_t subgroupSize; - VkShaderStageFlags subgroupSupportedStages; - VkSubgroupFeatureFlags subgroupSupportedOperations; - VkBool32 subgroupQuadOperationsInAllStages; - VkPointClippingBehavior pointClippingBehavior; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - VkBool32 protectedNoFault; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceVulkan11Properties; - -typedef struct VkPhysicalDeviceVulkan12Features { - VkStructureType sType; - void* pNext; - VkBool32 samplerMirrorClampToEdge; - VkBool32 drawIndirectCount; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; - VkBool32 descriptorIndexing; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; - VkBool32 samplerFilterMinmax; - VkBool32 scalarBlockLayout; - VkBool32 imagelessFramebuffer; - VkBool32 uniformBufferStandardLayout; - VkBool32 shaderSubgroupExtendedTypes; - VkBool32 separateDepthStencilLayouts; - VkBool32 hostQueryReset; - VkBool32 timelineSemaphore; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; - VkBool32 shaderOutputViewportIndex; - VkBool32 shaderOutputLayer; - VkBool32 subgroupBroadcastDynamicId; -} VkPhysicalDeviceVulkan12Features; - -typedef struct VkConformanceVersion { - uint8_t major; - uint8_t minor; - uint8_t subminor; - uint8_t patch; -} VkConformanceVersion; - -typedef struct VkPhysicalDeviceVulkan12Properties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; - uint64_t maxTimelineSemaphoreValueDifference; - VkSampleCountFlags framebufferIntegerColorSampleCounts; -} VkPhysicalDeviceVulkan12Properties; - -typedef struct VkImageFormatListCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkImageFormatListCreateInfo; - -typedef struct VkAttachmentDescription2 { - VkStructureType sType; - const void* pNext; - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription2; - -typedef struct VkAttachmentReference2 { - VkStructureType sType; - const void* pNext; - uint32_t attachment; - VkImageLayout layout; - VkImageAspectFlags aspectMask; -} VkAttachmentReference2; - -typedef struct VkSubpassDescription2 { - VkStructureType sType; - const void* pNext; - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const VkAttachmentReference2* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference2* pColorAttachments; - const VkAttachmentReference2* pResolveAttachments; - const VkAttachmentReference2* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription2; - -typedef struct VkSubpassDependency2 { - VkStructureType sType; - const void* pNext; - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; - int32_t viewOffset; -} VkSubpassDependency2; - -typedef struct VkRenderPassCreateInfo2 { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription2* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription2* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency2* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; -} VkRenderPassCreateInfo2; - -typedef struct VkSubpassBeginInfo { - VkStructureType sType; - const void* pNext; - VkSubpassContents contents; -} VkSubpassBeginInfo; - -typedef struct VkSubpassEndInfo { - VkStructureType sType; - const void* pNext; -} VkSubpassEndInfo; - -typedef struct VkPhysicalDevice8BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; -} VkPhysicalDevice8BitStorageFeatures; - -typedef struct VkPhysicalDeviceDriverProperties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; -} VkPhysicalDeviceDriverProperties; - -typedef struct VkPhysicalDeviceShaderAtomicInt64Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; -} VkPhysicalDeviceShaderAtomicInt64Features; - -typedef struct VkPhysicalDeviceShaderFloat16Int8Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; -} VkPhysicalDeviceShaderFloat16Int8Features; - -typedef struct VkPhysicalDeviceFloatControlsProperties { - VkStructureType sType; - void* pNext; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; -} VkPhysicalDeviceFloatControlsProperties; - -typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkDescriptorBindingFlags* pBindingFlags; -} VkDescriptorSetLayoutBindingFlagsCreateInfo; - -typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeatures; - -typedef struct VkPhysicalDeviceDescriptorIndexingProperties { - VkStructureType sType; - void* pNext; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; -} VkPhysicalDeviceDescriptorIndexingProperties; - -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfo; - -typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { - VkStructureType sType; - void* pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupport; - -typedef struct VkSubpassDescriptionDepthStencilResolve { - VkStructureType sType; - const void* pNext; - VkResolveModeFlagBits depthResolveMode; - VkResolveModeFlagBits stencilResolveMode; - const VkAttachmentReference2* pDepthStencilResolveAttachment; -} VkSubpassDescriptionDepthStencilResolve; - -typedef struct VkPhysicalDeviceDepthStencilResolveProperties { - VkStructureType sType; - void* pNext; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; -} VkPhysicalDeviceDepthStencilResolveProperties; - -typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 scalarBlockLayout; -} VkPhysicalDeviceScalarBlockLayoutFeatures; - -typedef struct VkImageStencilUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags stencilUsage; -} VkImageStencilUsageCreateInfo; - -typedef struct VkSamplerReductionModeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerReductionMode reductionMode; -} VkSamplerReductionModeCreateInfo; - -typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { - VkStructureType sType; - void* pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxProperties; - -typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { - VkStructureType sType; - void* pNext; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; -} VkPhysicalDeviceVulkanMemoryModelFeatures; - -typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { - VkStructureType sType; - void* pNext; - VkBool32 imagelessFramebuffer; -} VkPhysicalDeviceImagelessFramebufferFeatures; - -typedef struct VkFramebufferAttachmentImageInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkFramebufferAttachmentImageInfo; - -typedef struct VkFramebufferAttachmentsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentImageInfoCount; - const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; -} VkFramebufferAttachmentsCreateInfo; - -typedef struct VkRenderPassAttachmentBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkImageView* pAttachments; -} VkRenderPassAttachmentBeginInfo; - -typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 uniformBufferStandardLayout; -} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; - -typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupExtendedTypes; -} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; - -typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { - VkStructureType sType; - void* pNext; - VkBool32 separateDepthStencilLayouts; -} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; - -typedef struct VkAttachmentReferenceStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilLayout; -} VkAttachmentReferenceStencilLayout; - -typedef struct VkAttachmentDescriptionStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilInitialLayout; - VkImageLayout stencilFinalLayout; -} VkAttachmentDescriptionStencilLayout; - -typedef struct VkPhysicalDeviceHostQueryResetFeatures { - VkStructureType sType; - void* pNext; - VkBool32 hostQueryReset; -} VkPhysicalDeviceHostQueryResetFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { - VkStructureType sType; - void* pNext; - VkBool32 timelineSemaphore; -} VkPhysicalDeviceTimelineSemaphoreFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { - VkStructureType sType; - void* pNext; - uint64_t maxTimelineSemaphoreValueDifference; -} VkPhysicalDeviceTimelineSemaphoreProperties; - -typedef struct VkSemaphoreTypeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreType semaphoreType; - uint64_t initialValue; -} VkSemaphoreTypeCreateInfo; - -typedef struct VkTimelineSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; -} VkTimelineSemaphoreSubmitInfo; - -typedef struct VkSemaphoreWaitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreWaitFlags flags; - uint32_t semaphoreCount; - const VkSemaphore* pSemaphores; - const uint64_t* pValues; -} VkSemaphoreWaitInfo; - -typedef struct VkSemaphoreSignalInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; -} VkSemaphoreSignalInfo; - -typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeatures; - -typedef struct VkBufferDeviceAddressInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfo; - -typedef struct VkBufferOpaqueCaptureAddressCreateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkBufferOpaqueCaptureAddressCreateInfo; - -typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkMemoryOpaqueCaptureAddressAllocateInfo; - -typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkDeviceMemoryOpaqueCaptureAddressInfo; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); - -VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); - -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -#endif - - -#define VK_KHR_surface 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) -#define VK_KHR_SURFACE_SPEC_VERSION 25 -#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" - -typedef enum VkPresentModeKHR { - VK_PRESENT_MODE_IMMEDIATE_KHR = 0, - VK_PRESENT_MODE_MAILBOX_KHR = 1, - VK_PRESENT_MODE_FIFO_KHR = 2, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, - VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentModeKHR; - -typedef enum VkColorSpaceKHR { - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, - VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, - VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, - VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, - VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, - VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, - VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, - VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, - VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkColorSpaceKHR; - -typedef enum VkSurfaceTransformFlagBitsKHR { - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, - VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSurfaceTransformFlagBitsKHR; - -typedef enum VkCompositeAlphaFlagBitsKHR { - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, - VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCompositeAlphaFlagBitsKHR; -typedef VkFlags VkCompositeAlphaFlagsKHR; -typedef VkFlags VkSurfaceTransformFlagsKHR; -typedef struct VkSurfaceCapabilitiesKHR { - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; -} VkSurfaceCapabilitiesKHR; - -typedef struct VkSurfaceFormatKHR { - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; - -typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); -#endif - - -#define VK_KHR_swapchain 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) -#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 -#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" - -typedef enum VkSwapchainCreateFlagBitsKHR { - VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, - VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, - VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, - VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSwapchainCreateFlagBitsKHR; -typedef VkFlags VkSwapchainCreateFlagsKHR; - -typedef enum VkDeviceGroupPresentModeFlagBitsKHR { - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, - VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, - VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, - VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDeviceGroupPresentModeFlagBitsKHR; -typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; -typedef struct VkSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR oldSwapchain; -} VkSwapchainCreateInfoKHR; - -typedef struct VkPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t swapchainCount; - const VkSwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - VkResult* pResults; -} VkPresentInfoKHR; - -typedef struct VkImageSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; -} VkImageSwapchainCreateInfoKHR; - -typedef struct VkBindImageMemorySwapchainInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR; - -typedef struct VkAcquireNextImageInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint64_t timeout; - VkSemaphore semaphore; - VkFence fence; - uint32_t deviceMask; -} VkAcquireNextImageInfoKHR; - -typedef struct VkDeviceGroupPresentCapabilitiesKHR { - VkStructureType sType; - void* pNext; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupPresentCapabilitiesKHR; - -typedef struct VkDeviceGroupPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - VkDeviceGroupPresentModeFlagBitsKHR mode; -} VkDeviceGroupPresentInfoKHR; - -typedef struct VkDeviceGroupSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); -typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); -typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain); - -VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex); -#endif - - -#define VK_KHR_display 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) -#define VK_KHR_DISPLAY_SPEC_VERSION 23 -#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" -typedef VkFlags VkDisplayModeCreateFlagsKHR; - -typedef enum VkDisplayPlaneAlphaFlagBitsKHR { - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, - VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDisplayPlaneAlphaFlagBitsKHR; -typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; -typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; -typedef struct VkDisplayModeParametersKHR { - VkExtent2D visibleRegion; - uint32_t refreshRate; -} VkDisplayModeParametersKHR; - -typedef struct VkDisplayModeCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeCreateFlagsKHR flags; - VkDisplayModeParametersKHR parameters; -} VkDisplayModeCreateInfoKHR; - -typedef struct VkDisplayModePropertiesKHR { - VkDisplayModeKHR displayMode; - VkDisplayModeParametersKHR parameters; -} VkDisplayModePropertiesKHR; - -typedef struct VkDisplayPlaneCapabilitiesKHR { - VkDisplayPlaneAlphaFlagsKHR supportedAlpha; - VkOffset2D minSrcPosition; - VkOffset2D maxSrcPosition; - VkExtent2D minSrcExtent; - VkExtent2D maxSrcExtent; - VkOffset2D minDstPosition; - VkOffset2D maxDstPosition; - VkExtent2D minDstExtent; - VkExtent2D maxDstExtent; -} VkDisplayPlaneCapabilitiesKHR; - -typedef struct VkDisplayPlanePropertiesKHR { - VkDisplayKHR currentDisplay; - uint32_t currentStackIndex; -} VkDisplayPlanePropertiesKHR; - -typedef struct VkDisplayPropertiesKHR { - VkDisplayKHR display; - const char* displayName; - VkExtent2D physicalDimensions; - VkExtent2D physicalResolution; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkBool32 planeReorderPossible; - VkBool32 persistentContent; -} VkDisplayPropertiesKHR; - -typedef struct VkDisplaySurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplaySurfaceCreateFlagsKHR flags; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkDisplaySurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - - -#define VK_KHR_display_swapchain 1 -#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 -#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" -typedef struct VkDisplayPresentInfoKHR { - VkStructureType sType; - const void* pNext; - VkRect2D srcRect; - VkRect2D dstRect; - VkBool32 persistent; -} VkDisplayPresentInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains); -#endif - - -#define VK_KHR_sampler_mirror_clamp_to_edge 1 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" - - -#define VK_KHR_dynamic_rendering 1 -#define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 -#define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering" - -typedef enum VkRenderingFlagBitsKHR { - VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = 0x00000001, - VK_RENDERING_SUSPENDING_BIT_KHR = 0x00000002, - VK_RENDERING_RESUMING_BIT_KHR = 0x00000004, - VK_RENDERING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkRenderingFlagBitsKHR; -typedef VkFlags VkRenderingFlagsKHR; -typedef struct VkRenderingAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkResolveModeFlagBits resolveMode; - VkImageView resolveImageView; - VkImageLayout resolveImageLayout; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkClearValue clearValue; -} VkRenderingAttachmentInfoKHR; - -typedef struct VkRenderingInfoKHR { - VkStructureType sType; - const void* pNext; - VkRenderingFlagsKHR flags; - VkRect2D renderArea; - uint32_t layerCount; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkRenderingAttachmentInfoKHR* pColorAttachments; - const VkRenderingAttachmentInfoKHR* pDepthAttachment; - const VkRenderingAttachmentInfoKHR* pStencilAttachment; -} VkRenderingInfoKHR; - -typedef struct VkPipelineRenderingCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkPipelineRenderingCreateInfoKHR; - -typedef struct VkPhysicalDeviceDynamicRenderingFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRendering; -} VkPhysicalDeviceDynamicRenderingFeaturesKHR; - -typedef struct VkCommandBufferInheritanceRenderingInfoKHR { - VkStructureType sType; - const void* pNext; - VkRenderingFlagsKHR flags; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; - VkSampleCountFlagBits rasterizationSamples; -} VkCommandBufferInheritanceRenderingInfoKHR; - -typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkExtent2D shadingRateAttachmentTexelSize; -} VkRenderingFragmentShadingRateAttachmentInfoKHR; - -typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; -} VkRenderingFragmentDensityMapAttachmentInfoEXT; - -typedef struct VkAttachmentSampleCountInfoAMD { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const VkSampleCountFlagBits* pColorAttachmentSamples; - VkSampleCountFlagBits depthStencilAttachmentSamples; -} VkAttachmentSampleCountInfoAMD; - -typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; - -typedef struct VkMultiviewPerViewAttributesInfoNVX { - VkStructureType sType; - const void* pNext; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; -} VkMultiviewPerViewAttributesInfoNVX; - -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInfoKHR* pRenderingInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR( - VkCommandBuffer commandBuffer); -#endif - - -#define VK_KHR_multiview 1 -#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 -#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" -typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; - -typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; - -typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; - - - -#define VK_KHR_get_physical_device_properties2 1 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" -typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; - -typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; - -typedef VkFormatProperties2 VkFormatProperties2KHR; - -typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; - -typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; - -typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; - -typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; - -typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; - -typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); -#endif - - -#define VK_KHR_device_group 1 -#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 -#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" -typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; - -typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; - -typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; - -typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; - -typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; - -typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; - -typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; - -typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; - -typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; - -typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; - -typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); -#endif - - -#define VK_KHR_shader_draw_parameters 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" - - -#define VK_KHR_maintenance1 1 -#define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2 -#define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1" -#define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION -#define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME -typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; - -typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); -#endif - - -#define VK_KHR_device_group_creation 1 -#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 -#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" -#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE -typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; - -typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -#endif - - -#define VK_KHR_external_memory_capabilities 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" -#define VK_LUID_SIZE_KHR VK_LUID_SIZE -typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; - -typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; - -typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; - -typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; - -typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; - -typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; - -typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; - -typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; - -typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; - -typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); -#endif - - -#define VK_KHR_external_memory 1 -#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" -#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL -typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; - -typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; - -typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; - - - -#define VK_KHR_external_memory_fd 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" -typedef struct VkImportMemoryFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - int fd; -} VkImportMemoryFdInfoKHR; - -typedef struct VkMemoryFdPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryFdPropertiesKHR; - -typedef struct VkMemoryGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties); -#endif - - -#define VK_KHR_external_semaphore_capabilities 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" -typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; - -typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; - -typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; - -typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; - -typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -#endif - - -#define VK_KHR_external_semaphore 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" -typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; - -typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; - -typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; - - - -#define VK_KHR_external_semaphore_fd 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" -typedef struct VkImportSemaphoreFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - int fd; -} VkImportSemaphoreFdInfoKHR; - -typedef struct VkSemaphoreGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif - - -#define VK_KHR_push_descriptor 1 -#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 -#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" -typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorPropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); -#endif - - -#define VK_KHR_shader_float16_int8 1 -#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 -#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; - -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; - - - -#define VK_KHR_16bit_storage 1 -#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 -#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" -typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; - - - -#define VK_KHR_incremental_present 1 -#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 -#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" -typedef struct VkRectLayerKHR { - VkOffset2D offset; - VkExtent2D extent; - uint32_t layer; -} VkRectLayerKHR; - -typedef struct VkPresentRegionKHR { - uint32_t rectangleCount; - const VkRectLayerKHR* pRectangles; -} VkPresentRegionKHR; - -typedef struct VkPresentRegionsKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR* pRegions; -} VkPresentRegionsKHR; - - - -#define VK_KHR_descriptor_update_template 1 -typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; - -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" -typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; - -typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; - -typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; - -typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); -#endif - - -#define VK_KHR_imageless_framebuffer 1 -#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1 -#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" -typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; - -typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; - -typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; - -typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; - - - -#define VK_KHR_create_renderpass2 1 -#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 -#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" -typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; - -typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; - -typedef VkAttachmentReference2 VkAttachmentReference2KHR; - -typedef VkSubpassDescription2 VkSubpassDescription2KHR; - -typedef VkSubpassDependency2 VkSubpassDependency2KHR; - -typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; - -typedef VkSubpassEndInfo VkSubpassEndInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); -#endif - - -#define VK_KHR_shared_presentable_image 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" -typedef struct VkSharedPresentSurfaceCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkImageUsageFlags sharedPresentSupportedUsageFlags; -} VkSharedPresentSurfaceCapabilitiesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain); -#endif - - -#define VK_KHR_external_fence_capabilities 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" -typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; - -typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; - -typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; - -typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; - -typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); -#endif - - -#define VK_KHR_external_fence 1 -#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" -typedef VkFenceImportFlags VkFenceImportFlagsKHR; - -typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; - -typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; - - - -#define VK_KHR_external_fence_fd 1 -#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" -typedef struct VkImportFenceFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - int fd; -} VkImportFenceFdInfoKHR; - -typedef struct VkFenceGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif - - -#define VK_KHR_performance_query 1 -#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 -#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" - -typedef enum VkPerformanceCounterUnitKHR { - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, - VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, - VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, - VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, - VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, - VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, - VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, - VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, - VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, - VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterUnitKHR; - -typedef enum VkPerformanceCounterScopeKHR { - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, - VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, - VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterScopeKHR; - -typedef enum VkPerformanceCounterStorageKHR { - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, - VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, - VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, - VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, - VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterStorageKHR; - -typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, - VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterDescriptionFlagBitsKHR; -typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; - -typedef enum VkAcquireProfilingLockFlagBitsKHR { - VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAcquireProfilingLockFlagBitsKHR; -typedef VkFlags VkAcquireProfilingLockFlagsKHR; -typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 performanceCounterQueryPools; - VkBool32 performanceCounterMultipleQueryPools; -} VkPhysicalDevicePerformanceQueryFeaturesKHR; - -typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 allowCommandBufferQueryCopies; -} VkPhysicalDevicePerformanceQueryPropertiesKHR; - -typedef struct VkPerformanceCounterKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterUnitKHR unit; - VkPerformanceCounterScopeKHR scope; - VkPerformanceCounterStorageKHR storage; - uint8_t uuid[VK_UUID_SIZE]; -} VkPerformanceCounterKHR; - -typedef struct VkPerformanceCounterDescriptionKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterDescriptionFlagsKHR flags; - char name[VK_MAX_DESCRIPTION_SIZE]; - char category[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkPerformanceCounterDescriptionKHR; - -typedef struct VkQueryPoolPerformanceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - uint32_t counterIndexCount; - const uint32_t* pCounterIndices; -} VkQueryPoolPerformanceCreateInfoKHR; - -typedef union VkPerformanceCounterResultKHR { - int32_t int32; - int64_t int64; - uint32_t uint32; - uint64_t uint64; - float float32; - double float64; -} VkPerformanceCounterResultKHR; - -typedef struct VkAcquireProfilingLockInfoKHR { - VkStructureType sType; - const void* pNext; - VkAcquireProfilingLockFlagsKHR flags; - uint64_t timeout; -} VkAcquireProfilingLockInfoKHR; - -typedef struct VkPerformanceQuerySubmitInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t counterPassIndex; -} VkPerformanceQuerySubmitInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterKHR* pCounters, - VkPerformanceCounterDescriptionKHR* pCounterDescriptions); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, - uint32_t* pNumPasses); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( - VkDevice device, - const VkAcquireProfilingLockInfoKHR* pInfo); - -VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( - VkDevice device); -#endif - - -#define VK_KHR_maintenance2 1 -#define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2" -#define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION -#define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME -typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; - -typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; - -typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; - -typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; - -typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; - -typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; - -typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; - - - -#define VK_KHR_get_surface_capabilities2 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" -typedef struct VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSurfaceKHR surface; -} VkPhysicalDeviceSurfaceInfo2KHR; - -typedef struct VkSurfaceCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceCapabilitiesKHR surfaceCapabilities; -} VkSurfaceCapabilities2KHR; - -typedef struct VkSurfaceFormat2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceFormatKHR surfaceFormat; -} VkSurfaceFormat2KHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); -#endif - - -#define VK_KHR_variable_pointers 1 -#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 -#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; - - - -#define VK_KHR_get_display_properties2 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" -typedef struct VkDisplayProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPropertiesKHR displayProperties; -} VkDisplayProperties2KHR; - -typedef struct VkDisplayPlaneProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlanePropertiesKHR displayPlaneProperties; -} VkDisplayPlaneProperties2KHR; - -typedef struct VkDisplayModeProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayModePropertiesKHR displayModeProperties; -} VkDisplayModeProperties2KHR; - -typedef struct VkDisplayPlaneInfo2KHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeKHR mode; - uint32_t planeIndex; -} VkDisplayPlaneInfo2KHR; - -typedef struct VkDisplayPlaneCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlaneCapabilitiesKHR capabilities; -} VkDisplayPlaneCapabilities2KHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities); -#endif - - -#define VK_KHR_dedicated_allocation 1 -#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 -#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" -typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; - -typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; - - - -#define VK_KHR_storage_buffer_storage_class 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" - - -#define VK_KHR_relaxed_block_layout 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" - - -#define VK_KHR_get_memory_requirements2 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" -typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; - -typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; - -typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; - -typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; - -typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; - -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -#endif - - -#define VK_KHR_image_format_list 1 -#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 -#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" -typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; - - - -#define VK_KHR_sampler_ycbcr_conversion 1 -typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; - -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14 -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" -typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; - -typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; - -typedef VkChromaLocation VkChromaLocationKHR; - -typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; - -typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; - -typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; - -typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; - -typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; - -typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); -#endif - - -#define VK_KHR_bind_memory2 1 -#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 -#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" -typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; - -typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); -#endif - - -#define VK_KHR_maintenance3 1 -#define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3" -#define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION -#define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME -typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; - -typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); -#endif - - -#define VK_KHR_draw_indirect_count 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - - -#define VK_KHR_shader_subgroup_extended_types 1 -#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1 -#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types" -typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; - - - -#define VK_KHR_8bit_storage 1 -#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 -#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" -typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; - - - -#define VK_KHR_shader_atomic_int64 1 -#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 -#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" -typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; - - - -#define VK_KHR_shader_clock 1 -#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 -#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" -typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupClock; - VkBool32 shaderDeviceClock; -} VkPhysicalDeviceShaderClockFeaturesKHR; - - - -#define VK_KHR_driver_properties 1 -#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 -#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" -#define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE -#define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE -typedef VkDriverId VkDriverIdKHR; - -typedef VkConformanceVersion VkConformanceVersionKHR; - -typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; - - - -#define VK_KHR_shader_float_controls 1 -#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4 -#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" -typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; - -typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; - - - -#define VK_KHR_depth_stencil_resolve 1 -#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1 -#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve" -typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; - -typedef VkResolveModeFlags VkResolveModeFlagsKHR; - -typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; - -typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; - - - -#define VK_KHR_swapchain_mutable_format 1 -#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 -#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" - - -#define VK_KHR_timeline_semaphore 1 -#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2 -#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore" -typedef VkSemaphoreType VkSemaphoreTypeKHR; - -typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; - -typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; - -typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; - -typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; - -typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; - -typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); -#endif - - -#define VK_KHR_vulkan_memory_model 1 -#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 -#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" -typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; - - - -#define VK_KHR_shader_terminate_invocation 1 -#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 -#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" -typedef struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderTerminateInvocation; -} VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; - - - -#define VK_KHR_fragment_shading_rate 1 -#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 -#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" - -typedef enum VkFragmentShadingRateCombinerOpKHR { - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF -} VkFragmentShadingRateCombinerOpKHR; -typedef struct VkFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - const VkAttachmentReference2* pFragmentShadingRateAttachment; - VkExtent2D shadingRateAttachmentTexelSize; -} VkFragmentShadingRateAttachmentInfoKHR; - -typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkExtent2D fragmentSize; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateStateCreateInfoKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineFragmentShadingRate; - VkBool32 primitiveFragmentShadingRate; - VkBool32 attachmentFragmentShadingRate; -} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentShadingRateAttachmentTexelSize; - VkExtent2D maxFragmentShadingRateAttachmentTexelSize; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - VkBool32 primitiveFragmentShadingRateWithMultipleViewports; - VkBool32 layeredShadingRateAttachments; - VkBool32 fragmentShadingRateNonTrivialCombinerOps; - VkExtent2D maxFragmentSize; - uint32_t maxFragmentSizeAspectRatio; - uint32_t maxFragmentShadingRateCoverageSamples; - VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; - VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; - VkBool32 fragmentShadingRateWithSampleMask; - VkBool32 fragmentShadingRateWithShaderSampleMask; - VkBool32 fragmentShadingRateWithConservativeRasterization; - VkBool32 fragmentShadingRateWithFragmentShaderInterlock; - VkBool32 fragmentShadingRateWithCustomSampleLocations; - VkBool32 fragmentShadingRateStrictMultiplyCombiner; -} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateKHR { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleCounts; - VkExtent2D fragmentSize; -} VkPhysicalDeviceFragmentShadingRateKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); -typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( - VkCommandBuffer commandBuffer, - const VkExtent2D* pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -#endif - - -#define VK_KHR_spirv_1_4 1 -#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 -#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" - - -#define VK_KHR_surface_protected_capabilities 1 -#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities" -typedef struct VkSurfaceProtectedCapabilitiesKHR { - VkStructureType sType; - const void* pNext; - VkBool32 supportsProtected; -} VkSurfaceProtectedCapabilitiesKHR; - - - -#define VK_KHR_separate_depth_stencil_layouts 1 -#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1 -#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts" -typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; - -typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; - -typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; - - - -#define VK_KHR_present_wait 1 -#define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1 -#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait" -typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentWait; -} VkPhysicalDevicePresentWaitFeaturesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout); -#endif - - -#define VK_KHR_uniform_buffer_standard_layout 1 -#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout" -typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; - - - -#define VK_KHR_buffer_device_address 1 -#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 -#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" -typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; - -typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; - -typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; - -typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; - -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -#endif - - -#define VK_KHR_deferred_host_operations 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) -#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4 -#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations" -typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); -typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); -typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( - VkDevice device, - const VkAllocationCallbacks* pAllocator, - VkDeferredOperationKHR* pDeferredOperation); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR( - VkDevice device, - VkDeferredOperationKHR operation, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR( - VkDevice device, - VkDeferredOperationKHR operation); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR( - VkDevice device, - VkDeferredOperationKHR operation); - -VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR( - VkDevice device, - VkDeferredOperationKHR operation); -#endif - - -#define VK_KHR_pipeline_executable_properties 1 -#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 -#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" - -typedef enum VkPipelineExecutableStatisticFormatKHR { - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPipelineExecutableStatisticFormatKHR; -typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineExecutableInfo; -} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - -typedef struct VkPipelineInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; -} VkPipelineInfoKHR; - -typedef struct VkPipelineExecutablePropertiesKHR { - VkStructureType sType; - void* pNext; - VkShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; -} VkPipelineExecutablePropertiesKHR; - -typedef struct VkPipelineExecutableInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; - uint32_t executableIndex; -} VkPipelineExecutableInfoKHR; - -typedef union VkPipelineExecutableStatisticValueKHR { - VkBool32 b32; - int64_t i64; - uint64_t u64; - double f64; -} VkPipelineExecutableStatisticValueKHR; - -typedef struct VkPipelineExecutableStatisticKHR { - VkStructureType sType; - void* pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR value; -} VkPipelineExecutableStatisticKHR; - -typedef struct VkPipelineExecutableInternalRepresentationKHR { - VkStructureType sType; - void* pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkBool32 isText; - size_t dataSize; - void* pData; -} VkPipelineExecutableInternalRepresentationKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR( - VkDevice device, - const VkPipelineInfoKHR* pPipelineInfo, - uint32_t* pExecutableCount, - VkPipelineExecutablePropertiesKHR* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pStatisticCount, - VkPipelineExecutableStatisticKHR* pStatistics); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pInternalRepresentationCount, - VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); -#endif - - -#define VK_KHR_shader_integer_dot_product 1 -#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1 -#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" -typedef struct VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerDotProduct; -} VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; -} VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; - - - -#define VK_KHR_pipeline_library 1 -#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1 -#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library" -typedef struct VkPipelineLibraryCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t libraryCount; - const VkPipeline* pLibraries; -} VkPipelineLibraryCreateInfoKHR; - - - -#define VK_KHR_shader_non_semantic_info 1 -#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1 -#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info" - - -#define VK_KHR_present_id 1 -#define VK_KHR_PRESENT_ID_SPEC_VERSION 1 -#define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id" -typedef struct VkPresentIdKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint64_t* pPresentIds; -} VkPresentIdKHR; - -typedef struct VkPhysicalDevicePresentIdFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentId; -} VkPhysicalDevicePresentIdFeaturesKHR; - - - -#define VK_KHR_synchronization2 1 -typedef uint64_t VkFlags64; -#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 -#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" -typedef VkFlags64 VkPipelineStageFlags2KHR; - -// Flag bits for VkPipelineStageFlagBits2KHR -typedef VkFlags64 VkPipelineStageFlagBits2KHR; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; -#endif -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; -static const VkPipelineStageFlagBits2KHR VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; - -typedef VkFlags64 VkAccessFlags2KHR; - -// Flag bits for VkAccessFlagBits2KHR -typedef VkFlags64 VkAccessFlagBits2KHR; -static const VkAccessFlagBits2KHR VK_ACCESS_2_NONE_KHR = 0ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkAccessFlagBits2KHR VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; -#endif -static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; -static const VkAccessFlagBits2KHR VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; - - -typedef enum VkSubmitFlagBitsKHR { - VK_SUBMIT_PROTECTED_BIT_KHR = 0x00000001, - VK_SUBMIT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSubmitFlagBitsKHR; -typedef VkFlags VkSubmitFlagsKHR; -typedef struct VkMemoryBarrier2KHR { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2KHR srcStageMask; - VkAccessFlags2KHR srcAccessMask; - VkPipelineStageFlags2KHR dstStageMask; - VkAccessFlags2KHR dstAccessMask; -} VkMemoryBarrier2KHR; - -typedef struct VkBufferMemoryBarrier2KHR { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2KHR srcStageMask; - VkAccessFlags2KHR srcAccessMask; - VkPipelineStageFlags2KHR dstStageMask; - VkAccessFlags2KHR dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier2KHR; - -typedef struct VkImageMemoryBarrier2KHR { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2KHR srcStageMask; - VkAccessFlags2KHR srcAccessMask; - VkPipelineStageFlags2KHR dstStageMask; - VkAccessFlags2KHR dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier2KHR; - -typedef struct VkDependencyInfoKHR { - VkStructureType sType; - const void* pNext; - VkDependencyFlags dependencyFlags; - uint32_t memoryBarrierCount; - const VkMemoryBarrier2KHR* pMemoryBarriers; - uint32_t bufferMemoryBarrierCount; - const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers; - uint32_t imageMemoryBarrierCount; - const VkImageMemoryBarrier2KHR* pImageMemoryBarriers; -} VkDependencyInfoKHR; - -typedef struct VkSemaphoreSubmitInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; - VkPipelineStageFlags2KHR stageMask; - uint32_t deviceIndex; -} VkSemaphoreSubmitInfoKHR; - -typedef struct VkCommandBufferSubmitInfoKHR { - VkStructureType sType; - const void* pNext; - VkCommandBuffer commandBuffer; - uint32_t deviceMask; -} VkCommandBufferSubmitInfoKHR; - -typedef struct VkSubmitInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSubmitFlagsKHR flags; - uint32_t waitSemaphoreInfoCount; - const VkSemaphoreSubmitInfoKHR* pWaitSemaphoreInfos; - uint32_t commandBufferInfoCount; - const VkCommandBufferSubmitInfoKHR* pCommandBufferInfos; - uint32_t signalSemaphoreInfoCount; - const VkSemaphoreSubmitInfoKHR* pSignalSemaphoreInfos; -} VkSubmitInfo2KHR; - -typedef struct VkPhysicalDeviceSynchronization2FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 synchronization2; -} VkPhysicalDeviceSynchronization2FeaturesKHR; - -typedef struct VkQueueFamilyCheckpointProperties2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2KHR checkpointExecutionStageMask; -} VkQueueFamilyCheckpointProperties2NV; - -typedef struct VkCheckpointData2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2KHR stage; - void* pCheckpointMarker; -} VkCheckpointData2NV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence); -typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); -typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfoKHR* pDependencyInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2KHR stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfoKHR* pDependencyInfos); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( - VkCommandBuffer commandBuffer, - const VkDependencyInfoKHR* pDependencyInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2KHR stage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2KHR* pSubmits, - VkFence fence); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2KHR stage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); - -VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointData2NV* pCheckpointData); -#endif - - -#define VK_KHR_shader_subgroup_uniform_control_flow 1 -#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1 -#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow" -typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupUniformControlFlow; -} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - - - -#define VK_KHR_zero_initialize_workgroup_memory 1 -#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1 -#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory" -typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderZeroInitializeWorkgroupMemory; -} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; - - - -#define VK_KHR_workgroup_memory_explicit_layout 1 -#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout" -typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 workgroupMemoryExplicitLayout; - VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; - VkBool32 workgroupMemoryExplicitLayout8BitAccess; - VkBool32 workgroupMemoryExplicitLayout16BitAccess; -} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - - - -#define VK_KHR_copy_commands2 1 -#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 -#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" -typedef struct VkBufferCopy2KHR { - VkStructureType sType; - const void* pNext; - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy2KHR; - -typedef struct VkCopyBufferInfo2KHR { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferCopy2KHR* pRegions; -} VkCopyBufferInfo2KHR; - -typedef struct VkImageCopy2KHR { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy2KHR; - -typedef struct VkCopyImageInfo2KHR { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2KHR* pRegions; -} VkCopyImageInfo2KHR; - -typedef struct VkBufferImageCopy2KHR { - VkStructureType sType; - const void* pNext; - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy2KHR; - -typedef struct VkCopyBufferToImageInfo2KHR { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkBufferImageCopy2KHR* pRegions; -} VkCopyBufferToImageInfo2KHR; - -typedef struct VkCopyImageToBufferInfo2KHR { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferImageCopy2KHR* pRegions; -} VkCopyImageToBufferInfo2KHR; - -typedef struct VkImageBlit2KHR { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit2KHR; - -typedef struct VkBlitImageInfo2KHR { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageBlit2KHR* pRegions; - VkFilter filter; -} VkBlitImageInfo2KHR; - -typedef struct VkImageResolve2KHR { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve2KHR; - -typedef struct VkResolveImageInfo2KHR { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageResolve2KHR* pRegions; -} VkResolveImageInfo2KHR; - -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2KHR* pCopyBufferInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2KHR* pCopyImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2KHR* pBlitImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2KHR* pResolveImageInfo); -#endif - - -#define VK_KHR_format_feature_flags2 1 -#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 1 -#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" -typedef VkFlags64 VkFormatFeatureFlags2KHR; - -// Flag bits for VkFormatFeatureFlagBits2KHR -typedef VkFlags64 VkFormatFeatureFlagBits2KHR; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; -#endif -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkFormatFeatureFlagBits2KHR VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; -#endif - -typedef struct VkFormatProperties3KHR { - VkStructureType sType; - void* pNext; - VkFormatFeatureFlags2KHR linearTilingFeatures; - VkFormatFeatureFlags2KHR optimalTilingFeatures; - VkFormatFeatureFlags2KHR bufferFeatures; -} VkFormatProperties3KHR; - - - -#define VK_KHR_maintenance4 1 -#define VK_KHR_MAINTENANCE_4_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4" -typedef struct VkPhysicalDeviceMaintenance4FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance4; -} VkPhysicalDeviceMaintenance4FeaturesKHR; - -typedef struct VkPhysicalDeviceMaintenance4PropertiesKHR { - VkStructureType sType; - void* pNext; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceMaintenance4PropertiesKHR; - -typedef struct VkDeviceBufferMemoryRequirementsKHR { - VkStructureType sType; - const void* pNext; - const VkBufferCreateInfo* pCreateInfo; -} VkDeviceBufferMemoryRequirementsKHR; - -typedef struct VkDeviceImageMemoryRequirementsKHR { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - VkImageAspectFlagBits planeAspect; -} VkDeviceImageMemoryRequirementsKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirementsKHR* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR( - VkDevice device, - const VkDeviceBufferMemoryRequirementsKHR* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirementsKHR* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirementsKHR* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -#endif - - -#define VK_EXT_debug_report 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10 -#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" - -typedef enum VkDebugReportObjectTypeEXT { - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportObjectTypeEXT; - -typedef enum VkDebugReportFlagBitsEXT { - VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, - VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, - VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, - VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, - VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, - VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportFlagBitsEXT; -typedef VkFlags VkDebugReportFlagsEXT; -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - -typedef struct VkDebugReportCallbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; -} VkDebugReportCallbackCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage); -#endif - - -#define VK_NV_glsl_shader 1 -#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 -#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" - - -#define VK_EXT_depth_range_unrestricted 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" - - -#define VK_IMG_filter_cubic 1 -#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 -#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" - - -#define VK_AMD_rasterization_order 1 -#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 -#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" - -typedef enum VkRasterizationOrderAMD { - VK_RASTERIZATION_ORDER_STRICT_AMD = 0, - VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, - VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF -} VkRasterizationOrderAMD; -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { - VkStructureType sType; - const void* pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD; - - - -#define VK_AMD_shader_trinary_minmax 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" - - -#define VK_AMD_shader_explicit_vertex_parameter 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" - - -#define VK_EXT_debug_marker 1 -#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 -#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" -typedef struct VkDebugMarkerObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; -} VkDebugMarkerObjectNameInfoEXT; - -typedef struct VkDebugMarkerObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugMarkerObjectTagInfoEXT; - -typedef struct VkDebugMarkerMarkerInfoEXT { - VkStructureType sType; - const void* pNext; - const char* pMarkerName; - float color[4]; -} VkDebugMarkerMarkerInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -#endif - - -#define VK_AMD_gcn_shader 1 -#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 -#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" - - -#define VK_NV_dedicated_allocation 1 -#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 -#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" -typedef struct VkDedicatedAllocationImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationImageCreateInfoNV; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV; - -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV; - - - -#define VK_EXT_transform_feedback 1 -#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 -#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" -typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; -typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 transformFeedback; - VkBool32 geometryStreams; -} VkPhysicalDeviceTransformFeedbackFeaturesEXT; - -typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - VkDeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - VkBool32 transformFeedbackQueries; - VkBool32 transformFeedbackStreamsLinesTriangles; - VkBool32 transformFeedbackRasterizationStreamSelect; - VkBool32 transformFeedbackDraw; -} VkPhysicalDeviceTransformFeedbackPropertiesEXT; - -typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; -} VkPipelineRasterizationStateStreamCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); -typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); -typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride); -#endif - - -#define VK_NVX_binary_import 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) -#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1 -#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import" -typedef struct VkCuModuleCreateInfoNVX { - VkStructureType sType; - const void* pNext; - size_t dataSize; - const void* pData; -} VkCuModuleCreateInfoNVX; - -typedef struct VkCuFunctionCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuModuleNVX module; - const char* pName; -} VkCuFunctionCreateInfoNVX; - -typedef struct VkCuLaunchInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuFunctionNVX function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const * pParams; - size_t extraCount; - const void* const * pExtras; -} VkCuLaunchInfoNVX; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); -typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX( - VkDevice device, - const VkCuModuleCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuModuleNVX* pModule); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX( - VkDevice device, - const VkCuFunctionCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuFunctionNVX* pFunction); - -VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX( - VkDevice device, - VkCuModuleNVX module, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX( - VkDevice device, - VkCuFunctionNVX function, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX( - VkCommandBuffer commandBuffer, - const VkCuLaunchInfoNVX* pLaunchInfo); -#endif - - -#define VK_NVX_image_view_handle 1 -#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2 -#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle" -typedef struct VkImageViewHandleInfoNVX { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkDescriptorType descriptorType; - VkSampler sampler; -} VkImageViewHandleInfoNVX; - -typedef struct VkImageViewAddressPropertiesNVX { - VkStructureType sType; - void* pNext; - VkDeviceAddress deviceAddress; - VkDeviceSize size; -} VkImageViewAddressPropertiesNVX; - -typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX( - VkDevice device, - VkImageView imageView, - VkImageViewAddressPropertiesNVX* pProperties); -#endif - - -#define VK_AMD_draw_indirect_count 1 -#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 -#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - - -#define VK_AMD_negative_viewport_height 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" - - -#define VK_AMD_gpu_shader_half_float 1 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" - - -#define VK_AMD_shader_ballot 1 -#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 -#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" - - -#define VK_AMD_texture_gather_bias_lod 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" -typedef struct VkTextureLODGatherFormatPropertiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 supportsTextureGatherLODBiasAMD; -} VkTextureLODGatherFormatPropertiesAMD; - - - -#define VK_AMD_shader_info 1 -#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 -#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" - -typedef enum VkShaderInfoTypeAMD { - VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, - VK_SHADER_INFO_TYPE_BINARY_AMD = 1, - VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, - VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderInfoTypeAMD; -typedef struct VkShaderResourceUsageAMD { - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; -} VkShaderResourceUsageAMD; - -typedef struct VkShaderStatisticsInfoAMD { - VkShaderStageFlags shaderStageMask; - VkShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; -} VkShaderStatisticsInfoAMD; - -typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t* pInfoSize, - void* pInfo); -#endif - - -#define VK_AMD_shader_image_load_store_lod 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" - - -#define VK_NV_corner_sampled_image 1 -#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 -#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" -typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cornerSampledImage; -} VkPhysicalDeviceCornerSampledImageFeaturesNV; - - - -#define VK_IMG_format_pvrtc 1 -#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 -#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" - - -#define VK_NV_external_memory_capabilities 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" - -typedef enum VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBitsNV; -typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - -typedef enum VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBitsNV; -typedef VkFlags VkExternalMemoryFeatureFlagsNV; -typedef struct VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties; - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; -} VkExternalImageFormatPropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); -#endif - - -#define VK_NV_external_memory 1 -#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" -typedef struct VkExternalMemoryImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExternalMemoryImageCreateInfoNV; - -typedef struct VkExportMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExportMemoryAllocateInfoNV; - - - -#define VK_EXT_validation_flags 1 -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2 -#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" - -typedef enum VkValidationCheckEXT { - VK_VALIDATION_CHECK_ALL_EXT = 0, - VK_VALIDATION_CHECK_SHADERS_EXT = 1, - VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCheckEXT; -typedef struct VkValidationFlagsEXT { - VkStructureType sType; - const void* pNext; - uint32_t disabledValidationCheckCount; - const VkValidationCheckEXT* pDisabledValidationChecks; -} VkValidationFlagsEXT; - - - -#define VK_EXT_shader_subgroup_ballot 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" - - -#define VK_EXT_shader_subgroup_vote 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" - - -#define VK_EXT_texture_compression_astc_hdr 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" -typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 textureCompressionASTC_HDR; -} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; - - - -#define VK_EXT_astc_decode_mode 1 -#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 -#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" -typedef struct VkImageViewASTCDecodeModeEXT { - VkStructureType sType; - const void* pNext; - VkFormat decodeMode; -} VkImageViewASTCDecodeModeEXT; - -typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 decodeModeSharedExponent; -} VkPhysicalDeviceASTCDecodeFeaturesEXT; - - - -#define VK_EXT_conditional_rendering 1 -#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 -#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" - -typedef enum VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, - VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConditionalRenderingFlagBitsEXT; -typedef VkFlags VkConditionalRenderingFlagsEXT; -typedef struct VkConditionalRenderingBeginInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceSize offset; - VkConditionalRenderingFlagsEXT flags; -} VkConditionalRenderingBeginInfoEXT; - -typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 conditionalRendering; - VkBool32 inheritedConditionalRendering; -} VkPhysicalDeviceConditionalRenderingFeaturesEXT; - -typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 conditionalRenderingEnable; -} VkCommandBufferInheritanceConditionalRenderingInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); -typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer); -#endif - - -#define VK_NV_clip_space_w_scaling 1 -#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 -#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" -typedef struct VkViewportWScalingNV { - float xcoeff; - float ycoeff; -} VkViewportWScalingNV; - -typedef struct VkPipelineViewportWScalingStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - const VkViewportWScalingNV* pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings); -#endif - - -#define VK_EXT_direct_mode_display 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" -typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); -#endif - - -#define VK_EXT_display_surface_counter 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" - -typedef enum VkSurfaceCounterFlagBitsEXT { - VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, - VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, - VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSurfaceCounterFlagBitsEXT; -typedef VkFlags VkSurfaceCounterFlagsEXT; -typedef struct VkSurfaceCapabilities2EXT { - VkStructureType sType; - void* pNext; - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; - VkSurfaceCounterFlagsEXT supportedSurfaceCounters; -} VkSurfaceCapabilities2EXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); -#endif - - -#define VK_EXT_display_control 1 -#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" - -typedef enum VkDisplayPowerStateEXT { - VK_DISPLAY_POWER_STATE_OFF_EXT = 0, - VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, - VK_DISPLAY_POWER_STATE_ON_EXT = 2, - VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayPowerStateEXT; - -typedef enum VkDeviceEventTypeEXT { - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, - VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceEventTypeEXT; - -typedef enum VkDisplayEventTypeEXT { - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, - VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayEventTypeEXT; -typedef struct VkDisplayPowerInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayPowerStateEXT powerState; -} VkDisplayPowerInfoEXT; - -typedef struct VkDeviceEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceEventTypeEXT deviceEvent; -} VkDeviceEventInfoEXT; - -typedef struct VkDisplayEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayEventTypeEXT displayEvent; -} VkDisplayEventInfoEXT; - -typedef struct VkSwapchainCounterCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkSurfaceCounterFlagsEXT surfaceCounters; -} VkSwapchainCounterCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue); -#endif - - -#define VK_GOOGLE_display_timing 1 -#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" -typedef struct VkRefreshCycleDurationGOOGLE { - uint64_t refreshDuration; -} VkRefreshCycleDurationGOOGLE; - -typedef struct VkPastPresentationTimingGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; -} VkPastPresentationTimingGOOGLE; - -typedef struct VkPresentTimeGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; -} VkPresentTimeGOOGLE; - -typedef struct VkPresentTimesInfoGOOGLE { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimeGOOGLE* pTimes; -} VkPresentTimesInfoGOOGLE; - -typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings); -#endif - - -#define VK_NV_sample_mask_override_coverage 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" - - -#define VK_NV_geometry_shader_passthrough 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" - - -#define VK_NV_viewport_array2 1 -#define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2" -#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION -#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME - - -#define VK_NVX_multiview_per_view_attributes 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" -typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - VkStructureType sType; - void* pNext; - VkBool32 perViewPositionAllComponents; -} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - - - -#define VK_NV_viewport_swizzle 1 -#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" - -typedef enum VkViewportCoordinateSwizzleNV { - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, - VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF -} VkViewportCoordinateSwizzleNV; -typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; -typedef struct VkViewportSwizzleNV { - VkViewportCoordinateSwizzleNV x; - VkViewportCoordinateSwizzleNV y; - VkViewportCoordinateSwizzleNV z; - VkViewportCoordinateSwizzleNV w; -} VkViewportSwizzleNV; - -typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const VkViewportSwizzleNV* pViewportSwizzles; -} VkPipelineViewportSwizzleStateCreateInfoNV; - - - -#define VK_EXT_discard_rectangles 1 -#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1 -#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" - -typedef enum VkDiscardRectangleModeEXT { - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, - VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, - VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDiscardRectangleModeEXT; -typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT; - -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const VkRect2D* pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles); -#endif - - -#define VK_EXT_conservative_rasterization 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" - -typedef enum VkConservativeRasterizationModeEXT { - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, - VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, - VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, - VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConservativeRasterizationModeEXT; -typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; - VkConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; -} VkPipelineRasterizationConservativeStateCreateInfoEXT; - - - -#define VK_EXT_depth_clip_enable 1 -#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 -#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" -typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClipEnable; -} VkPhysicalDeviceDepthClipEnableFeaturesEXT; - -typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; - VkBool32 depthClipEnable; -} VkPipelineRasterizationDepthClipStateCreateInfoEXT; - - - -#define VK_EXT_swapchain_colorspace 1 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" - - -#define VK_EXT_hdr_metadata 1 -#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 -#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" -typedef struct VkXYColorEXT { - float x; - float y; -} VkXYColorEXT; - -typedef struct VkHdrMetadataEXT { - VkStructureType sType; - const void* pNext; - VkXYColorEXT displayPrimaryRed; - VkXYColorEXT displayPrimaryGreen; - VkXYColorEXT displayPrimaryBlue; - VkXYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; -} VkHdrMetadataEXT; - -typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata); -#endif - - -#define VK_EXT_external_memory_dma_buf 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" - - -#define VK_EXT_queue_family_foreign 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" -#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) - - -#define VK_EXT_debug_utils 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) -#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 -#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" -typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; - -typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageSeverityFlagBitsEXT; - -typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, - VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, - VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageTypeFlagBitsEXT; -typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; -typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; -typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; -typedef struct VkDebugUtilsLabelEXT { - VkStructureType sType; - const void* pNext; - const char* pLabelName; - float color[4]; -} VkDebugUtilsLabelEXT; - -typedef struct VkDebugUtilsObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; -} VkDebugUtilsObjectNameInfoEXT; - -typedef struct VkDebugUtilsMessengerCallbackDataEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - const VkDebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - const VkDebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - const VkDebugUtilsObjectNameInfoEXT* pObjects; -} VkDebugUtilsMessengerCallbackDataEXT; - -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDebugUtilsMessengerCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCreateFlagsEXT flags; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; -} VkDebugUtilsMessengerCreateInfoEXT; - -typedef struct VkDebugUtilsObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugUtilsObjectTagInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); -typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); -typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo); - -VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( - VkQueue queue); - -VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); -#endif - - -#define VK_EXT_sampler_filter_minmax 1 -#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2 -#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" -typedef VkSamplerReductionMode VkSamplerReductionModeEXT; - -typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; - -typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - - - -#define VK_AMD_gpu_shader_int16 1 -#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2 -#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" - - -#define VK_AMD_mixed_attachment_samples 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" - - -#define VK_AMD_shader_fragment_mask 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" - - -#define VK_EXT_inline_uniform_block 1 -#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 -#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" -typedef struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; -} VkPhysicalDeviceInlineUniformBlockFeaturesEXT; - -typedef struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; -} VkPhysicalDeviceInlineUniformBlockPropertiesEXT; - -typedef struct VkWriteDescriptorSetInlineUniformBlockEXT { - VkStructureType sType; - const void* pNext; - uint32_t dataSize; - const void* pData; -} VkWriteDescriptorSetInlineUniformBlockEXT; - -typedef struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t maxInlineUniformBlockBindings; -} VkDescriptorPoolInlineUniformBlockCreateInfoEXT; - - - -#define VK_EXT_shader_stencil_export 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" - - -#define VK_EXT_sample_locations 1 -#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 -#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" -typedef struct VkSampleLocationEXT { - float x; - float y; -} VkSampleLocationEXT; - -typedef struct VkSampleLocationsInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const VkSampleLocationEXT* pSampleLocations; -} VkSampleLocationsInfoEXT; - -typedef struct VkAttachmentSampleLocationsEXT { - uint32_t attachmentIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkAttachmentSampleLocationsEXT; - -typedef struct VkSubpassSampleLocationsEXT { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkSubpassSampleLocationsEXT; - -typedef struct VkRenderPassSampleLocationsBeginInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentInitialSampleLocationsCount; - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT; - -typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT; - -typedef struct VkMultisamplePropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties); -#endif - - -#define VK_EXT_blend_operation_advanced 1 -#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 -#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" - -typedef enum VkBlendOverlapEXT { - VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, - VK_BLEND_OVERLAP_DISJOINT_EXT = 1, - VK_BLEND_OVERLAP_CONJOINT_EXT = 2, - VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBlendOverlapEXT; -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; - -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; - -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT; - - - -#define VK_NV_fragment_coverage_to_color 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" -typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; -typedef struct VkPipelineCoverageToColorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV; - - - -#define VK_NV_framebuffer_mixed_samples 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" - -typedef enum VkCoverageModulationModeNV { - VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, - VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, - VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, - VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, - VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageModulationModeNV; -typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; -typedef struct VkPipelineCoverageModulationStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageModulationStateCreateFlagsNV flags; - VkCoverageModulationModeNV coverageModulationMode; - VkBool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; -} VkPipelineCoverageModulationStateCreateInfoNV; - - - -#define VK_NV_fill_rectangle 1 -#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 -#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" - - -#define VK_NV_shader_sm_builtins 1 -#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1 -#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins" -typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; -} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; - -typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shaderSMBuiltins; -} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; - - - -#define VK_EXT_post_depth_coverage 1 -#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 -#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" - - -#define VK_EXT_image_drm_format_modifier 1 -#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 -#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" -typedef struct VkDrmFormatModifierPropertiesEXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags drmFormatModifierTilingFeatures; -} VkDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierPropertiesListEXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesListEXT; - -typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; - -typedef struct VkImageDrmFormatModifierListCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t drmFormatModifierCount; - const uint64_t* pDrmFormatModifiers; -} VkImageDrmFormatModifierListCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - const VkSubresourceLayout* pPlaneLayouts; -} VkImageDrmFormatModifierExplicitCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierPropertiesEXT { - VkStructureType sType; - void* pNext; - uint64_t drmFormatModifier; -} VkImageDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierProperties2EXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures; -} VkDrmFormatModifierProperties2EXT; - -typedef struct VkDrmFormatModifierPropertiesList2EXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesList2EXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties); -#endif - - -#define VK_EXT_validation_cache 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) -#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 -#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" - -typedef enum VkValidationCacheHeaderVersionEXT { - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, - VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCacheHeaderVersionEXT; -typedef VkFlags VkValidationCacheCreateFlagsEXT; -typedef struct VkValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; -} VkValidationCacheCreateInfoEXT; - -typedef struct VkShaderModuleValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheEXT validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); -typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache); - -VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData); -#endif - - -#define VK_EXT_descriptor_indexing 1 -#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 -#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" -typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; - -typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; - -typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; - -typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; - -typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; - -typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; - -typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; - - - -#define VK_EXT_shader_viewport_index_layer 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" - - -#define VK_NV_shading_rate_image 1 -#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 -#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" - -typedef enum VkShadingRatePaletteEntryNV { - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, - VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, - VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, - VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, - VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, - VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF -} VkShadingRatePaletteEntryNV; - -typedef enum VkCoarseSampleOrderTypeNV { - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, - VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, - VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, - VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, - VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoarseSampleOrderTypeNV; -typedef struct VkShadingRatePaletteNV { - uint32_t shadingRatePaletteEntryCount; - const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; -} VkShadingRatePaletteNV; - -typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 shadingRateImageEnable; - uint32_t viewportCount; - const VkShadingRatePaletteNV* pShadingRatePalettes; -} VkPipelineViewportShadingRateImageStateCreateInfoNV; - -typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shadingRateImage; - VkBool32 shadingRateCoarseSampleOrder; -} VkPhysicalDeviceShadingRateImageFeaturesNV; - -typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { - VkStructureType sType; - void* pNext; - VkExtent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; -} VkPhysicalDeviceShadingRateImagePropertiesNV; - -typedef struct VkCoarseSampleLocationNV { - uint32_t pixelX; - uint32_t pixelY; - uint32_t sample; -} VkCoarseSampleLocationNV; - -typedef struct VkCoarseSampleOrderCustomNV { - VkShadingRatePaletteEntryNV shadingRate; - uint32_t sampleCount; - uint32_t sampleLocationCount; - const VkCoarseSampleLocationNV* pSampleLocations; -} VkCoarseSampleOrderCustomNV; - -typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkCoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; -} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); -#endif - - -#define VK_NV_ray_tracing 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) -#define VK_NV_RAY_TRACING_SPEC_VERSION 3 -#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" -#define VK_SHADER_UNUSED_KHR (~0U) -#define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR - -typedef enum VkRayTracingShaderGroupTypeKHR { - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkRayTracingShaderGroupTypeKHR; -typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; - - -typedef enum VkGeometryTypeKHR { - VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, - VK_GEOMETRY_TYPE_AABBS_KHR = 1, - VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, - VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, - VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, - VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryTypeKHR; -typedef VkGeometryTypeKHR VkGeometryTypeNV; - - -typedef enum VkAccelerationStructureTypeKHR { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, - VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureTypeKHR; -typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; - - -typedef enum VkCopyAccelerationStructureModeKHR { - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, - VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, - VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCopyAccelerationStructureModeKHR; -typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; - - -typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMemoryRequirementsTypeNV; - -typedef enum VkGeometryFlagBitsKHR { - VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, - VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, - VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryFlagBitsKHR; -typedef VkFlags VkGeometryFlagsKHR; -typedef VkGeometryFlagsKHR VkGeometryFlagsNV; - -typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; - - -typedef enum VkGeometryInstanceFlagBitsKHR { - VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, - VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryInstanceFlagBitsKHR; -typedef VkFlags VkGeometryInstanceFlagsKHR; -typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; - -typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; - - -typedef enum VkBuildAccelerationStructureFlagBitsKHR { - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, - VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureFlagBitsKHR; -typedef VkFlags VkBuildAccelerationStructureFlagsKHR; -typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; - -typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; - -typedef struct VkRayTracingShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; -} VkRayTracingShaderGroupCreateInfoNV; - -typedef struct VkRayTracingPipelineCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoNV* pGroups; - uint32_t maxRecursionDepth; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoNV; - -typedef struct VkGeometryTrianglesNV { - VkStructureType sType; - const void* pNext; - VkBuffer vertexData; - VkDeviceSize vertexOffset; - uint32_t vertexCount; - VkDeviceSize vertexStride; - VkFormat vertexFormat; - VkBuffer indexData; - VkDeviceSize indexOffset; - uint32_t indexCount; - VkIndexType indexType; - VkBuffer transformData; - VkDeviceSize transformOffset; -} VkGeometryTrianglesNV; - -typedef struct VkGeometryAABBNV { - VkStructureType sType; - const void* pNext; - VkBuffer aabbData; - uint32_t numAABBs; - uint32_t stride; - VkDeviceSize offset; -} VkGeometryAABBNV; - -typedef struct VkGeometryDataNV { - VkGeometryTrianglesNV triangles; - VkGeometryAABBNV aabbs; -} VkGeometryDataNV; - -typedef struct VkGeometryNV { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkGeometryDataNV geometry; - VkGeometryFlagsKHR flags; -} VkGeometryNV; - -typedef struct VkAccelerationStructureInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeNV type; - VkBuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const VkGeometryNV* pGeometries; -} VkAccelerationStructureInfoNV; - -typedef struct VkAccelerationStructureCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceSize compactedSize; - VkAccelerationStructureInfoNV info; -} VkAccelerationStructureCreateInfoNV; - -typedef struct VkBindAccelerationStructureMemoryInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureNV accelerationStructure; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindAccelerationStructureMemoryInfoNV; - -typedef struct VkWriteDescriptorSetAccelerationStructureNV { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureNV* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureNV; - -typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureMemoryRequirementsTypeNV type; - VkAccelerationStructureNV accelerationStructure; -} VkAccelerationStructureMemoryRequirementsInfoNV; - -typedef struct VkPhysicalDeviceRayTracingPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; -} VkPhysicalDeviceRayTracingPropertiesNV; - -typedef struct VkTransformMatrixKHR { - float matrix[3][4]; -} VkTransformMatrixKHR; - -typedef VkTransformMatrixKHR VkTransformMatrixNV; - -typedef struct VkAabbPositionsKHR { - float minX; - float minY; - float minZ; - float maxX; - float maxY; - float maxZ; -} VkAabbPositionsKHR; - -typedef VkAabbPositionsKHR VkAabbPositionsNV; - -typedef struct VkAccelerationStructureInstanceKHR { - VkTransformMatrixKHR transform; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureInstanceKHR; - -typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); -typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure); - -VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( - VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); - -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( - VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV* pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode); - -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( - VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); - -VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - uint32_t shader); -#endif - - -#define VK_NV_representative_fragment_test 1 -#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2 -#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" -typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 representativeFragmentTest; -} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; - -typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 representativeFragmentTestEnable; -} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; - - - -#define VK_EXT_filter_cubic 1 -#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 -#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" -typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { - VkStructureType sType; - void* pNext; - VkImageViewType imageViewType; -} VkPhysicalDeviceImageViewImageFormatInfoEXT; - -typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 filterCubic; - VkBool32 filterCubicMinmax; -} VkFilterCubicImageViewImageFormatPropertiesEXT; - - - -#define VK_QCOM_render_pass_shader_resolve 1 -#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4 -#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve" - - -#define VK_EXT_global_priority 1 -#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 -#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" - -typedef enum VkQueueGlobalPriorityEXT { - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024, - VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF -} VkQueueGlobalPriorityEXT; -typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkQueueGlobalPriorityEXT globalPriority; -} VkDeviceQueueGlobalPriorityCreateInfoEXT; - - - -#define VK_EXT_external_memory_host 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" -typedef struct VkImportMemoryHostPointerInfoEXT { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; -} VkImportMemoryHostPointerInfoEXT; - -typedef struct VkMemoryHostPointerPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryHostPointerPropertiesEXT; - -typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize minImportedHostPointerAlignment; -} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); -#endif - - -#define VK_AMD_buffer_marker 1 -#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 -#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" -typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); -#endif - - -#define VK_AMD_pipeline_compiler_control 1 -#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1 -#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control" - -typedef enum VkPipelineCompilerControlFlagBitsAMD { - VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkPipelineCompilerControlFlagBitsAMD; -typedef VkFlags VkPipelineCompilerControlFlagsAMD; -typedef struct VkPipelineCompilerControlCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkPipelineCompilerControlFlagsAMD compilerControlFlags; -} VkPipelineCompilerControlCreateInfoAMD; - - - -#define VK_EXT_calibrated_timestamps 1 -#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 -#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" - -typedef enum VkTimeDomainEXT { - VK_TIME_DOMAIN_DEVICE_EXT = 0, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, - VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF -} VkTimeDomainEXT; -typedef struct VkCalibratedTimestampInfoEXT { - VkStructureType sType; - const void* pNext; - VkTimeDomainEXT timeDomain; -} VkCalibratedTimestampInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); -typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainEXT* pTimeDomains); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoEXT* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation); -#endif - - -#define VK_AMD_shader_core_properties 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2 -#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" -typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { - VkStructureType sType; - void* pNext; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; -} VkPhysicalDeviceShaderCorePropertiesAMD; - - - -#define VK_AMD_memory_overallocation_behavior 1 -#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 -#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" - -typedef enum VkMemoryOverallocationBehaviorAMD { - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF -} VkMemoryOverallocationBehaviorAMD; -typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkMemoryOverallocationBehaviorAMD overallocationBehavior; -} VkDeviceMemoryOverallocationCreateInfoAMD; - - - -#define VK_EXT_vertex_attribute_divisor 1 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" -typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -typedef struct VkVertexInputBindingDivisorDescriptionEXT { - uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescriptionEXT; - -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; - - - -#define VK_EXT_pipeline_creation_feedback 1 -#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback" - -typedef enum VkPipelineCreationFeedbackFlagBitsEXT { - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 0x00000001, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 0x00000002, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 0x00000004, - VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPipelineCreationFeedbackFlagBitsEXT; -typedef VkFlags VkPipelineCreationFeedbackFlagsEXT; -typedef struct VkPipelineCreationFeedbackEXT { - VkPipelineCreationFeedbackFlagsEXT flags; - uint64_t duration; -} VkPipelineCreationFeedbackEXT; - -typedef struct VkPipelineCreationFeedbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineCreationFeedbackEXT* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - VkPipelineCreationFeedbackEXT* pPipelineStageCreationFeedbacks; -} VkPipelineCreationFeedbackCreateInfoEXT; - - - -#define VK_NV_shader_subgroup_partitioned 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" - - -#define VK_NV_compute_shader_derivatives 1 -#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 -#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" -typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 computeDerivativeGroupQuads; - VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; - - - -#define VK_NV_mesh_shader 1 -#define VK_NV_MESH_SHADER_SPEC_VERSION 1 -#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" -typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 taskShader; - VkBool32 meshShader; -} VkPhysicalDeviceMeshShaderFeaturesNV; - -typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; -} VkPhysicalDeviceMeshShaderPropertiesNV; - -typedef struct VkDrawMeshTasksIndirectCommandNV { - uint32_t taskCount; - uint32_t firstTask; -} VkDrawMeshTasksIndirectCommandNV; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( - VkCommandBuffer commandBuffer, - uint32_t taskCount, - uint32_t firstTask); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - - -#define VK_NV_fragment_shader_barycentric 1 -#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" -typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderBarycentric; -} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; - - - -#define VK_NV_shader_image_footprint 1 -#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2 -#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" -typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 imageFootprint; -} VkPhysicalDeviceShaderImageFootprintFeaturesNV; - - - -#define VK_NV_scissor_exclusive 1 -#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1 -#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" -typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t exclusiveScissorCount; - const VkRect2D* pExclusiveScissors; -} VkPipelineViewportExclusiveScissorStateCreateInfoNV; - -typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 exclusiveScissor; -} VkPhysicalDeviceExclusiveScissorFeaturesNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D* pExclusiveScissors); -#endif - - -#define VK_NV_device_diagnostic_checkpoints 1 -#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 -#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" -typedef struct VkQueueFamilyCheckpointPropertiesNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags checkpointExecutionStageMask; -} VkQueueFamilyCheckpointPropertiesNV; - -typedef struct VkCheckpointDataNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlagBits stage; - void* pCheckpointMarker; -} VkCheckpointDataNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); -typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker); - -VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData); -#endif - - -#define VK_INTEL_shader_integer_functions2 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" -typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerFunctions2; -} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - - - -#define VK_INTEL_performance_query 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) -#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2 -#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query" - -typedef enum VkPerformanceConfigurationTypeINTEL { - VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, - VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceConfigurationTypeINTEL; - -typedef enum VkQueryPoolSamplingModeINTEL { - VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, - VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkQueryPoolSamplingModeINTEL; - -typedef enum VkPerformanceOverrideTypeINTEL { - VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, - VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, - VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceOverrideTypeINTEL; - -typedef enum VkPerformanceParameterTypeINTEL { - VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, - VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, - VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceParameterTypeINTEL; - -typedef enum VkPerformanceValueTypeINTEL { - VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, - VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, - VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, - VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, - VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, - VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceValueTypeINTEL; -typedef union VkPerformanceValueDataINTEL { - uint32_t value32; - uint64_t value64; - float valueFloat; - VkBool32 valueBool; - const char* valueString; -} VkPerformanceValueDataINTEL; - -typedef struct VkPerformanceValueINTEL { - VkPerformanceValueTypeINTEL type; - VkPerformanceValueDataINTEL data; -} VkPerformanceValueINTEL; - -typedef struct VkInitializePerformanceApiInfoINTEL { - VkStructureType sType; - const void* pNext; - void* pUserData; -} VkInitializePerformanceApiInfoINTEL; - -typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { - VkStructureType sType; - const void* pNext; - VkQueryPoolSamplingModeINTEL performanceCountersSampling; -} VkQueryPoolPerformanceQueryCreateInfoINTEL; - -typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; - -typedef struct VkPerformanceMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint64_t marker; -} VkPerformanceMarkerInfoINTEL; - -typedef struct VkPerformanceStreamMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint32_t marker; -} VkPerformanceStreamMarkerInfoINTEL; - -typedef struct VkPerformanceOverrideInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceOverrideTypeINTEL type; - VkBool32 enable; - uint64_t parameter; -} VkPerformanceOverrideInfoINTEL; - -typedef struct VkPerformanceConfigurationAcquireInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceConfigurationTypeINTEL type; -} VkPerformanceConfigurationAcquireInfoINTEL; - -typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); -typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); -typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); -typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); -typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL( - VkDevice device, - const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); - -VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL( - VkDevice device); - -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceMarkerInfoINTEL* pMarkerInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceOverrideInfoINTEL* pOverrideInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL( - VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, - VkPerformanceConfigurationINTEL* pConfiguration); - -VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL( - VkDevice device, - VkPerformanceConfigurationINTEL configuration); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL( - VkQueue queue, - VkPerformanceConfigurationINTEL configuration); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL( - VkDevice device, - VkPerformanceParameterTypeINTEL parameter, - VkPerformanceValueINTEL* pValue); -#endif - - -#define VK_EXT_pci_bus_info 1 -#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 -#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" -typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; -} VkPhysicalDevicePCIBusInfoPropertiesEXT; - - - -#define VK_AMD_display_native_hdr 1 -#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1 -#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr" -typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 localDimmingSupport; -} VkDisplayNativeHdrSurfaceCapabilitiesAMD; - -typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkBool32 localDimmingEnable; -} VkSwapchainDisplayNativeHdrCreateInfoAMD; - -typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD( - VkDevice device, - VkSwapchainKHR swapChain, - VkBool32 localDimmingEnable); -#endif - - -#define VK_EXT_fragment_density_map 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 2 -#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" -typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMap; - VkBool32 fragmentDensityMapDynamic; - VkBool32 fragmentDensityMapNonSubsampledImages; -} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentDensityTexelSize; - VkExtent2D maxFragmentDensityTexelSize; - VkBool32 fragmentDensityInvocations; -} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; - -typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkAttachmentReference fragmentDensityMapAttachment; -} VkRenderPassFragmentDensityMapCreateInfoEXT; - - - -#define VK_EXT_scalar_block_layout 1 -#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 -#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" -typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; - - - -#define VK_GOOGLE_hlsl_functionality1 1 -#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1 -#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" -#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION -#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME - - -#define VK_GOOGLE_decorate_string 1 -#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 -#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" - - -#define VK_EXT_subgroup_size_control 1 -#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 -#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" -typedef struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; -} VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; - -typedef struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; -} VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; - -typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT { - VkStructureType sType; - void* pNext; - uint32_t requiredSubgroupSize; -} VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; - - - -#define VK_AMD_shader_core_properties2 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2" - -typedef enum VkShaderCorePropertiesFlagBitsAMD { - VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderCorePropertiesFlagBitsAMD; -typedef VkFlags VkShaderCorePropertiesFlagsAMD; -typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { - VkStructureType sType; - void* pNext; - VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; -} VkPhysicalDeviceShaderCoreProperties2AMD; - - - -#define VK_AMD_device_coherent_memory 1 -#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 -#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" -typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 deviceCoherentMemory; -} VkPhysicalDeviceCoherentMemoryFeaturesAMD; - - - -#define VK_EXT_shader_image_atomic_int64 1 -#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 -#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" -typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderImageInt64Atomics; - VkBool32 sparseImageInt64Atomics; -} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - - - -#define VK_EXT_memory_budget 1 -#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 -#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" -typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; - VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryBudgetPropertiesEXT; - - - -#define VK_EXT_memory_priority 1 -#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1 -#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority" -typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 memoryPriority; -} VkPhysicalDeviceMemoryPriorityFeaturesEXT; - -typedef struct VkMemoryPriorityAllocateInfoEXT { - VkStructureType sType; - const void* pNext; - float priority; -} VkMemoryPriorityAllocateInfoEXT; - - - -#define VK_NV_dedicated_allocation_image_aliasing 1 -#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1 -#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing" -typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 dedicatedAllocationImageAliasing; -} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - - - -#define VK_EXT_buffer_device_address 1 -#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 -#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" -typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; - -typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; - -typedef struct VkBufferDeviceAddressCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceAddress deviceAddress; -} VkBufferDeviceAddressCreateInfoEXT; - -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); -#endif - - -#define VK_EXT_tooling_info 1 -#define VK_EXT_TOOLING_INFO_SPEC_VERSION 1 -#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info" - -typedef enum VkToolPurposeFlagBitsEXT { - VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 0x00000001, - VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 0x00000002, - VK_TOOL_PURPOSE_TRACING_BIT_EXT = 0x00000004, - VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 0x00000008, - VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 0x00000010, - VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, - VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, - VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkToolPurposeFlagBitsEXT; -typedef VkFlags VkToolPurposeFlagsEXT; -typedef struct VkPhysicalDeviceToolPropertiesEXT { - VkStructureType sType; - void* pNext; - char name[VK_MAX_EXTENSION_NAME_SIZE]; - char version[VK_MAX_EXTENSION_NAME_SIZE]; - VkToolPurposeFlagsEXT purposes; - char description[VK_MAX_DESCRIPTION_SIZE]; - char layer[VK_MAX_EXTENSION_NAME_SIZE]; -} VkPhysicalDeviceToolPropertiesEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolPropertiesEXT* pToolProperties); -#endif - - -#define VK_EXT_separate_stencil_usage 1 -#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 -#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" -typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; - - - -#define VK_EXT_validation_features 1 -#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 -#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" - -typedef enum VkValidationFeatureEnableEXT { - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, - VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, - VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, - VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, - VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureEnableEXT; - -typedef enum VkValidationFeatureDisableEXT { - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, - VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, - VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, - VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, - VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, - VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, - VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, - VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, - VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureDisableEXT; -typedef struct VkValidationFeaturesEXT { - VkStructureType sType; - const void* pNext; - uint32_t enabledValidationFeatureCount; - const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; -} VkValidationFeaturesEXT; - - - -#define VK_NV_cooperative_matrix 1 -#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 -#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" - -typedef enum VkComponentTypeNV { - VK_COMPONENT_TYPE_FLOAT16_NV = 0, - VK_COMPONENT_TYPE_FLOAT32_NV = 1, - VK_COMPONENT_TYPE_FLOAT64_NV = 2, - VK_COMPONENT_TYPE_SINT8_NV = 3, - VK_COMPONENT_TYPE_SINT16_NV = 4, - VK_COMPONENT_TYPE_SINT32_NV = 5, - VK_COMPONENT_TYPE_SINT64_NV = 6, - VK_COMPONENT_TYPE_UINT8_NV = 7, - VK_COMPONENT_TYPE_UINT16_NV = 8, - VK_COMPONENT_TYPE_UINT32_NV = 9, - VK_COMPONENT_TYPE_UINT64_NV = 10, - VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkComponentTypeNV; - -typedef enum VkScopeNV { - VK_SCOPE_DEVICE_NV = 1, - VK_SCOPE_WORKGROUP_NV = 2, - VK_SCOPE_SUBGROUP_NV = 3, - VK_SCOPE_QUEUE_FAMILY_NV = 5, - VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkScopeNV; -typedef struct VkCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeNV AType; - VkComponentTypeNV BType; - VkComponentTypeNV CType; - VkComponentTypeNV DType; - VkScopeNV scope; -} VkCooperativeMatrixPropertiesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesNV* pProperties); -#endif - - -#define VK_NV_coverage_reduction_mode 1 -#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1 -#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode" - -typedef enum VkCoverageReductionModeNV { - VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, - VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, - VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageReductionModeNV; -typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; -typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 coverageReductionMode; -} VkPhysicalDeviceCoverageReductionModeFeaturesNV; - -typedef struct VkPipelineCoverageReductionStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageReductionStateCreateFlagsNV flags; - VkCoverageReductionModeNV coverageReductionMode; -} VkPipelineCoverageReductionStateCreateInfoNV; - -typedef struct VkFramebufferMixedSamplesCombinationNV { - VkStructureType sType; - void* pNext; - VkCoverageReductionModeNV coverageReductionMode; - VkSampleCountFlagBits rasterizationSamples; - VkSampleCountFlags depthStencilSamples; - VkSampleCountFlags colorSamples; -} VkFramebufferMixedSamplesCombinationNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, - uint32_t* pCombinationCount, - VkFramebufferMixedSamplesCombinationNV* pCombinations); -#endif - - -#define VK_EXT_fragment_shader_interlock 1 -#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 -#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" -typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderSampleInterlock; - VkBool32 fragmentShaderPixelInterlock; - VkBool32 fragmentShaderShadingRateInterlock; -} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; - - - -#define VK_EXT_ycbcr_image_arrays 1 -#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 -#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" -typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcrImageArrays; -} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; - - - -#define VK_EXT_provoking_vertex 1 -#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1 -#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex" - -typedef enum VkProvokingVertexModeEXT { - VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, - VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, - VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkProvokingVertexModeEXT; -typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexLast; - VkBool32 transformFeedbackPreservesProvokingVertex; -} VkPhysicalDeviceProvokingVertexFeaturesEXT; - -typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexModePerPipeline; - VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; -} VkPhysicalDeviceProvokingVertexPropertiesEXT; - -typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkProvokingVertexModeEXT provokingVertexMode; -} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; - - - -#define VK_EXT_headless_surface 1 -#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 -#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" -typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; -typedef struct VkHeadlessSurfaceCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkHeadlessSurfaceCreateFlagsEXT flags; -} VkHeadlessSurfaceCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( - VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - - -#define VK_EXT_line_rasterization 1 -#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 -#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" - -typedef enum VkLineRasterizationModeEXT { - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, - VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkLineRasterizationModeEXT; -typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeaturesEXT; - -typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkLineRasterizationModeEXT lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); -#endif - - -#define VK_EXT_shader_atomic_float 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" -typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat32Atomics; - VkBool32 shaderBufferFloat32AtomicAdd; - VkBool32 shaderBufferFloat64Atomics; - VkBool32 shaderBufferFloat64AtomicAdd; - VkBool32 shaderSharedFloat32Atomics; - VkBool32 shaderSharedFloat32AtomicAdd; - VkBool32 shaderSharedFloat64Atomics; - VkBool32 shaderSharedFloat64AtomicAdd; - VkBool32 shaderImageFloat32Atomics; - VkBool32 shaderImageFloat32AtomicAdd; - VkBool32 sparseImageFloat32Atomics; - VkBool32 sparseImageFloat32AtomicAdd; -} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; - - - -#define VK_EXT_host_query_reset 1 -#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1 -#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset" -typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); -#endif - - -#define VK_EXT_index_type_uint8 1 -#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 -#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" -typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; - - - -#define VK_EXT_extended_dynamic_state 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" -typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState; -} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp); -#endif - - -#define VK_EXT_shader_atomic_float2 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2" -typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat16Atomics; - VkBool32 shaderBufferFloat16AtomicAdd; - VkBool32 shaderBufferFloat16AtomicMinMax; - VkBool32 shaderBufferFloat32AtomicMinMax; - VkBool32 shaderBufferFloat64AtomicMinMax; - VkBool32 shaderSharedFloat16Atomics; - VkBool32 shaderSharedFloat16AtomicAdd; - VkBool32 shaderSharedFloat16AtomicMinMax; - VkBool32 shaderSharedFloat32AtomicMinMax; - VkBool32 shaderSharedFloat64AtomicMinMax; - VkBool32 shaderImageFloat32AtomicMinMax; - VkBool32 sparseImageFloat32AtomicMinMax; -} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; - - - -#define VK_EXT_shader_demote_to_helper_invocation 1 -#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 -#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" -typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderDemoteToHelperInvocation; -} VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; - - - -#define VK_NV_device_generated_commands 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) -#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 -#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands" - -typedef enum VkIndirectCommandsTokenTypeNV { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsTokenTypeNV; - -typedef enum VkIndirectStateFlagBitsNV { - VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, - VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectStateFlagBitsNV; -typedef VkFlags VkIndirectStateFlagsNV; - -typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsLayoutUsageFlagBitsNV; -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxGraphicsShaderGroupCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsStreamCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsStreamStride; - uint32_t minSequencesCountBufferOffsetAlignment; - uint32_t minSequencesIndexBufferOffsetAlignment; - uint32_t minIndirectCommandsBufferOffsetAlignment; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCommands; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - -typedef struct VkGraphicsShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; -} VkGraphicsShaderGroupCreateInfoNV; - -typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t groupCount; - const VkGraphicsShaderGroupCreateInfoNV* pGroups; - uint32_t pipelineCount; - const VkPipeline* pPipelines; -} VkGraphicsPipelineShaderGroupsCreateInfoNV; - -typedef struct VkBindShaderGroupIndirectCommandNV { - uint32_t groupIndex; -} VkBindShaderGroupIndirectCommandNV; - -typedef struct VkBindIndexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - VkIndexType indexType; -} VkBindIndexBufferIndirectCommandNV; - -typedef struct VkBindVertexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - uint32_t stride; -} VkBindVertexBufferIndirectCommandNV; - -typedef struct VkSetStateFlagsIndirectCommandNV { - uint32_t data; -} VkSetStateFlagsIndirectCommandNV; - -typedef struct VkIndirectCommandsStreamNV { - VkBuffer buffer; - VkDeviceSize offset; -} VkIndirectCommandsStreamNV; - -typedef struct VkIndirectCommandsLayoutTokenNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsTokenTypeNV tokenType; - uint32_t stream; - uint32_t offset; - uint32_t vertexBindingUnit; - VkBool32 vertexDynamicStride; - VkPipelineLayout pushconstantPipelineLayout; - VkShaderStageFlags pushconstantShaderStageFlags; - uint32_t pushconstantOffset; - uint32_t pushconstantSize; - VkIndirectStateFlagsNV indirectStateFlags; - uint32_t indexTypeCount; - const VkIndexType* pIndexTypes; - const uint32_t* pIndexTypeValues; -} VkIndirectCommandsLayoutTokenNV; - -typedef struct VkIndirectCommandsLayoutCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsLayoutUsageFlagsNV flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t tokenCount; - const VkIndirectCommandsLayoutTokenNV* pTokens; - uint32_t streamCount; - const uint32_t* pStreamStrides; -} VkIndirectCommandsLayoutCreateInfoNV; - -typedef struct VkGeneratedCommandsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t streamCount; - const VkIndirectCommandsStreamNV* pStreams; - uint32_t sequencesCount; - VkBuffer preprocessBuffer; - VkDeviceSize preprocessOffset; - VkDeviceSize preprocessSize; - VkBuffer sequencesCountBuffer; - VkDeviceSize sequencesCountOffset; - VkBuffer sequencesIndexBuffer; - VkDeviceSize sequencesIndexOffset; -} VkGeneratedCommandsInfoNV; - -typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t maxSequencesCount; -} VkGeneratedCommandsMemoryRequirementsInfoNV; - -typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV( - VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); -#endif - - -#define VK_NV_inherited_viewport_scissor 1 -#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1 -#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor" -typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 inheritedViewportScissor2D; -} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; - -typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportScissor2D; - uint32_t viewportDepthCount; - const VkViewport* pViewportDepths; -} VkCommandBufferInheritanceViewportScissorInfoNV; - - - -#define VK_EXT_texel_buffer_alignment 1 -#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 -#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" -typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 texelBufferAlignment; -} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; - -typedef struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; -} VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; - - - -#define VK_QCOM_render_pass_transform 1 -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2 -#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" -typedef struct VkRenderPassTransformBeginInfoQCOM { - VkStructureType sType; - void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkRenderPassTransformBeginInfoQCOM; - -typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { - VkStructureType sType; - void* pNext; - VkSurfaceTransformFlagBitsKHR transform; - VkRect2D renderArea; -} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; - - - -#define VK_EXT_device_memory_report 1 -#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2 -#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report" - -typedef enum VkDeviceMemoryReportEventTypeEXT { - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceMemoryReportEventTypeEXT; -typedef VkFlags VkDeviceMemoryReportFlagsEXT; -typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceMemoryReport; -} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; - -typedef struct VkDeviceMemoryReportCallbackDataEXT { - VkStructureType sType; - void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - VkDeviceMemoryReportEventTypeEXT type; - uint64_t memoryObjectId; - VkDeviceSize size; - VkObjectType objectType; - uint64_t objectHandle; - uint32_t heapIndex; -} VkDeviceMemoryReportCallbackDataEXT; - -typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( - const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; - void* pUserData; -} VkDeviceDeviceMemoryReportCreateInfoEXT; - - - -#define VK_EXT_acquire_drm_display 1 -#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - uint32_t connectorId, - VkDisplayKHR* display); -#endif - - -#define VK_EXT_robustness2 1 -#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 -#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" -typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 robustBufferAccess2; - VkBool32 robustImageAccess2; - VkBool32 nullDescriptor; -} VkPhysicalDeviceRobustness2FeaturesEXT; - -typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize robustStorageBufferAccessSizeAlignment; - VkDeviceSize robustUniformBufferAccessSizeAlignment; -} VkPhysicalDeviceRobustness2PropertiesEXT; - - - -#define VK_EXT_custom_border_color 1 -#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 -#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" -typedef struct VkSamplerCustomBorderColorCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkClearColorValue customBorderColor; - VkFormat format; -} VkSamplerCustomBorderColorCreateInfoEXT; - -typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxCustomBorderColorSamplers; -} VkPhysicalDeviceCustomBorderColorPropertiesEXT; - -typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 customBorderColors; - VkBool32 customBorderColorWithoutFormat; -} VkPhysicalDeviceCustomBorderColorFeaturesEXT; - - - -#define VK_GOOGLE_user_type 1 -#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1 -#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" - - -#define VK_EXT_private_data 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlotEXT) -#define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1 -#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data" - -typedef enum VkPrivateDataSlotCreateFlagBitsEXT { - VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPrivateDataSlotCreateFlagBitsEXT; -typedef VkFlags VkPrivateDataSlotCreateFlagsEXT; -typedef struct VkPhysicalDevicePrivateDataFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 privateData; -} VkPhysicalDevicePrivateDataFeaturesEXT; - -typedef struct VkDevicePrivateDataCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t privateDataSlotRequestCount; -} VkDevicePrivateDataCreateInfoEXT; - -typedef struct VkPrivateDataSlotCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPrivateDataSlotCreateFlagsEXT flags; -} VkPrivateDataSlotCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot); -typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data); -typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT( - VkDevice device, - const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlotEXT* pPrivateDataSlot); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT( - VkDevice device, - VkPrivateDataSlotEXT privateDataSlot, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, - uint64_t data); - -VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlotEXT privateDataSlot, - uint64_t* pData); -#endif - - -#define VK_EXT_pipeline_creation_cache_control 1 -#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3 -#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control" -typedef struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelineCreationCacheControl; -} VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; - - - -#define VK_NV_device_diagnostics_config 1 -#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1 -#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" - -typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, - VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkDeviceDiagnosticsConfigFlagBitsNV; -typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; -typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 diagnosticsConfig; -} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; - -typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceDiagnosticsConfigFlagsNV flags; -} VkDeviceDiagnosticsConfigCreateInfoNV; - - - -#define VK_QCOM_render_pass_store_ops 1 -#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2 -#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" - - -#define VK_NV_fragment_shading_rate_enums 1 -#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums" - -typedef enum VkFragmentShadingRateTypeNV { - VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, - VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, - VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateTypeNV; - -typedef enum VkFragmentShadingRateNV { - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, - VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, - VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, - VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, - VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, - VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, - VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateNV; -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShadingRateEnums; - VkBool32 supersampleFragmentShadingRates; - VkBool32 noInvocationFragmentShadingRates; -} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { - VkStructureType sType; - void* pNext; - VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; -} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - -typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkFragmentShadingRateTypeNV shadingRateType; - VkFragmentShadingRateNV shadingRate; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV( - VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -#endif - - -#define VK_NV_ray_tracing_motion_blur 1 -#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1 -#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur" - -typedef enum VkAccelerationStructureMotionInstanceTypeNV { - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMotionInstanceTypeNV; -typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; -typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; -typedef union VkDeviceOrHostAddressConstKHR { - VkDeviceAddress deviceAddress; - const void* hostAddress; -} VkDeviceOrHostAddressConstKHR; - -typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR vertexData; -} VkAccelerationStructureGeometryMotionTrianglesDataNV; - -typedef struct VkAccelerationStructureMotionInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t maxInstances; - VkAccelerationStructureMotionInfoFlagsNV flags; -} VkAccelerationStructureMotionInfoNV; - -typedef struct VkAccelerationStructureMatrixMotionInstanceNV { - VkTransformMatrixKHR transformT0; - VkTransformMatrixKHR transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureMatrixMotionInstanceNV; - -typedef struct VkSRTDataNV { - float sx; - float a; - float b; - float pvx; - float sy; - float c; - float pvy; - float sz; - float pvz; - float qx; - float qy; - float qz; - float qw; - float tx; - float ty; - float tz; -} VkSRTDataNV; - -typedef struct VkAccelerationStructureSRTMotionInstanceNV { - VkSRTDataNV transformT0; - VkSRTDataNV transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureSRTMotionInstanceNV; - -typedef union VkAccelerationStructureMotionInstanceDataNV { - VkAccelerationStructureInstanceKHR staticInstance; - VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; - VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; -} VkAccelerationStructureMotionInstanceDataNV; - -typedef struct VkAccelerationStructureMotionInstanceNV { - VkAccelerationStructureMotionInstanceTypeNV type; - VkAccelerationStructureMotionInstanceFlagsNV flags; - VkAccelerationStructureMotionInstanceDataNV data; -} VkAccelerationStructureMotionInstanceNV; - -typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingMotionBlur; - VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; -} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; - - - -#define VK_EXT_ycbcr_2plane_444_formats 1 -#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 -#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" -typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcr2plane444Formats; -} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - - - -#define VK_EXT_fragment_density_map2 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2" -typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapDeferred; -} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subsampledLoads; - VkBool32 subsampledCoarseReconstructionEarlyAccess; - uint32_t maxSubsampledArrayLayers; - uint32_t maxDescriptorSetSubsampledSamplers; -} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; - - - -#define VK_QCOM_rotated_copy_commands 1 -#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1 -#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" -typedef struct VkCopyCommandTransformInfoQCOM { - VkStructureType sType; - const void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkCopyCommandTransformInfoQCOM; - - - -#define VK_EXT_image_robustness 1 -#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 -#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" -typedef struct VkPhysicalDeviceImageRobustnessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; -} VkPhysicalDeviceImageRobustnessFeaturesEXT; - - - -#define VK_EXT_4444_formats 1 -#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 -#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" -typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatA4R4G4B4; - VkBool32 formatA4B4G4R4; -} VkPhysicalDevice4444FormatsFeaturesEXT; - - - -#define VK_EXT_rgba10x6_formats 1 -#define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1 -#define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats" -typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatRgba10x6WithoutYCbCrSampler; -} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; - - - -#define VK_NV_acquire_winrt_display 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay); -#endif - - -#define VK_VALVE_mutable_descriptor_type 1 -#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 -#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" -typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE { - VkStructureType sType; - void* pNext; - VkBool32 mutableDescriptorType; -} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; - -typedef struct VkMutableDescriptorTypeListVALVE { - uint32_t descriptorTypeCount; - const VkDescriptorType* pDescriptorTypes; -} VkMutableDescriptorTypeListVALVE; - -typedef struct VkMutableDescriptorTypeCreateInfoVALVE { - VkStructureType sType; - const void* pNext; - uint32_t mutableDescriptorTypeListCount; - const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists; -} VkMutableDescriptorTypeCreateInfoVALVE; - - - -#define VK_EXT_vertex_input_dynamic_state 1 -#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 -#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" -typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexInputDynamicState; -} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; - -typedef struct VkVertexInputBindingDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; - uint32_t divisor; -} VkVertexInputBindingDescription2EXT; - -typedef struct VkVertexInputAttributeDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription2EXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( - VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); -#endif - - -#define VK_EXT_physical_device_drm 1 -#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1 -#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm" -typedef struct VkPhysicalDeviceDrmPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 hasPrimary; - VkBool32 hasRender; - int64_t primaryMajor; - int64_t primaryMinor; - int64_t renderMajor; - int64_t renderMinor; -} VkPhysicalDeviceDrmPropertiesEXT; - - - -#define VK_EXT_primitive_topology_list_restart 1 -#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1 -#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" -typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 primitiveTopologyListRestart; - VkBool32 primitiveTopologyPatchListRestart; -} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - - - -#define VK_HUAWEI_subpass_shading 1 -#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2 -#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" -typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { - VkStructureType sType; - void* pNext; - VkRenderPass renderPass; - uint32_t subpass; -} VkSubpassShadingPipelineCreateInfoHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 subpassShading; -} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { - VkStructureType sType; - void* pNext; - uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; -} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; - -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); -typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - VkDevice device, - VkRenderPass renderpass, - VkExtent2D* pMaxWorkgroupSize); - -VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI( - VkCommandBuffer commandBuffer); -#endif - - -#define VK_HUAWEI_invocation_mask 1 -#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 -#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask" -typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 invocationMask; -} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; - -typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); -#endif - - -#define VK_NV_external_memory_rdma 1 -typedef void* VkRemoteAddressNV; -#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma" -typedef struct VkMemoryGetRemoteAddressInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetRemoteAddressInfoNV; - -typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 externalMemoryRDMA; -} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( - VkDevice device, - const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV* pAddress); -#endif - - -#define VK_EXT_extended_dynamic_state2 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" -typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState2; - VkBool32 extendedDynamicState2LogicOp; - VkBool32 extendedDynamicState2PatchControlPoints; -} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); -typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable); -#endif - - -#define VK_EXT_color_write_enable 1 -#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 -#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" -typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 colorWriteEnable; -} VkPhysicalDeviceColorWriteEnableFeaturesEXT; - -typedef struct VkPipelineColorWriteCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkBool32* pColorWriteEnables; -} VkPipelineColorWriteCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables); -#endif - - -#define VK_EXT_global_priority_query 1 -#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT 16U -#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1 -#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query" -typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 globalPriorityQuery; -} VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; - -typedef struct VkQueueFamilyGlobalPriorityPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t priorityCount; - VkQueueGlobalPriorityEXT priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT]; -} VkQueueFamilyGlobalPriorityPropertiesEXT; - - - -#define VK_EXT_multi_draw 1 -#define VK_EXT_MULTI_DRAW_SPEC_VERSION 1 -#define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw" -typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 multiDraw; -} VkPhysicalDeviceMultiDrawFeaturesEXT; - -typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxMultiDrawCount; -} VkPhysicalDeviceMultiDrawPropertiesEXT; - -typedef struct VkMultiDrawInfoEXT { - uint32_t firstVertex; - uint32_t vertexCount; -} VkMultiDrawInfoEXT; - -typedef struct VkMultiDrawIndexedInfoEXT { - uint32_t firstIndex; - uint32_t indexCount; - int32_t vertexOffset; -} VkMultiDrawIndexedInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT* pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT* pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t* pVertexOffset); -#endif - - -#define VK_EXT_load_store_op_none 1 -#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 -#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" - - -#define VK_EXT_border_color_swizzle 1 -#define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 -#define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" -typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 borderColorSwizzle; - VkBool32 borderColorSwizzleFromImage; -} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; - -typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkComponentMapping components; - VkBool32 srgb; -} VkSamplerBorderColorComponentMappingCreateInfoEXT; - - - -#define VK_EXT_pageable_device_local_memory 1 -#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1 -#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory" -typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pageableDeviceLocalMemory; -} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( - VkDevice device, - VkDeviceMemory memory, - float priority); -#endif - - -#define VK_KHR_acceleration_structure 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) -#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 -#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" - -typedef enum VkBuildAccelerationStructureModeKHR { - VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureModeKHR; - -typedef enum VkAccelerationStructureBuildTypeKHR { - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureBuildTypeKHR; - -typedef enum VkAccelerationStructureCompatibilityKHR { - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCompatibilityKHR; - -typedef enum VkAccelerationStructureCreateFlagBitsKHR { - VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, - VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, - VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCreateFlagBitsKHR; -typedef VkFlags VkAccelerationStructureCreateFlagsKHR; -typedef union VkDeviceOrHostAddressKHR { - VkDeviceAddress deviceAddress; - void* hostAddress; -} VkDeviceOrHostAddressKHR; - -typedef struct VkAccelerationStructureBuildRangeInfoKHR { - uint32_t primitiveCount; - uint32_t primitiveOffset; - uint32_t firstVertex; - uint32_t transformOffset; -} VkAccelerationStructureBuildRangeInfoKHR; - -typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { - VkStructureType sType; - const void* pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR vertexData; - VkDeviceSize vertexStride; - uint32_t maxVertex; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexData; - VkDeviceOrHostAddressConstKHR transformData; -} VkAccelerationStructureGeometryTrianglesDataKHR; - -typedef struct VkAccelerationStructureGeometryAabbsDataKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR data; - VkDeviceSize stride; -} VkAccelerationStructureGeometryAabbsDataKHR; - -typedef struct VkAccelerationStructureGeometryInstancesDataKHR { - VkStructureType sType; - const void* pNext; - VkBool32 arrayOfPointers; - VkDeviceOrHostAddressConstKHR data; -} VkAccelerationStructureGeometryInstancesDataKHR; - -typedef union VkAccelerationStructureGeometryDataKHR { - VkAccelerationStructureGeometryTrianglesDataKHR triangles; - VkAccelerationStructureGeometryAabbsDataKHR aabbs; - VkAccelerationStructureGeometryInstancesDataKHR instances; -} VkAccelerationStructureGeometryDataKHR; - -typedef struct VkAccelerationStructureGeometryKHR { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkAccelerationStructureGeometryDataKHR geometry; - VkGeometryFlagsKHR flags; -} VkAccelerationStructureGeometryKHR; - -typedef struct VkAccelerationStructureBuildGeometryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeKHR type; - VkBuildAccelerationStructureFlagsKHR flags; - VkBuildAccelerationStructureModeKHR mode; - VkAccelerationStructureKHR srcAccelerationStructure; - VkAccelerationStructureKHR dstAccelerationStructure; - uint32_t geometryCount; - const VkAccelerationStructureGeometryKHR* pGeometries; - const VkAccelerationStructureGeometryKHR* const* ppGeometries; - VkDeviceOrHostAddressKHR scratchData; -} VkAccelerationStructureBuildGeometryInfoKHR; - -typedef struct VkAccelerationStructureCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureCreateFlagsKHR createFlags; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; - VkAccelerationStructureTypeKHR type; - VkDeviceAddress deviceAddress; -} VkAccelerationStructureCreateInfoKHR; - -typedef struct VkWriteDescriptorSetAccelerationStructureKHR { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureKHR* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureKHR; - -typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 accelerationStructure; - VkBool32 accelerationStructureCaptureReplay; - VkBool32 accelerationStructureIndirectBuild; - VkBool32 accelerationStructureHostCommands; - VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; -} VkPhysicalDeviceAccelerationStructureFeaturesKHR; - -typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { - VkStructureType sType; - void* pNext; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxPrimitiveCount; - uint32_t maxPerStageDescriptorAccelerationStructures; - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; - uint32_t maxDescriptorSetAccelerationStructures; - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; - uint32_t minAccelerationStructureScratchOffsetAlignment; -} VkPhysicalDeviceAccelerationStructurePropertiesKHR; - -typedef struct VkAccelerationStructureDeviceAddressInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR accelerationStructure; -} VkAccelerationStructureDeviceAddressInfoKHR; - -typedef struct VkAccelerationStructureVersionInfoKHR { - VkStructureType sType; - const void* pNext; - const uint8_t* pVersionData; -} VkAccelerationStructureVersionInfoKHR; - -typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkDeviceOrHostAddressKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureToMemoryInfoKHR; - -typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyMemoryToAccelerationStructureInfoKHR; - -typedef struct VkCopyAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureInfoKHR; - -typedef struct VkAccelerationStructureBuildSizesInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceSize accelerationStructureSize; - VkDeviceSize updateScratchSize; - VkDeviceSize buildScratchSize; -} VkAccelerationStructureBuildSizesInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); -typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); -typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( - VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure); - -VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); - -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkDeviceAddress* pIndirectDeviceAddresses, - const uint32_t* pIndirectStrides, - const uint32_t* const* ppMaxPrimitiveCounts); - -VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( - VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); - -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility); - -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -#endif - - -#define VK_KHR_ray_tracing_pipeline 1 -#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1 -#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline" - -typedef enum VkShaderGroupShaderKHR { - VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, - VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, - VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, - VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, - VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF -} VkShaderGroupShaderKHR; -typedef struct VkRayTracingShaderGroupCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - const void* pShaderGroupCaptureReplayHandle; -} VkRayTracingShaderGroupCreateInfoKHR; - -typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxPipelineRayPayloadSize; - uint32_t maxPipelineRayHitAttributeSize; -} VkRayTracingPipelineInterfaceCreateInfoKHR; - -typedef struct VkRayTracingPipelineCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoKHR* pGroups; - uint32_t maxPipelineRayRecursionDepth; - const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; - const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingPipeline; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - VkBool32 rayTracingPipelineTraceRaysIndirect; - VkBool32 rayTraversalPrimitiveCulling; -} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRayRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint32_t shaderGroupHandleCaptureReplaySize; - uint32_t maxRayDispatchInvocationCount; - uint32_t shaderGroupHandleAlignment; - uint32_t maxRayHitAttributeSize; -} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; - -typedef struct VkStridedDeviceAddressRegionKHR { - VkDeviceAddress deviceAddress; - VkDeviceSize stride; - VkDeviceSize size; -} VkStridedDeviceAddressRegionKHR; - -typedef struct VkTraceRaysIndirectCommandKHR { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkTraceRaysIndirectCommandKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); -typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); -typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress); - -VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR( - VkCommandBuffer commandBuffer, - uint32_t pipelineStackSize); -#endif - - -#define VK_KHR_ray_query 1 -#define VK_KHR_RAY_QUERY_SPEC_VERSION 1 -#define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query" -typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayQuery; -} VkPhysicalDeviceRayQueryFeaturesKHR; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/vulkan/vulkan_win32.h b/include/vulkan/vulkan_win32.h deleted file mode 100644 index 1b680f0b..00000000 --- a/include/vulkan/vulkan_win32.h +++ /dev/null @@ -1,315 +0,0 @@ -#ifndef VULKAN_WIN32_H_ -#define VULKAN_WIN32_H_ 1 - -/* -** Copyright 2015-2021 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** 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_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 diff --git a/lib/d3dcompiler_43.lib b/lib/d3dcompiler_43.lib deleted file mode 100644 index 201bab8a..00000000 Binary files a/lib/d3dcompiler_43.lib and /dev/null differ diff --git a/lib/libd3dcompiler_43.def b/lib/libd3dcompiler_43.def deleted file mode 100644 index 344fbe0d..00000000 --- a/lib/libd3dcompiler_43.def +++ /dev/null @@ -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 diff --git a/lib/vulkan-1.lib b/lib/vulkan-1.lib deleted file mode 100755 index 3c6574a9..00000000 Binary files a/lib/vulkan-1.lib and /dev/null differ diff --git a/lib32/d3dcompiler_43.lib b/lib32/d3dcompiler_43.lib deleted file mode 100644 index d5578505..00000000 Binary files a/lib32/d3dcompiler_43.lib and /dev/null differ diff --git a/lib32/libd3dcompiler_43.def b/lib32/libd3dcompiler_43.def deleted file mode 100644 index 22d78e63..00000000 --- a/lib32/libd3dcompiler_43.def +++ /dev/null @@ -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 diff --git a/lib32/vulkan-1.lib b/lib32/vulkan-1.lib deleted file mode 100755 index db227fd3..00000000 Binary files a/lib32/vulkan-1.lib and /dev/null differ diff --git a/meson.build b/meson.build index 13b1edd8..724b3aee 100644 --- a/meson.build +++ b/meson.build @@ -1,40 +1,31 @@ -project('dxvk', ['c', 'cpp'], version : 'v1.10.1', meson_version : '>= 0.49', default_options : [ 'cpp_std=c++17' ]) +project('dxvk', ['c', 'cpp'], version : 'v2.2', meson_version : '>= 0.49', default_options : [ 'cpp_std=c++17', 'warning_level=2' ]) cpu_family = target_machine.cpu_family() +platform = target_machine.system() cpp = meson.get_compiler('cpp') cc = meson.get_compiler('c') dxvk_is_msvc = cpp.get_id() == 'msvc' compiler_args = [ - '-DNOMINMAX', - '-D_WIN32_WINNT=0xa00', '-msse', '-msse2', '-msse3', '-mfpmath=sse', '-Wimplicit-fallthrough', + # gcc + '-Wno-missing-field-initializers', + '-Wno-unused-parameter', + '-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 = [ - '-static', - '-static-libgcc', - '-static-libstdc++', - # We need to set the section alignment for debug symbols to - # work properly as well as avoiding a memcpy from the Wine loader. - '-Wl,--file-alignment=4096', -] - -# Wine's built-in back traces only work with dwarf2 symbols -if get_option('debug') and target_machine.system() == 'windows' - compiler_args += [ - '-gstrict-dwarf', - '-gdwarf-2', - ] -endif +link_args = [] if get_option('build_id') link_args += [ @@ -42,71 +33,129 @@ if get_option('build_id') ] endif -if cpu_family == 'x86' +dxvk_include_dirs = [ + './include', + './include/vulkan/include', + './include/spirv/include' +] + +proj_displayinfo = subproject('libdisplay-info') +dep_displayinfo = proj_displayinfo.get_variable('di_dep') + +if platform == 'windows' + compiler_args += [ + '-DNOMINMAX', + '-D_WIN32_WINNT=0xa00', + ] + link_args += [ - '-Wl,--enable-stdcall-fixup', - '-Wl,--add-stdcall-alias', + '-static', + '-static-libgcc', + '-static-libstdc++', + # We need to set the section alignment for debug symbols to + # work properly as well as avoiding a memcpy from the Wine loader. + '-Wl,--file-alignment=4096', + ] + + # Wine's built-in back traces only work with dwarf4 symbols + if get_option('debug') + compiler_args += [ + '-gdwarf-4', + ] + endif + + # Enable stdcall fixup on 32-bit + if cpu_family == 'x86' + link_args += [ + '-Wl,--enable-stdcall-fixup', + '-Wl,--kill-at', + ] + endif + + lib_d3d9 = cpp.find_library('d3d9') + lib_d3d11 = cpp.find_library('d3d11') + lib_dxgi = cpp.find_library('dxgi') + + if dxvk_is_msvc + lib_d3dcompiler_47 = cpp.find_library('d3dcompiler') + else + lib_d3dcompiler_47 = cpp.find_library('d3dcompiler_47') + endif + + 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 + + dxvk_wsi = 'win32' + dxvk_name_prefix = '' + compiler_args += ['-DDXVK_WSI_WIN32'] +else + 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' + ] + + dxvk_wsi = get_option('dxvk_native_wsi') + + if dxvk_wsi == 'sdl2' + lib_sdl2 = cpp.find_library('SDL2') + compiler_args += ['-DDXVK_WSI_SDL2'] + elif dxvk_wsi == 'glfw' + lib_glfw = cpp.find_library('glfw') + compiler_args += ['-DDXVK_WSI_GLFW'] + endif + + dxvk_name_prefix = 'libdxvk_' + + 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') -dxvk_include_path = include_directories('./include') - -if (cpu_family == 'x86_64') - dxvk_library_path = meson.source_root() + '/lib' -else - dxvk_library_path = meson.source_root() + '/lib32' -endif - -dxvk_extradep = [ ] - -lib_vulkan = cpp.find_library('vulkan-1', dirs : dxvk_library_path) -lib_d3d9 = cpp.find_library('d3d9') -lib_d3d11 = cpp.find_library('d3d11') -lib_dxgi = cpp.find_library('dxgi') -lib_d3dcompiler_43 = cpp.find_library('d3dcompiler_43', dirs : dxvk_library_path) - -if dxvk_is_msvc - lib_d3dcompiler_47 = cpp.find_library('d3dcompiler') -else - lib_d3dcompiler_47 = cpp.find_library('d3dcompiler_47') -endif - exe_ext = '' dll_ext = '' - def_spec_ext = '.def' -glsl_compiler = find_program('glslangValidator') -glsl_args = [ '-V', '--vn', '@BASENAME@', '@INPUT@', '-o', '@OUTPUT@' ] -if run_command(glsl_compiler, [ '--quiet', '--version' ], check : false).returncode() == 0 - glsl_args += [ '--quiet' ] -endif -glsl_generator = generator(glsl_compiler, +glsl_compiler = find_program('glslang', 'glslangValidator') +glsl_args = [ + '--quiet', + '--target-env', 'vulkan1.2', + '--vn', '@BASENAME@', + '--depfile', '@DEPFILE@', + '@INPUT@', + '-o', '@OUTPUT@', +] +glsl_generator = generator( + glsl_compiler, output : [ '@BASENAME@.h' ], + depfile : '@BASENAME@.h.d', arguments : glsl_args, ) -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 - dxvk_version = vcs_tag( command: ['git', 'describe', '--dirty=+'], input: 'version.h.in', @@ -114,9 +163,3 @@ dxvk_version = vcs_tag( ) subdir('src') - -enable_tests = get_option('enable_tests') - -if enable_tests - subdir('tests') -endif diff --git a/meson_options.txt b/meson_options.txt index 6af1f6b7..5ac9ea7b 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -1,6 +1,7 @@ -option('enable_tests', type : 'boolean', value : false) option('enable_dxgi', type : 'boolean', value : true, description: 'Build DXGI') 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.') \ No newline at end of file diff --git a/package-native.sh b/package-native.sh new file mode 100755 index 00000000..3ef65943 --- /dev/null +++ b/package-native.sh @@ -0,0 +1,88 @@ +#!/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 + +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 + ;; + *) + 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 \ + "$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" +} + +build_arch 64 lib +build_arch 32 lib32 + +if [ $opt_nopackage -eq 0 ]; then + package +fi diff --git a/package-release.sh b/package-release.sh index 9318226c..0db4fa75 100755 --- a/package-release.sh +++ b/package-release.sh @@ -10,7 +10,8 @@ if [ -z "$1" ] || [ -z "$2" ]; then fi DXVK_VERSION="$1" -DXVK_SRC_DIR=`dirname $(readlink -f $0)` +DXVK_SRC_DIR=$(readlink -f "$0") +DXVK_SRC_DIR=$(dirname "$DXVK_SRC_DIR") DXVK_BUILD_DIR=$(realpath "$2")"/dxvk-$DXVK_VERSION" DXVK_ARCHIVE_PATH=$(realpath "$2")"/dxvk-$DXVK_VERSION.tar.gz" @@ -57,14 +58,13 @@ function build_arch { opt_strip=--strip fi - meson --cross-file "$DXVK_SRC_DIR/$crossfile$1.txt" \ - --buildtype "release" \ - --prefix "$DXVK_BUILD_DIR" \ - $opt_strip \ - --bindir "x$1" \ - --libdir "x$1" \ - -Denable_tests=false \ - -Dbuild_id=$opt_buildid \ + meson setup --cross-file "$DXVK_SRC_DIR/$crossfile$1.txt" \ + --buildtype "release" \ + --prefix "$DXVK_BUILD_DIR" \ + $opt_strip \ + --bindir "x$1" \ + --libdir "x$1" \ + -Dbuild_id=$opt_buildid \ "$DXVK_BUILD_DIR/build.$1" cd "$DXVK_BUILD_DIR/build.$1" @@ -77,11 +77,6 @@ function build_arch { fi } -function build_script { - cp "$DXVK_SRC_DIR/setup_dxvk.sh" "$DXVK_BUILD_DIR/setup_dxvk.sh" - chmod +x "$DXVK_BUILD_DIR/setup_dxvk.sh" -} - function package { cd "$DXVK_BUILD_DIR/.." tar -czf "$DXVK_ARCHIVE_PATH" "dxvk-$DXVK_VERSION" @@ -90,7 +85,6 @@ function package { build_arch 64 build_arch 32 -build_script if [ $opt_nopackage -eq 0 ]; then package diff --git a/setup_dxvk.sh b/setup_dxvk.sh deleted file mode 100755 index 3e63ecf0..00000000 --- a/setup_dxvk.sh +++ /dev/null @@ -1,216 +0,0 @@ -#!/usr/bin/env bash - -# default directories -dxvk_lib32=${dxvk_lib32:-"x32"} -dxvk_lib64=${dxvk_lib64:-"x64"} - -# figure out where we are -basedir=$(dirname "$(readlink -f $0)") - -# figure out which action to perform -action="$1" - -case "$action" in -install) - ;; -uninstall) - ;; -*) - echo "Unrecognized action: $action" - echo "Usage: $0 [install|uninstall] [--without-dxgi] [--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 -# disable mscoree and mshtml to avoid downloading -# wine gecko and mono -export WINEDLLOVERRIDES="mscoree,mshtml=" - -wine="wine" -wine64="wine64" -wineboot="wineboot" - -# $PATH is the way for user to control where wine is located (including custom Wine versions). -# Pure 64-bit Wine (non Wow64) requries skipping 32-bit steps. -# In such case, wine64 and winebooot will be present, but wine binary will be missing, -# however it can be present in other PATHs, so it shouldn't be used, to avoid versions mixing. -wine_path=$(dirname "$(which $wineboot)") -wow64=true -if ! [ -f "$wine_path/$wine" ]; then - wine=$wine64 - wow64=false -fi - -# resolve 32-bit and 64-bit system32 path -winever=$($wine --version | grep wine) -if [ -z "$winever" ]; then - echo "$wine:"' Not a wine executable. Check your $wine.' >&2 - exit 1 -fi - -# ensure wine placeholder dlls are recreated -# if they are missing -$wineboot -u - -win64_sys_path=$($wine64 winepath -u 'C:\windows\system32' 2> /dev/null) -win64_sys_path="${win64_sys_path/$'\r'/}" -if $wow64; then - win32_sys_path=$($wine winepath -u 'C:\windows\system32' 2> /dev/null) - win32_sys_path="${win32_sys_path/$'\r'/}" -fi - -if [ -z "$win32_sys_path" ] && [ -z "$win64_sys_path" ]; then - echo 'Failed to resolve C:\windows\system32.' >&2 - exit 1 -fi - -# create native dll override -overrideDll() { - $wine reg add 'HKEY_CURRENT_USER\Software\Wine\DllOverrides' /v $1 /d native /f >/dev/null 2>&1 - if [ $? -ne 0 ]; then - echo -e "Failed to add override for $1" - exit 1 - fi -} - -# remove dll override -restoreDll() { - $wine reg delete 'HKEY_CURRENT_USER\Software\Wine\DllOverrides' /v $1 /f > /dev/null 2>&1 - if [ $? -ne 0 ]; then - echo "Failed to remove override for $1" - fi -} - -# copy or link dxvk dll, back up original file -installFile() { - dstfile="${1}/${3}.dll" - srcfile="${basedir}/${2}/${3}.dll" - - if [ -f "${srcfile}.so" ]; then - srcfile="${srcfile}.so" - fi - - if ! [ -f "${srcfile}" ]; then - echo "${srcfile}: File not found. Skipping." >&2 - return 1 - fi - - if [ -n "$1" ]; then - if [ -f "${dstfile}" ] || [ -h "${dstfile}" ]; then - if ! [ -f "${dstfile}.old" ]; then - mv -v "${dstfile}" "${dstfile}.old" - else - rm -v "${dstfile}" - fi - $file_cmd "${srcfile}" "${dstfile}" - else - echo "${dstfile}: File not found in wine prefix" >&2 - return 1 - fi - fi - return 0 -} - -# remove dxvk dll, restore original file -uninstallFile() { - dstfile="${1}/${3}.dll" - srcfile="${basedir}/${2}/${3}.dll" - - if [ -f "${srcfile}.so" ]; then - srcfile="${srcfile}.so" - fi - - if ! [ -f "${srcfile}" ]; then - echo "${srcfile}: File not found. Skipping." >&2 - return 1 - fi - - if ! [ -f "${dstfile}" ] && ! [ -h "${dstfile}" ]; then - echo "${dstfile}: File not found. Skipping." >&2 - return 1 - fi - - if [ -f "${dstfile}.old" ]; then - rm -v "${dstfile}" - mv -v "${dstfile}.old" "${dstfile}" - return 0 - else - return 1 - fi -} - -install() { - installFile "$win64_sys_path" "$dxvk_lib64" "$1" - inst64_ret="$?" - - inst32_ret=-1 - if $wow64; then - installFile "$win32_sys_path" "$dxvk_lib32" "$1" - inst32_ret="$?" - fi - - if (( ($inst32_ret == 0) || ($inst64_ret == 0) )); then - overrideDll "$1" - fi -} - -uninstall() { - uninstallFile "$win64_sys_path" "$dxvk_lib64" "$1" - uninst64_ret="$?" - - uninst32_ret=-1 - if $wow64; then - uninstallFile "$win32_sys_path" "$dxvk_lib32" "$1" - uninst32_ret="$?" - fi - - if (( ($uninst32_ret == 0) || ($uninst64_ret == 0) )); then - restoreDll "$1" - fi -} - -# skip dxgi during install if not explicitly -# enabled, but always try to uninstall it -if $with_dxgi || [ "$action" == "uninstall" ]; then - $action dxgi -fi - -$action d3d9 - -if $with_d3d10 || [ "$action" == "uninstall" ]; then - $action d3d10 - $action d3d10_1 -fi - -$action d3d10core -$action d3d11 diff --git a/src/d3d10/d3d10.def b/src/d3d10/d3d10.def deleted file mode 100644 index 6da63131..00000000 --- a/src/d3d10/d3d10.def +++ /dev/null @@ -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 diff --git a/src/d3d10/d3d10_1.def b/src/d3d10/d3d10_1.def deleted file mode 100644 index d32e4e1a..00000000 --- a/src/d3d10/d3d10_1.def +++ /dev/null @@ -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 \ No newline at end of file diff --git a/src/d3d10/d3d10_core.cpp b/src/d3d10/d3d10_core.cpp index d4d229ed..5ae0ac69 100644 --- a/src/d3d10/d3d10_core.cpp +++ b/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; diff --git a/src/d3d10/d3d10_interfaces.h b/src/d3d10/d3d10_interfaces.h deleted file mode 100644 index aa028ab5..00000000 --- a/src/d3d10/d3d10_interfaces.h +++ /dev/null @@ -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 diff --git a/src/d3d10/d3d10_main.cpp b/src/d3d10/d3d10_main.cpp deleted file mode 100644 index 7bec4d0b..00000000 --- a/src/d3d10/d3d10_main.cpp +++ /dev/null @@ -1,335 +0,0 @@ -#include - -#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 dxgiFactory = nullptr; - Com dxgiAdapter = pAdapter; - Com device = nullptr; - - if (!pAdapter) { - if (DriverType != D3D10_DRIVER_TYPE_HARDWARE) - Logger::warn("D3D10CreateDevice: Unsupported driver type"); - - hr = CreateDXGIFactory(__uuidof(IDXGIFactory), reinterpret_cast(&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(&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(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(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(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(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 d3d11Reflector = nullptr; - - HRESULT hr = D3DReflect(pShaderBytecode, - BytecodeLength, IID_ID3D11ShaderReflection, - reinterpret_cast(&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; - } - -} - - diff --git a/src/d3d10/d3d10_multithread.cpp b/src/d3d10/d3d10_multithread.cpp index 65932b53..20a97eef 100644 --- a/src/d3d10/d3d10_multithread.cpp +++ b/src/d3d10/d3d10_multithread.cpp @@ -6,9 +6,12 @@ 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) { } @@ -49,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; } } diff --git a/src/d3d10/d3d10_multithread.h b/src/d3d10/d3d10_multithread.h index 39a736cc..75d4060f 100644 --- a/src/d3d10/d3d10_multithread.h +++ b/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; diff --git a/src/d3d10/d3d10_query.h b/src/d3d10/d3d10_query.h index c189e979..699caa4e 100644 --- a/src/d3d10/d3d10_query.h +++ b/src/d3d10/d3d10_query.h @@ -6,7 +6,6 @@ namespace dxvk { class D3D10Device; class D3D11Device; - class D3D11DeviceContext; class D3D11Query; class D3D10Query : public ID3D10Predicate { diff --git a/src/d3d10/d3d10_reflection.cpp b/src/d3d10/d3d10_reflection.cpp deleted file mode 100644 index d49dea90..00000000 --- a/src/d3d10/d3d10_reflection.cpp +++ /dev/null @@ -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(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; - } - -} \ No newline at end of file diff --git a/src/d3d10/d3d10_reflection.h b/src/d3d10/d3d10_reflection.h deleted file mode 100644 index b25a92ce..00000000 --- a/src/d3d10/d3d10_reflection.h +++ /dev/null @@ -1,163 +0,0 @@ -#pragma once - -#include -#include - -#include "d3d10_include.h" - -#include -#include - -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> 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 { - - 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 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); - - }; - -} \ No newline at end of file diff --git a/src/d3d10/d3d10_state_block.cpp b/src/d3d10/d3d10_state_block.cpp deleted file mode 100644 index af628eb4..00000000 --- a/src/d3d10/d3d10_state_block.cpp +++ /dev/null @@ -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, 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(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(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(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(pA); - auto b = reinterpret_cast(pB); - auto r = reinterpret_cast(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(pA); - auto b = reinterpret_cast(pB); - auto r = reinterpret_cast(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(pA); - auto b = reinterpret_cast(pB); - auto r = reinterpret_cast(pResult); - - for (size_t i = 0; i < sizeof(D3D10_STATE_BLOCK_MASK); i++) - r[i] = a[i] | b[i]; - return S_OK; - } - -} diff --git a/src/d3d10/d3d10_state_block.h b/src/d3d10/d3d10_state_block.h deleted file mode 100644 index b899034d..00000000 --- a/src/d3d10/d3d10_state_block.h +++ /dev/null @@ -1,82 +0,0 @@ -#pragma once - -#include "d3d10_include.h" -#include "d3d10_interfaces.h" - -namespace dxvk { - - struct D3D10_STATE_BLOCK_STATE { - Com vs = { }; - Com vsSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT] = { }; - Com vsSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { }; - Com vsCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { }; - Com gs = { }; - Com gsSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT] = { }; - Com gsSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { }; - Com gsCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { }; - Com ps = { }; - Com psSso[D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT] = { }; - Com psSrv[D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { }; - Com psCbo[D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { }; - Com 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 iaIndexBuffer = { }; - DXGI_FORMAT iaIndexFormat = DXGI_FORMAT_UNKNOWN; - UINT iaIndexOffset = 0; - Com iaInputLayout = nullptr; - D3D10_PRIMITIVE_TOPOLOGY iaTopology = D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED; - Com omRtv[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT] = { }; - Com omDsv = { }; - Com omDepthStencilState = { }; - UINT omStencilRef = 0; - Com 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 rsState = { }; - Com soBuffers[D3D10_SO_BUFFER_SLOT_COUNT] = { }; - UINT soOffsets[D3D10_SO_BUFFER_SLOT_COUNT] = { }; - Com predicate = { }; - BOOL predicateInvert = FALSE; - }; - - - class D3D10StateBlock : public ComObject { - - 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 m_device; - D3D10_STATE_BLOCK_MASK m_mask; - D3D10_STATE_BLOCK_STATE m_state; - - static BOOL TestBit( - const BYTE* pMask, - UINT Idx); - - }; - -} diff --git a/src/d3d10/d3d10core.sym b/src/d3d10/d3d10core.sym new file mode 100644 index 00000000..ba6ccb59 --- /dev/null +++ b/src/d3d10/d3d10core.sym @@ -0,0 +1,9 @@ +{ + global: + D3D10CoreCreateDevice; + D3D10CoreGetVersion; + D3D10CoreRegisterLayers; + + local: + *; +}; diff --git a/src/d3d10/meson.build b/src/d3d10/meson.build index 0a78fcc3..51db067c 100644 --- a/src/d3d10/meson.build +++ b/src/d3d10/meson.build @@ -1,48 +1,30 @@ -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 = [] + +if platform == 'windows' + d3d10_d3d11_dep = lib_d3d11 +else + d3d10_core_ld_args += [ '-Wl,--version-script', join_paths(meson.current_source_dir(), 'd3d10core.sym') ] + d3d10_core_link_depends += files('d3d10core.sym') + d3d10_d3d11_dep = d3d11_dep +endif d3d10_core_dll = shared_library('d3d10core'+dll_ext, d3d10_core_src, d3d10_core_res, - name_prefix : '', - dependencies : [ d3d11_dep ], + name_prefix : dxvk_name_prefix, + dependencies : [ d3d10_d3d11_dep ], include_directories : dxvk_include_path, install : true, vs_module_defs : 'd3d10core'+def_spec_ext, + link_args : d3d10_core_ld_args, + link_depends : [ d3d10_core_link_depends ], ) d3d10_core_dep = declare_dependency( 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, - vs_module_defs : 'd3d10'+def_spec_ext, -) - -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, - vs_module_defs : 'd3d10_1'+def_spec_ext, -) - -d3d10_dep = declare_dependency( - link_with : [ d3d10_dll, d3d10_1_dll, d3d10_core_dll ], - include_directories : [ dxvk_include_path ], -) diff --git a/src/d3d10/version10.rc b/src/d3d10/version10.rc deleted file mode 100644 index 43d7a62f..00000000 --- a/src/d3d10/version10.rc +++ /dev/null @@ -1,32 +0,0 @@ -#include - -// 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 Runtime" - VALUE "FileVersion", "10.0.17763.1 (WinBuild.160101.0800)" - VALUE "InternalName", "D3D10.dll" - VALUE "LegalCopyright", "zlib/libpng license" - VALUE "OriginalFilename", "D3D10.dll" - VALUE "ProductName", "DXVK" - VALUE "ProductVersion", "10.0.17763.1" - END - END - BLOCK "VarFileInfo" - BEGIN - VALUE "Translation", 0x0809, 1200 - END -END - diff --git a/src/d3d10/version10_1.rc b/src/d3d10/version10_1.rc deleted file mode 100644 index 92550d32..00000000 --- a/src/d3d10/version10_1.rc +++ /dev/null @@ -1,32 +0,0 @@ -#include - -// 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 - diff --git a/src/d3d11/d3d11.sym b/src/d3d11/d3d11.sym new file mode 100644 index 00000000..91c8598e --- /dev/null +++ b/src/d3d11/d3d11.sym @@ -0,0 +1,10 @@ +{ + global: + D3D11CoreCreateDevice; + D3D11CreateDevice; + D3D11CreateDeviceAndSwapChain; + D3D11On12CreateDevice; + + local: + *; +}; diff --git a/src/d3d11/d3d11_annotation.cpp b/src/d3d11/d3d11_annotation.cpp index 7c74b7ad..b7c1fdf7 100644 --- a/src/d3d11/d3d11_annotation.cpp +++ b/src/d3d11/d3d11_annotation.cpp @@ -1,8 +1,10 @@ #include "d3d11_annotation.h" -#include "d3d11_context.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 { @@ -30,46 +32,50 @@ namespace dxvk { registrationFunction(annotation); } - D3D11UserDefinedAnnotation::D3D11UserDefinedAnnotation(D3D11DeviceContext* ctx) - : m_container(ctx), - m_eventDepth(0) { - if (m_container->IsAnnotationEnabled()) + + template + D3D11UserDefinedAnnotation::D3D11UserDefinedAnnotation( + ContextType* container, + const Rc& dxvkDevice) + : m_container(container), m_eventDepth(0), + m_annotationsEnabled(dxvkDevice->instance()->extensions().extDebugUtils) { + if (!IsDeferred && m_annotationsEnabled) RegisterUserDefinedAnnotation(this); } - D3D11UserDefinedAnnotation::D3D11UserDefinedAnnotation(const D3D11UserDefinedAnnotation&) - { - if (m_container->IsAnnotationEnabled()) - RegisterUserDefinedAnnotation(this); - } - D3D11UserDefinedAnnotation::~D3D11UserDefinedAnnotation() { - if (m_container->IsAnnotationEnabled()) + template + D3D11UserDefinedAnnotation::~D3D11UserDefinedAnnotation() { + if (!IsDeferred && m_annotationsEnabled) RegisterUserDefinedAnnotation(this); } - ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::AddRef() { + template + ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::AddRef() { return m_container->AddRef(); } - ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::Release() { + template + ULONG STDMETHODCALLTYPE D3D11UserDefinedAnnotation::Release() { return m_container->Release(); } - HRESULT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::QueryInterface( + template + HRESULT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::QueryInterface( REFIID riid, void** ppvObject) { return m_container->QueryInterface(riid, ppvObject); } - INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::BeginEvent( + template + INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::BeginEvent( D3DCOLOR Color, LPCWSTR Name) { - if (!m_container->IsAnnotationEnabled()) + if (!m_annotationsEnabled) return -1; D3D10DeviceLock lock = m_container->LockContext(); @@ -88,8 +94,9 @@ namespace dxvk { } - INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::EndEvent() { - if (!m_container->IsAnnotationEnabled()) + template + INT STDMETHODCALLTYPE D3D11UserDefinedAnnotation::EndEvent() { + if (!m_annotationsEnabled) return -1; D3D10DeviceLock lock = m_container->LockContext(); @@ -102,10 +109,11 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11UserDefinedAnnotation::SetMarker( + template + void STDMETHODCALLTYPE D3D11UserDefinedAnnotation::SetMarker( D3DCOLOR Color, LPCWSTR Name) { - if (!m_container->IsAnnotationEnabled()) + if (!m_annotationsEnabled) return; D3D10DeviceLock lock = m_container->LockContext(); @@ -122,8 +130,13 @@ namespace dxvk { } - BOOL STDMETHODCALLTYPE D3D11UserDefinedAnnotation::GetStatus() { - return m_container->IsAnnotationEnabled(); + template + BOOL STDMETHODCALLTYPE D3D11UserDefinedAnnotation::GetStatus() { + return m_annotationsEnabled; } + + template class D3D11UserDefinedAnnotation; + template class D3D11UserDefinedAnnotation; + } diff --git a/src/d3d11/d3d11_annotation.h b/src/d3d11/d3d11_annotation.h index 06d80af6..ec569a9a 100644 --- a/src/d3d11/d3d11_annotation.h +++ b/src/d3d11/d3d11_annotation.h @@ -1,20 +1,31 @@ #pragma once +#include + #include "d3d11_include.h" + #include "../dxvk/dxvk_annotation.h" +#include "../dxvk/dxvk_device.h" namespace dxvk { - class D3D11DeviceContext; + class D3D11DeferredContext; + class D3D11ImmediateContext; + template class D3D11UserDefinedAnnotation final : public IDXVKUserDefinedAnnotation { - + constexpr static bool IsDeferred = std::is_same_v; public: - D3D11UserDefinedAnnotation(D3D11DeviceContext* ctx); - D3D11UserDefinedAnnotation(const D3D11UserDefinedAnnotation&); + D3D11UserDefinedAnnotation( + ContextType* container, + const Rc& dxvkDevice); + ~D3D11UserDefinedAnnotation(); + D3D11UserDefinedAnnotation (const D3D11UserDefinedAnnotation&) = delete; + D3D11UserDefinedAnnotation& operator = (const D3D11UserDefinedAnnotation&) = delete; + ULONG STDMETHODCALLTYPE AddRef(); ULONG STDMETHODCALLTYPE Release(); @@ -37,10 +48,9 @@ namespace dxvk { private: - D3D11DeviceContext* m_container; - - // Stack depth for non-finalized BeginEvent calls - int32_t m_eventDepth; + ContextType* m_container; + int32_t m_eventDepth; + bool m_annotationsEnabled; }; } diff --git a/src/d3d11/d3d11_blend.cpp b/src/d3d11/d3d11_blend.cpp index caacc869..441d35a7 100644 --- a/src/d3d11/d3d11_blend.cpp +++ b/src/d3d11/d3d11_blend.cpp @@ -58,8 +58,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11BlendState::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11BlendState), riid)) { + Logger::warn("D3D11BlendState::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -87,7 +90,7 @@ namespace dxvk { void D3D11BlendState::BindToContext( - const Rc& ctx, + DxvkContext* ctx, uint32_t sampleMask) const { // We handled Independent Blend during object creation // already, so if it is disabled, all elements in the diff --git a/src/d3d11/d3d11_blend.h b/src/d3d11/d3d11_blend.h index 5761d3ca..a5546c6e 100644 --- a/src/d3d11/d3d11_blend.h +++ b/src/d3d11/d3d11_blend.h @@ -33,7 +33,7 @@ namespace dxvk { D3D11_BLEND_DESC1* pDesc) final; void BindToContext( - const Rc& ctx, + DxvkContext* ctx, UINT sampleMask) const; D3D10BlendState* GetD3D10Iface() { diff --git a/src/d3d11/d3d11_buffer.cpp b/src/d3d11/d3d11_buffer.cpp index eb72fc1b..11087a97 100644 --- a/src/d3d11/d3d11_buffer.cpp +++ b/src/d3d11/d3d11_buffer.cpp @@ -8,12 +8,14 @@ namespace dxvk { D3D11Buffer::D3D11Buffer( D3D11Device* pDevice, - const D3D11_BUFFER_DESC* pDesc) + const D3D11_BUFFER_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info) : D3D11DeviceChild(pDevice), m_desc (*pDesc), m_resource (this), 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; @@ -37,9 +39,6 @@ namespace dxvk { info.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; info.stages |= m_parent->GetEnabledShaderStages(); info.access |= VK_ACCESS_UNIFORM_READ_BIT; - - if (m_parent->GetOptions()->constantBufferRangeCheck) - info.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; } if (pDesc->BindFlags & D3D11_BIND_SHADER_RESOURCE) { @@ -69,12 +68,50 @@ 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_parent->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; + } - m_mapMode = DetermineMapMode(); + // 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; + } + + if (p11on12Info) { + m_11on12 = *p11on12Info; + + DxvkBufferImportInfo importInfo; + importInfo.buffer = VkBuffer(m_11on12.VulkanHandle); + importInfo.offset = m_11on12.VulkanOffset; + + if (m_desc.CPUAccessFlags) + m_11on12.Resource->Map(0, nullptr, &importInfo.mapPtr); + + m_buffer = m_parent->GetDXVKDevice()->importBuffer(info, importInfo, GetMemoryFlags()); + m_mapped = m_buffer->getSliceHandle(); + + m_mapMode = DetermineMapMode(); + } else if (!(pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)) { + // Create the buffer and set the entire buffer slice as mapped, + // so that we only have to update it when invalidating the buffer + m_buffer = m_parent->GetDXVKDevice()->createBuffer(info, GetMemoryFlags()); + m_mapped = m_buffer->getSliceHandle(); + + m_mapMode = DetermineMapMode(); + } else { + m_sparseAllocator = m_parent->GetDXVKDevice()->createSparsePageAllocator(); + m_sparseAllocator->setCapacity(info.size / SparseMemoryPageSize); + + m_mapped = DxvkBufferSliceHandle(); + m_mapMode = D3D11_COMMON_BUFFER_MAP_MODE_NONE; + } // For Stream Output buffers we need a counter if (pDesc->BindFlags & D3D11_BIND_STREAM_OUTPUT) @@ -83,7 +120,8 @@ namespace dxvk { D3D11Buffer::~D3D11Buffer() { - + if (m_desc.CPUAccessFlags && m_11on12.Resource != nullptr) + m_11on12.Resource->Unmap(0, nullptr); } @@ -116,8 +154,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11Buffer), riid)) { + Logger::warn("D3D11Buffer::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -159,7 +200,7 @@ 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_parent->LookupFormat(Format, DXGI_VK_FORMAT_MODE_ANY); - VkFormatFeatureFlags features = GetBufferFormatFeatures(BindFlags); + VkFormatFeatureFlags2 features = GetBufferFormatFeatures(BindFlags); return CheckFormatFeatureSupport(viewFormat.Format, features); } @@ -167,13 +208,9 @@ namespace dxvk { 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)) @@ -194,7 +231,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; @@ -202,17 +257,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_parent->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; @@ -251,6 +339,7 @@ namespace dxvk { || (m_parent->GetOptions()->cachedDynamicResources & m_desc.BindFlags); if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && useCached) { + memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; } diff --git a/src/d3d11/d3d11_buffer.h b/src/d3d11/d3d11_buffer.h index c0472fd6..097a8fcb 100644 --- a/src/d3d11/d3d11_buffer.h +++ b/src/d3d11/d3d11_buffer.h @@ -7,12 +7,12 @@ #include "d3d11_device_child.h" #include "d3d11_interfaces.h" +#include "d3d11_on_12.h" #include "d3d11_resource.h" namespace dxvk { class D3D11Device; - class D3D11DeviceContext; /** @@ -42,7 +42,9 @@ namespace dxvk { D3D11Buffer( D3D11Device* pDevice, - const D3D11_BUFFER_DESC* pDesc); + const D3D11_BUFFER_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info); + ~D3D11Buffer(); HRESULT STDMETHODCALLTYPE QueryInterface( @@ -67,6 +69,10 @@ 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_mapMode; } @@ -74,6 +80,10 @@ namespace dxvk { Rc GetBuffer() const { return m_buffer; } + + Rc GetSparseAllocator() const { + return m_sparseAllocator; + } DxvkBufferSlice GetBufferSlice() const { return DxvkBufferSlice(m_buffer, 0, m_desc.ByteWidth); @@ -81,18 +91,20 @@ namespace dxvk { DxvkBufferSlice GetBufferSlice(VkDeviceSize offset) const { VkDeviceSize size = m_desc.ByteWidth; - - return likely(offset < size) - ? DxvkBufferSlice(m_buffer, offset, size - offset) - : DxvkBufferSlice(); + offset = std::min(offset, size); + return DxvkBufferSlice(m_buffer, offset, size - offset); } DxvkBufferSlice GetBufferSlice(VkDeviceSize offset, VkDeviceSize length) const { VkDeviceSize size = m_desc.ByteWidth; + offset = std::min(offset, size); + return DxvkBufferSlice(m_buffer, offset, std::min(length, size - offset)); + } - return likely(offset < size) - ? DxvkBufferSlice(m_buffer, offset, std::min(length, size - offset)) - : DxvkBufferSlice(); + VkDeviceSize GetRemainingSize(VkDeviceSize offset) const { + VkDeviceSize size = m_desc.ByteWidth; + offset = std::min(offset, size); + return size - offset; } DxvkBufferSlice GetSOCounter() { @@ -133,6 +145,14 @@ namespace dxvk { : DxvkCsThread::SynchronizeAll; } + /** + * \brief Retrieves D3D11on12 resource info + * \returns 11on12 resource info + */ + D3D11_ON_12_RESOURCE_INFO Get11on12Info() const { + return m_11on12; + } + /** * \brief Normalizes buffer description * @@ -142,13 +162,28 @@ namespace dxvk { static HRESULT NormalizeBufferProperties( D3D11_BUFFER_DESC* pDesc); + /** + * \brief Initializes D3D11 buffer description from D3D12 + * + * \param [in] pResource D3D12 resource + * \param [in] pResourceFlags D3D11 flag overrides + * \param [out] pBufferDesc D3D11 buffer description + * \returns \c S_OK if the parameters are valid + */ + static HRESULT GetDescFromD3D12( + ID3D12Resource* pResource, + const D3D11_RESOURCE_FLAGS* pResourceFlags, + D3D11_BUFFER_DESC* pBufferDesc); + private: D3D11_BUFFER_DESC m_desc; + D3D11_ON_12_RESOURCE_INFO m_11on12; D3D11_COMMON_BUFFER_MAP_MODE m_mapMode; Rc m_buffer; Rc m_soCounter; + Rc m_sparseAllocator; DxvkBufferSliceHandle m_mapped; uint64_t m_seq = 0ull; @@ -157,7 +192,7 @@ namespace dxvk { BOOL CheckFormatFeatureSupport( VkFormat Format, - VkFormatFeatureFlags Features) const; + VkFormatFeatureFlags2 Features) const; VkMemoryPropertyFlags GetMemoryFlags() const; diff --git a/src/d3d11/d3d11_class_linkage.cpp b/src/d3d11/d3d11_class_linkage.cpp index 8070b660..d2bc7588 100644 --- a/src/d3d11/d3d11_class_linkage.cpp +++ b/src/d3d11/d3d11_class_linkage.cpp @@ -28,8 +28,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11ClassLinkage::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11ClassLinkage), riid)) { + Logger::warn("D3D11ClassLinkage::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_cmdlist.cpp b/src/d3d11/d3d11_cmdlist.cpp index aeb1cd5a..31ed4376 100644 --- a/src/d3d11/d3d11_cmdlist.cpp +++ b/src/d3d11/d3d11_cmdlist.cpp @@ -30,8 +30,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11CommandList::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11CommandList), riid)) { + Logger::warn("D3D11CommandList::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -41,54 +44,79 @@ namespace dxvk { } - void D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) { - m_chunks.push_back(std::move(Chunk)); - } - - void D3D11CommandList::AddQuery(D3D11Query* pQuery) { m_queries.emplace_back(pQuery); } - void D3D11CommandList::EmitToCommandList(ID3D11CommandList* pCommandList) { - auto cmdList = static_cast(pCommandList); - - for (const auto& chunk : m_chunks) - cmdList->m_chunks.push_back(chunk); - - for (const auto& query : m_queries) - cmdList->m_queries.push_back(query); - - for (const auto& resource : m_resources) - cmdList->m_resources.push_back(resource); - - MarkSubmitted(); + uint64_t D3D11CommandList::AddChunk(DxvkCsChunkRef&& Chunk) { + m_chunks.push_back(std::move(Chunk)); + return m_chunks.size() - 1; } - uint64_t D3D11CommandList::EmitToCsThread(DxvkCsThread* CsThread) { - uint64_t seq = 0; + uint64_t D3D11CommandList::AddCommandList( + D3D11CommandList* pCommandList) { + // This will be the chunk ID of the first chunk + // added, for the purpose of resource tracking. + uint64_t baseChunkId = m_chunks.size(); + + for (const auto& chunk : pCommandList->m_chunks) + m_chunks.push_back(chunk); + for (const auto& query : pCommandList->m_queries) + m_queries.push_back(query); + + for (const auto& resource : pCommandList->m_resources) { + TrackedResource entry = resource; + entry.chunkId += baseChunkId; + + m_resources.push_back(std::move(entry)); + } + + pCommandList->MarkSubmitted(); + + // Return ID of the last chunk added. The command list + // added can never be empty, so do not handle zero. + return m_chunks.size() - 1; + } + + + void D3D11CommandList::EmitToCsThread( + const D3D11ChunkDispatchProc& DispatchProc) { for (const auto& query : m_queries) query->DoDeferredEnd(); - for (const auto& chunk : m_chunks) - seq = CsThread->dispatchChunk(DxvkCsChunkRef(chunk)); - - for (const auto& resource : m_resources) - TrackResourceSequenceNumber(resource, seq); + for (size_t i = 0, j = 0; i < m_chunks.size(); i++) { + // If there are resources to track for the current chunk, + // use a strong flush hint to dispatch GPU work quickly. + GpuFlushType flushType = GpuFlushType::ImplicitWeakHint; + + if (j < m_resources.size() && m_resources[j].chunkId == i) + flushType = GpuFlushType::ImplicitStrongHint; + + // Dispatch the chunk and capture its sequence number + uint64_t seq = DispatchProc(DxvkCsChunkRef(m_chunks[i]), flushType); + + // Track resource sequence numbers for the added chunk + while (j < m_resources.size() && m_resources[j].chunkId == i) + TrackResourceSequenceNumber(m_resources[j++].ref, seq); + } MarkSubmitted(); - return seq; } void D3D11CommandList::TrackResourceUsage( ID3D11Resource* pResource, D3D11_RESOURCE_DIMENSION ResourceType, - UINT Subresource) { - m_resources.emplace_back(pResource, Subresource, ResourceType); + UINT Subresource, + uint64_t ChunkId) { + TrackedResource entry; + entry.ref = D3D11ResourceRef(pResource, Subresource, ResourceType); + entry.chunkId = ChunkId; + + m_resources.push_back(std::move(entry)); } @@ -96,7 +124,6 @@ namespace dxvk { const D3D11ResourceRef& Resource, uint64_t Seq) { ID3D11Resource* iface = Resource.Get(); - UINT subresource = Resource.GetSubresource(); switch (Resource.GetType()) { case D3D11_RESOURCE_DIMENSION_UNKNOWN: @@ -109,17 +136,17 @@ namespace dxvk { case D3D11_RESOURCE_DIMENSION_TEXTURE1D: { auto impl = static_cast(iface)->GetCommonTexture(); - impl->TrackSequenceNumber(subresource, Seq); + impl->TrackSequenceNumber(Resource.GetSubresource(), Seq); } break; case D3D11_RESOURCE_DIMENSION_TEXTURE2D: { auto impl = static_cast(iface)->GetCommonTexture(); - impl->TrackSequenceNumber(subresource, Seq); + impl->TrackSequenceNumber(Resource.GetSubresource(), Seq); } break; case D3D11_RESOURCE_DIMENSION_TEXTURE3D: { auto impl = static_cast(iface)->GetCommonTexture(); - impl->TrackSequenceNumber(subresource, Seq); + impl->TrackSequenceNumber(Resource.GetSubresource(), Seq); } break; } } diff --git a/src/d3d11/d3d11_cmdlist.h b/src/d3d11/d3d11_cmdlist.h index 8be313ad..45253ecf 100644 --- a/src/d3d11/d3d11_cmdlist.h +++ b/src/d3d11/d3d11_cmdlist.h @@ -1,9 +1,13 @@ #pragma once +#include + #include "d3d11_context.h" namespace dxvk { + using D3D11ChunkDispatchProc = std::function; + class D3D11CommandList : public D3D11DeviceChild { public: @@ -20,30 +24,36 @@ namespace dxvk { UINT STDMETHODCALLTYPE GetContextFlags() final; - void AddChunk( - DxvkCsChunkRef&& Chunk); - void AddQuery( D3D11Query* pQuery); - void EmitToCommandList( - ID3D11CommandList* pCommandList); - - uint64_t EmitToCsThread( - DxvkCsThread* CsThread); + uint64_t AddChunk( + DxvkCsChunkRef&& Chunk); + + uint64_t AddCommandList( + D3D11CommandList* pCommandList); + + void EmitToCsThread( + const D3D11ChunkDispatchProc& DispatchProc); void TrackResourceUsage( ID3D11Resource* pResource, D3D11_RESOURCE_DIMENSION ResourceType, - UINT Subresource); + UINT Subresource, + uint64_t ChunkId); private: - UINT const m_contextFlags; + struct TrackedResource { + D3D11ResourceRef ref; + uint64_t chunkId; + }; + + UINT m_contextFlags; std::vector m_chunks; std::vector> m_queries; - std::vector m_resources; + std::vector m_resources; std::atomic m_submitted = { false }; std::atomic m_warned = { false }; diff --git a/src/d3d11/d3d11_context.cpp b/src/d3d11/d3d11_context.cpp index 23fb9e61..977a403e 100644 --- a/src/d3d11/d3d11_context.cpp +++ b/src/d3d11/d3d11_context.cpp @@ -1,43 +1,43 @@ -#include +#include #include "d3d11_context.h" -#include "d3d11_device.h" -#include "d3d11_query.h" -#include "d3d11_texture.h" -#include "d3d11_video.h" - -#include "../dxbc/dxbc_util.h" +#include "d3d11_context_def.h" +#include "d3d11_context_imm.h" namespace dxvk { - - D3D11DeviceContext::D3D11DeviceContext( + + template + D3D11CommonContext::D3D11CommonContext( D3D11Device* pParent, const Rc& Device, + UINT ContextFlags, DxvkCsChunkFlags CsFlags) : D3D11DeviceChild(pParent), - m_contextExt(this), - m_multithread(this, false), + m_contextExt(GetTypedContext()), + m_annotation(GetTypedContext(), Device), m_device (Device), + m_flags (ContextFlags), m_staging (Device, StagingBufferSize), - m_annotation(this), m_csFlags (CsFlags), m_csChunk (AllocCsChunk()), m_cmdData (nullptr) { } - - - D3D11DeviceContext::~D3D11DeviceContext() { - + + + template + D3D11CommonContext::~D3D11CommonContext() { + } - - - HRESULT STDMETHODCALLTYPE D3D11DeviceContext::QueryInterface(REFIID riid, void** ppvObject) { + + + template + HRESULT STDMETHODCALLTYPE D3D11CommonContext::QueryInterface(REFIID riid, void** ppvObject) { if (ppvObject == nullptr) return E_POINTER; *ppvObject = nullptr; - + if (riid == __uuidof(IUnknown) || riid == __uuidof(ID3D11DeviceChild) || riid == __uuidof(ID3D11DeviceContext) @@ -48,36 +48,58 @@ namespace dxvk { *ppvObject = ref(this); return S_OK; } - + if (riid == __uuidof(ID3D11VkExtContext) || riid == __uuidof(ID3D11VkExtContext1)) { *ppvObject = ref(&m_contextExt); return S_OK; } - + if (riid == __uuidof(ID3DUserDefinedAnnotation) || riid == __uuidof(IDXVKUserDefinedAnnotation)) { *ppvObject = ref(&m_annotation); return S_OK; } - if (riid == __uuidof(ID3D10Multithread)) { - *ppvObject = ref(&m_multithread); - return S_OK; + if (logQueryInterfaceError(__uuidof(ID3D11DeviceContext), riid)) { + Logger::warn("D3D11DeviceContext::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); } - - Logger::warn("D3D11DeviceContext::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + return E_NOINTERFACE; } - - void STDMETHODCALLTYPE D3D11DeviceContext::DiscardResource(ID3D11Resource* pResource) { + + template + D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE D3D11CommonContext::GetType() { + return IsDeferred + ? D3D11_DEVICE_CONTEXT_DEFERRED + : D3D11_DEVICE_CONTEXT_IMMEDIATE; + } + + + template + UINT STDMETHODCALLTYPE D3D11CommonContext::GetContextFlags() { + return m_flags; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearState() { + D3D10DeviceLock lock = LockContext(); + + ResetCommandListState(); + ResetContextState(); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DiscardResource(ID3D11Resource* pResource) { D3D10DeviceLock lock = LockContext(); if (!pResource) return; - + // We don't support the Discard API for images D3D11_RESOURCE_DIMENSION resType = D3D11_RESOURCE_DIMENSION_UNKNOWN; pResource->GetType(&resType); @@ -93,12 +115,14 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContext::DiscardView(ID3D11View* pResourceView) { + template + void STDMETHODCALLTYPE D3D11CommonContext::DiscardView(ID3D11View* pResourceView) { DiscardView1(pResourceView, nullptr, 0); } - void STDMETHODCALLTYPE D3D11DeviceContext::DiscardView1( + template + void STDMETHODCALLTYPE D3D11CommonContext::DiscardView1( ID3D11View* pResourceView, const D3D11_RECT* pRects, UINT NumRects) { @@ -144,153 +168,10 @@ namespace dxvk { ctx->discardImageView(cView, cView->formatInfo()->aspectMask); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearState() { - D3D10DeviceLock lock = LockContext(); - // Default shaders - m_state.vs.shader = nullptr; - m_state.hs.shader = nullptr; - m_state.ds.shader = nullptr; - m_state.gs.shader = nullptr; - m_state.ps.shader = nullptr; - m_state.cs.shader = nullptr; - - // Default constant buffers - for (uint32_t i = 0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++) { - m_state.vs.constantBuffers[i] = { nullptr, 0, 0 }; - m_state.hs.constantBuffers[i] = { nullptr, 0, 0 }; - m_state.ds.constantBuffers[i] = { nullptr, 0, 0 }; - m_state.gs.constantBuffers[i] = { nullptr, 0, 0 }; - m_state.ps.constantBuffers[i] = { nullptr, 0, 0 }; - m_state.cs.constantBuffers[i] = { nullptr, 0, 0 }; - } - - // Default samplers - for (uint32_t i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; i++) { - m_state.vs.samplers[i] = nullptr; - m_state.hs.samplers[i] = nullptr; - m_state.ds.samplers[i] = nullptr; - m_state.gs.samplers[i] = nullptr; - m_state.ps.samplers[i] = nullptr; - m_state.cs.samplers[i] = nullptr; - } - - // Default shader resources - for (uint32_t i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++) { - m_state.vs.shaderResources.views[i] = nullptr; - m_state.hs.shaderResources.views[i] = nullptr; - m_state.ds.shaderResources.views[i] = nullptr; - m_state.gs.shaderResources.views[i] = nullptr; - m_state.ps.shaderResources.views[i] = nullptr; - m_state.cs.shaderResources.views[i] = nullptr; - } - m_state.vs.shaderResources.hazardous.clear(); - m_state.hs.shaderResources.hazardous.clear(); - m_state.ds.shaderResources.hazardous.clear(); - m_state.gs.shaderResources.hazardous.clear(); - m_state.ps.shaderResources.hazardous.clear(); - m_state.cs.shaderResources.hazardous.clear(); - - // Default UAVs - for (uint32_t i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++) { - m_state.ps.unorderedAccessViews[i] = nullptr; - m_state.cs.unorderedAccessViews[i] = nullptr; - } - - m_state.cs.uavMask.clear(); - - // Default ID state - m_state.id.argBuffer = nullptr; - - // Default IA state - m_state.ia.inputLayout = nullptr; - m_state.ia.primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; - - for (uint32_t i = 0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; i++) { - m_state.ia.vertexBuffers[i].buffer = nullptr; - m_state.ia.vertexBuffers[i].offset = 0; - m_state.ia.vertexBuffers[i].stride = 0; - } - - m_state.ia.indexBuffer.buffer = nullptr; - m_state.ia.indexBuffer.offset = 0; - m_state.ia.indexBuffer.format = DXGI_FORMAT_UNKNOWN; - - // Default OM State - for (uint32_t i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++) - m_state.om.renderTargetViews[i] = nullptr; - m_state.om.depthStencilView = nullptr; - - m_state.om.cbState = nullptr; - m_state.om.dsState = nullptr; - - for (uint32_t i = 0; i < 4; i++) - m_state.om.blendFactor[i] = 1.0f; - - m_state.om.sampleMask = D3D11_DEFAULT_SAMPLE_MASK; - m_state.om.stencilRef = D3D11_DEFAULT_STENCIL_REFERENCE; - - m_state.om.maxRtv = 0; - m_state.om.maxUav = 0; - - // Default RS state - m_state.rs.state = nullptr; - m_state.rs.numViewports = 0; - m_state.rs.numScissors = 0; - - for (uint32_t i = 0; i < D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE; i++) { - m_state.rs.viewports[i] = D3D11_VIEWPORT { }; - m_state.rs.scissors [i] = D3D11_RECT { }; - } - - // Default SO state - for (uint32_t i = 0; i < D3D11_SO_BUFFER_SLOT_COUNT; i++) { - m_state.so.targets[i].buffer = nullptr; - m_state.so.targets[i].offset = 0; - } - - // Default predication - m_state.pr.predicateObject = nullptr; - m_state.pr.predicateValue = FALSE; - - // Make sure to apply all state - ResetState(); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::SetPredication( - ID3D11Predicate* pPredicate, - BOOL PredicateValue) { - D3D10DeviceLock lock = LockContext(); - - auto predicate = D3D11Query::FromPredicate(pPredicate); - m_state.pr.predicateObject = predicate; - m_state.pr.predicateValue = PredicateValue; - - static bool s_errorShown = false; - - if (pPredicate && !std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::SetPredication: Stub"); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GetPredication( - ID3D11Predicate** ppPredicate, - BOOL* pPredicateValue) { - D3D10DeviceLock lock = LockContext(); - - if (ppPredicate) - *ppPredicate = D3D11Query::AsPredicate(m_state.pr.predicateObject.ref()); - - if (pPredicateValue) - *pPredicateValue = m_state.pr.predicateValue; - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CopySubresourceRegion( + template + void STDMETHODCALLTYPE D3D11CommonContext::CopySubresourceRegion( ID3D11Resource* pDstResource, UINT DstSubresource, UINT DstX, @@ -303,9 +184,10 @@ namespace dxvk { pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, 0); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CopySubresourceRegion1( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CopySubresourceRegion1( ID3D11Resource* pDstResource, UINT DstSubresource, UINT DstX, @@ -328,10 +210,10 @@ namespace dxvk { D3D11_RESOURCE_DIMENSION dstResourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN; D3D11_RESOURCE_DIMENSION srcResourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN; - + pDstResource->GetType(&dstResourceDim); pSrcResource->GetType(&srcResourceDim); - + if (dstResourceDim == D3D11_RESOURCE_DIMENSION_BUFFER && srcResourceDim == D3D11_RESOURCE_DIMENSION_BUFFER) { auto dstBuffer = static_cast(pDstResource); auto srcBuffer = static_cast(pSrcResource); @@ -339,84 +221,75 @@ namespace dxvk { VkDeviceSize dstOffset = DstX; VkDeviceSize srcOffset = 0; VkDeviceSize byteCount = -1; - + if (pSrcBox) { srcOffset = pSrcBox->left; byteCount = pSrcBox->right - pSrcBox->left; } - + CopyBuffer(dstBuffer, dstOffset, srcBuffer, srcOffset, byteCount); } else if (dstResourceDim != D3D11_RESOURCE_DIMENSION_BUFFER && srcResourceDim != D3D11_RESOURCE_DIMENSION_BUFFER) { auto dstTexture = GetCommonTexture(pDstResource); auto srcTexture = GetCommonTexture(pSrcResource); - + if (DstSubresource >= dstTexture->CountSubresources() || SrcSubresource >= srcTexture->CountSubresources()) return; - - auto dstFormatInfo = imageFormatInfo(dstTexture->GetPackedFormat()); - auto srcFormatInfo = imageFormatInfo(srcTexture->GetPackedFormat()); - + + auto dstFormatInfo = lookupFormatInfo(dstTexture->GetPackedFormat()); + auto srcFormatInfo = lookupFormatInfo(srcTexture->GetPackedFormat()); + auto dstLayers = vk::makeSubresourceLayers(dstTexture->GetSubresourceFromIndex(dstFormatInfo->aspectMask, DstSubresource)); auto srcLayers = vk::makeSubresourceLayers(srcTexture->GetSubresourceFromIndex(srcFormatInfo->aspectMask, SrcSubresource)); - + VkOffset3D srcOffset = { 0, 0, 0 }; VkOffset3D dstOffset = { int32_t(DstX), int32_t(DstY), int32_t(DstZ) }; - + VkExtent3D srcExtent = srcTexture->MipLevelExtent(srcLayers.mipLevel); - - if (pSrcBox != nullptr) { + + if (pSrcBox) { srcOffset.x = pSrcBox->left; srcOffset.y = pSrcBox->top; srcOffset.z = pSrcBox->front; - + srcExtent.width = pSrcBox->right - pSrcBox->left; srcExtent.height = pSrcBox->bottom - pSrcBox->top; srcExtent.depth = pSrcBox->back - pSrcBox->front; } - + CopyImage( dstTexture, &dstLayers, dstOffset, srcTexture, &srcLayers, srcOffset, srcExtent); - } else { - Logger::err(str::format( - "D3D11: CopySubresourceRegion1: Incompatible resources", - "\n Dst resource type: ", dstResourceDim, - "\n Src resource type: ", srcResourceDim)); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CopyResource( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CopyResource( ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) { D3D10DeviceLock lock = LockContext(); if (!pDstResource || !pSrcResource || (pDstResource == pSrcResource)) return; - + D3D11_RESOURCE_DIMENSION dstResourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN; D3D11_RESOURCE_DIMENSION srcResourceDim = D3D11_RESOURCE_DIMENSION_UNKNOWN; - + pDstResource->GetType(&dstResourceDim); pSrcResource->GetType(&srcResourceDim); - - if (dstResourceDim != srcResourceDim) { - Logger::err(str::format( - "D3D11: CopyResource: Incompatible resources", - "\n Dst resource type: ", dstResourceDim, - "\n Src resource type: ", srcResourceDim)); + + if (dstResourceDim != srcResourceDim) return; - } - + if (dstResourceDim == D3D11_RESOURCE_DIMENSION_BUFFER) { auto dstBuffer = static_cast(pDstResource); auto srcBuffer = static_cast(pSrcResource); if (dstBuffer->Desc()->ByteWidth != srcBuffer->Desc()->ByteWidth) return; - + CopyBuffer(dstBuffer, 0, srcBuffer, 0, -1); } else { auto dstTexture = GetCommonTexture(pDstResource); @@ -427,18 +300,16 @@ namespace dxvk { // The subresource count must match as well if (dstDesc->ArraySize != srcDesc->ArraySize - || dstDesc->MipLevels != srcDesc->MipLevels) { - Logger::err("D3D11: CopyResource: Incompatible images"); + || dstDesc->MipLevels != srcDesc->MipLevels) return; - } - auto dstFormatInfo = imageFormatInfo(dstTexture->GetPackedFormat()); - auto srcFormatInfo = imageFormatInfo(srcTexture->GetPackedFormat()); + auto dstFormatInfo = lookupFormatInfo(dstTexture->GetPackedFormat()); + auto srcFormatInfo = lookupFormatInfo(srcTexture->GetPackedFormat()); for (uint32_t i = 0; i < dstDesc->MipLevels; i++) { VkImageSubresourceLayers dstLayers = { dstFormatInfo->aspectMask, i, 0, dstDesc->ArraySize }; VkImageSubresourceLayers srcLayers = { srcFormatInfo->aspectMask, i, 0, srcDesc->ArraySize }; - + CopyImage( dstTexture, &dstLayers, VkOffset3D(), srcTexture, &srcLayers, VkOffset3D(), @@ -448,7 +319,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContext::CopyStructureCount( + template + void STDMETHODCALLTYPE D3D11CommonContext::CopyStructureCount( ID3D11Buffer* pDstBuffer, UINT DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView) { @@ -460,13 +332,14 @@ namespace dxvk { if (!buf || !uav) return; - auto counterSlice = uav->GetCounterSlice(); - if (!counterSlice.defined()) + auto counterView = uav->GetCounterView(); + + if (counterView == nullptr) return; EmitCs([ cDstSlice = buf->GetBufferSlice(DstAlignedByteOffset), - cSrcSlice = std::move(counterSlice) + cSrcSlice = counterView->slice() ] (DxvkContext* ctx) { ctx->copyBuffer( cDstSlice.buffer(), @@ -477,72 +350,24 @@ namespace dxvk { }); if (buf->HasSequenceNumber()) - TrackBufferSequenceNumber(buf); + GetTypedContext()->TrackBufferSequenceNumber(buf); } - void STDMETHODCALLTYPE D3D11DeviceContext::CopyTiles( - ID3D11Resource* pTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pTileRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pTileRegionSize, - ID3D11Buffer* pBuffer, - UINT64 BufferStartOffsetInBytes, - UINT Flags) { - static bool s_errorShown = false; - - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::CopyTiles: Not implemented"); - } - - - HRESULT STDMETHODCALLTYPE D3D11DeviceContext::CopyTileMappings( - ID3D11Resource* pDestTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pDestRegionStartCoordinate, - ID3D11Resource* pSourceTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pSourceRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pTileRegionSize, - UINT Flags) { - static bool s_errorShown = false; - - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::CopyTileMappings: Not implemented"); - - return DXGI_ERROR_INVALID_CALL; - } - - - HRESULT STDMETHODCALLTYPE D3D11DeviceContext::ResizeTilePool( - ID3D11Buffer* pTilePool, - UINT64 NewSizeInBytes) { - static bool s_errorShown = false; - - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::ResizeTilePool: Not implemented"); - - return DXGI_ERROR_INVALID_CALL; - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::TiledResourceBarrier( - ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, - ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier) { - - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearRenderTargetView( + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearRenderTargetView( ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4]) { D3D10DeviceLock lock = LockContext(); auto rtv = static_cast(pRenderTargetView); - + if (!rtv) return; - + auto view = rtv->GetImageView(); auto color = ConvertColorValue(ColorRGBA, view->formatInfo()); - + EmitCs([ cClearValue = color, cImageView = std::move(view) @@ -553,26 +378,27 @@ namespace dxvk { cClearValue); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearUnorderedAccessViewUint( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearUnorderedAccessViewUint( ID3D11UnorderedAccessView* pUnorderedAccessView, const UINT Values[4]) { D3D10DeviceLock lock = LockContext(); auto uav = static_cast(pUnorderedAccessView); - + if (!uav) return; - + // Gather UAV format info. We'll use this to determine // whether we need to create a temporary view or not. D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; uav->GetDesc(&uavDesc); - + VkFormat uavFormat = m_parent->LookupFormat(uavDesc.Format, DXGI_VK_FORMAT_MODE_ANY).Format; VkFormat rawFormat = m_parent->LookupFormat(uavDesc.Format, DXGI_VK_FORMAT_MODE_RAW).Format; - + if (uavFormat != rawFormat && rawFormat == VK_FORMAT_UNDEFINED) { Logger::err(str::format("D3D11: ClearUnorderedAccessViewUint: No raw format found for ", uavFormat)); return; @@ -580,15 +406,22 @@ namespace dxvk { VkClearValue clearValue; - // R11G11B10 is a special case since there's no corresponding - // integer format with the same bit layout. Use R32 instead. - if (uavFormat == VK_FORMAT_B10G11R11_UFLOAT_PACK32) { + if (uavDesc.Format == DXGI_FORMAT_R11G11B10_FLOAT) { + // R11G11B10 is a special case since there's no corresponding + // integer format with the same bit layout. Use R32 instead. clearValue.color.uint32[0] = ((Values[0] & 0x7FF) << 0) | ((Values[1] & 0x7FF) << 11) | ((Values[2] & 0x3FF) << 22); clearValue.color.uint32[1] = 0; clearValue.color.uint32[2] = 0; clearValue.color.uint32[3] = 0; + } else if (uavDesc.Format == DXGI_FORMAT_A8_UNORM) { + // We need to use R8_UINT to clear A8_UNORM images, + // so remap the alpha component to the red channel. + clearValue.color.uint32[0] = Values[3]; + clearValue.color.uint32[1] = 0; + clearValue.color.uint32[2] = 0; + clearValue.color.uint32[3] = 0; } else { clearValue.color.uint32[0] = Values[0]; clearValue.color.uint32[1] = Values[1]; @@ -601,7 +434,7 @@ namespace dxvk { // buffers that can be used for atomic operations, we can // use the fast Vulkan buffer clear function. Rc bufferView = uav->GetBufferView(); - + if (bufferView->info().format == VK_FORMAT_R32_UINT || bufferView->info().format == VK_FORMAT_R32_SINT || bufferView->info().format == VK_FORMAT_R32_SFLOAT @@ -621,11 +454,11 @@ namespace dxvk { if (uavFormat != rawFormat) { DxvkBufferViewCreateInfo info = bufferView->info(); info.format = rawFormat; - + bufferView = m_device->createBufferView( bufferView->buffer(), info); } - + EmitCs([ cClearValue = clearValue, cDstView = bufferView @@ -661,10 +494,10 @@ namespace dxvk { if (uavFormat != rawFormat && !isZeroClearValue) { DxvkImageViewCreateInfo info = imageView->info(); info.format = rawFormat; - + imageView = m_device->createImageView(imageView->image(), info); } - + EmitCs([ cClearValue = clearValue, cDstView = imageView @@ -717,18 +550,19 @@ namespace dxvk { } } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearUnorderedAccessViewFloat( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearUnorderedAccessViewFloat( ID3D11UnorderedAccessView* pUnorderedAccessView, const FLOAT Values[4]) { D3D10DeviceLock lock = LockContext(); auto uav = static_cast(pUnorderedAccessView); - + if (!uav) return; - + auto imgView = uav->GetImageView(); auto bufView = uav->GetBufferView(); @@ -738,13 +572,13 @@ namespace dxvk { if (!info || info->flags.any(DxvkFormatFlag::SampledSInt, DxvkFormatFlag::SampledUInt)) return; - + VkClearValue clearValue; clearValue.color.float32[0] = Values[0]; clearValue.color.float32[1] = Values[1]; clearValue.color.float32[2] = Values[2]; clearValue.color.float32[3] = Values[3]; - + if (uav->GetResourceType() == D3D11_RESOURCE_DIMENSION_BUFFER) { EmitCs([ cClearValue = clearValue, @@ -768,9 +602,10 @@ namespace dxvk { }); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearDepthStencilView( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearDepthStencilView( ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags, FLOAT Depth, @@ -778,29 +613,29 @@ namespace dxvk { D3D10DeviceLock lock = LockContext(); auto dsv = static_cast(pDepthStencilView); - + if (!dsv) return; - + // Figure out which aspects to clear based on // the image view properties and clear flags. VkImageAspectFlags aspectMask = 0; - + if (ClearFlags & D3D11_CLEAR_DEPTH) aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT; - + if (ClearFlags & D3D11_CLEAR_STENCIL) aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; - + aspectMask &= dsv->GetWritableAspectMask(); if (!aspectMask) return; - + VkClearValue clearValue; clearValue.depthStencil.depth = Depth; clearValue.depthStencil.stencil = Stencil; - + EmitCs([ cClearValue = clearValue, cAspectMask = aspectMask, @@ -812,12 +647,13 @@ namespace dxvk { cClearValue); }); } - - void STDMETHODCALLTYPE D3D11DeviceContext::ClearView( - ID3D11View* pView, - const FLOAT Color[4], - const D3D11_RECT* pRect, + + template + void STDMETHODCALLTYPE D3D11CommonContext::ClearView( + ID3D11View* pView, + const FLOAT Color[4], + const D3D11_RECT* pRect, UINT NumRects) { D3D10DeviceLock lock = LockContext(); @@ -840,7 +676,7 @@ namespace dxvk { if (rtv != nullptr) imgView = rtv->GetImageView(); - + if (uav != nullptr) { bufView = uav->GetBufferView(); imgView = uav->GetImageView(); @@ -860,16 +696,16 @@ namespace dxvk { if (bufView != nullptr) format = bufView->info().format; - + if (imgView != nullptr) format = imgView->info().format; - + if (format == VK_FORMAT_UNDEFINED) return; - + // We'll need the format info to determine the buffer // element size, and we also need it for depth images. - const DxvkFormatInfo* formatInfo = imageFormatInfo(format); + const DxvkFormatInfo* formatInfo = lookupFormatInfo(format); // Convert the clear color format. ClearView takes // the clear value for integer formats as a set of @@ -884,7 +720,7 @@ namespace dxvk { || pRect[i].top >= pRect[i].bottom) continue; } - + if (bufView != nullptr) { VkDeviceSize offset = 0; VkDeviceSize length = bufView->info().rangeLength / formatInfo->elementSize; @@ -918,7 +754,7 @@ namespace dxvk { uint32_t(pRect[i].right - pRect[i].left), uint32_t(pRect[i].bottom - pRect[i].top), 1 }; } - + EmitCs([ cImageView = imgView, cAreaOffset = offset, @@ -949,9 +785,10 @@ namespace dxvk { } } } - - void STDMETHODCALLTYPE D3D11DeviceContext::GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) { + + template + void STDMETHODCALLTYPE D3D11CommonContext::GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) { D3D10DeviceLock lock = LockContext(); auto view = static_cast(pShaderResourceView); @@ -969,62 +806,10 @@ namespace dxvk { ctx->generateMipmaps(cDstImageView, VK_FILTER_LINEAR); }); } - - - HRESULT STDMETHODCALLTYPE D3D11DeviceContext::UpdateTileMappings( - ID3D11Resource* pTiledResource, - UINT NumTiledResourceRegions, - const D3D11_TILED_RESOURCE_COORDINATE* pTiledResourceRegionStartCoordinates, - const D3D11_TILE_REGION_SIZE* pTiledResourceRegionSizes, - ID3D11Buffer* pTilePool, - UINT NumRanges, - const UINT* pRangeFlags, - const UINT* pTilePoolStartOffsets, - const UINT* pRangeTileCounts, - UINT Flags) { - bool s_errorShown = false; - - if (std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::UpdateTileMappings: Not implemented"); - - return DXGI_ERROR_INVALID_CALL; - } - void STDMETHODCALLTYPE D3D11DeviceContext::UpdateTiles( - ID3D11Resource* pDestTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pDestTileRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pDestTileRegionSize, - const void* pSourceTileData, - UINT Flags) { - bool s_errorShown = false; - - if (std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::UpdateTiles: Not implemented"); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::SetResourceMinLOD( - ID3D11Resource* pResource, - FLOAT MinLOD) { - bool s_errorShown = false; - - if (std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::SetResourceMinLOD: Not implemented"); - } - - - FLOAT STDMETHODCALLTYPE D3D11DeviceContext::GetResourceMinLOD(ID3D11Resource* pResource) { - bool s_errorShown = false; - - if (std::exchange(s_errorShown, true)) - Logger::err("D3D11DeviceContext::GetResourceMinLOD: Not implemented"); - - return 0.0f; - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::ResolveSubresource( + template + void STDMETHODCALLTYPE D3D11CommonContext::ResolveSubresource( ID3D11Resource* pDstResource, UINT DstSubresource, ID3D11Resource* pSrcResource, @@ -1034,73 +819,63 @@ namespace dxvk { bool isSameSubresource = pDstResource == pSrcResource && DstSubresource == SrcSubresource; - + if (!pDstResource || !pSrcResource || isSameSubresource) return; - + D3D11_RESOURCE_DIMENSION dstResourceType; D3D11_RESOURCE_DIMENSION srcResourceType; - + pDstResource->GetType(&dstResourceType); pSrcResource->GetType(&srcResourceType); - + if (dstResourceType != D3D11_RESOURCE_DIMENSION_TEXTURE2D - || srcResourceType != D3D11_RESOURCE_DIMENSION_TEXTURE2D) { - Logger::err(str::format( - "D3D11: ResolveSubresource: Incompatible resources", - "\n Dst resource type: ", dstResourceType, - "\n Src resource type: ", srcResourceType)); + || srcResourceType != D3D11_RESOURCE_DIMENSION_TEXTURE2D) return; - } - + auto dstTexture = static_cast(pDstResource); auto srcTexture = static_cast(pSrcResource); - + D3D11_TEXTURE2D_DESC dstDesc; D3D11_TEXTURE2D_DESC srcDesc; - + dstTexture->GetDesc(&dstDesc); srcTexture->GetDesc(&srcDesc); - - if (dstDesc.SampleDesc.Count != 1) { - Logger::err(str::format( - "D3D11: ResolveSubresource: Invalid sample counts", - "\n Dst sample count: ", dstDesc.SampleDesc.Count, - "\n Src sample count: ", srcDesc.SampleDesc.Count)); + + if (dstDesc.SampleDesc.Count != 1) return; - } - + D3D11CommonTexture* dstTextureInfo = GetCommonTexture(pDstResource); D3D11CommonTexture* srcTextureInfo = GetCommonTexture(pSrcResource); - + const DXGI_VK_FORMAT_INFO dstFormatInfo = m_parent->LookupFormat(dstDesc.Format, DXGI_VK_FORMAT_MODE_ANY); const DXGI_VK_FORMAT_INFO srcFormatInfo = m_parent->LookupFormat(srcDesc.Format, DXGI_VK_FORMAT_MODE_ANY); - - auto dstVulkanFormatInfo = imageFormatInfo(dstFormatInfo.Format); - auto srcVulkanFormatInfo = imageFormatInfo(srcFormatInfo.Format); - + + auto dstVulkanFormatInfo = lookupFormatInfo(dstFormatInfo.Format); + auto srcVulkanFormatInfo = lookupFormatInfo(srcFormatInfo.Format); + if (DstSubresource >= dstTextureInfo->CountSubresources() || SrcSubresource >= srcTextureInfo->CountSubresources()) return; - + const VkImageSubresource dstSubresource = dstTextureInfo->GetSubresourceFromIndex( dstVulkanFormatInfo->aspectMask, DstSubresource); - + const VkImageSubresource srcSubresource = srcTextureInfo->GetSubresourceFromIndex( srcVulkanFormatInfo->aspectMask, SrcSubresource); - + const VkImageSubresourceLayers dstSubresourceLayers = { dstSubresource.aspectMask, dstSubresource.mipLevel, dstSubresource.arrayLayer, 1 }; - + const VkImageSubresourceLayers srcSubresourceLayers = { srcSubresource.aspectMask, srcSubresource.mipLevel, srcSubresource.arrayLayer, 1 }; - + if (srcDesc.SampleDesc.Count == 1 || m_parent->GetOptions()->disableMsaa) { EmitCs([ cDstImage = dstTextureInfo->GetImage(), @@ -1116,7 +891,7 @@ namespace dxvk { } else { const VkFormat format = m_parent->LookupFormat( Format, DXGI_VK_FORMAT_MODE_ANY).Format; - + EmitCs([ cDstImage = dstTextureInfo->GetImage(), cSrcImage = srcTextureInfo->GetImage(), @@ -1136,18 +911,46 @@ namespace dxvk { } if (dstTextureInfo->HasSequenceNumber()) - TrackTextureSequenceNumber(dstTextureInfo, DstSubresource); + GetTypedContext()->TrackTextureSequenceNumber(dstTextureInfo, DstSubresource); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawAuto() { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::UpdateSubresource( + ID3D11Resource* pDstResource, + UINT DstSubresource, + const D3D11_BOX* pDstBox, + const void* pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch) { + UpdateResource(pDstResource, DstSubresource, pDstBox, + pSrcData, SrcRowPitch, SrcDepthPitch, 0); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::UpdateSubresource1( + ID3D11Resource* pDstResource, + UINT DstSubresource, + const D3D11_BOX* pDstBox, + const void* pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch, + UINT CopyFlags) { + UpdateResource(pDstResource, DstSubresource, pDstBox, + pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawAuto() { D3D10DeviceLock lock = LockContext(); D3D11Buffer* buffer = m_state.ia.vertexBuffers[0].buffer.ptr(); - if (buffer == nullptr) + if (!buffer) return; - + DxvkBufferSlice vtxBuf = buffer->GetBufferSlice(); DxvkBufferSlice ctrBuf = buffer->GetSOCounter(); @@ -1160,9 +963,10 @@ namespace dxvk { vtxBuf.offset()); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::Draw( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::Draw( UINT VertexCount, UINT StartVertexLocation) { D3D10DeviceLock lock = LockContext(); @@ -1173,14 +977,15 @@ namespace dxvk { StartVertexLocation, 0); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawIndexed( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawIndexed( UINT IndexCount, UINT StartIndexLocation, INT BaseVertexLocation) { D3D10DeviceLock lock = LockContext(); - + EmitCs([=] (DxvkContext* ctx) { ctx->drawIndexed( IndexCount, 1, @@ -1188,15 +993,16 @@ namespace dxvk { BaseVertexLocation, 0); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawInstanced( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawInstanced( UINT VertexCountPerInstance, UINT InstanceCount, UINT StartVertexLocation, UINT StartInstanceLocation) { D3D10DeviceLock lock = LockContext(); - + EmitCs([=] (DxvkContext* ctx) { ctx->draw( VertexCountPerInstance, @@ -1205,16 +1011,17 @@ namespace dxvk { StartInstanceLocation); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawIndexedInstanced( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawIndexedInstanced( UINT IndexCountPerInstance, UINT InstanceCount, UINT StartIndexLocation, INT BaseVertexLocation, UINT StartInstanceLocation) { D3D10DeviceLock lock = LockContext(); - + EmitCs([=] (DxvkContext* ctx) { ctx->drawIndexed( IndexCountPerInstance, @@ -1224,9 +1031,10 @@ namespace dxvk { StartInstanceLocation); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawIndexedInstancedIndirect( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawIndexedInstancedIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs) { D3D10DeviceLock lock = LockContext(); @@ -1234,15 +1042,15 @@ namespace dxvk { if (!ValidateDrawBufferSize(pBufferForArgs, AlignedByteOffsetForArgs, sizeof(VkDrawIndexedIndirectCommand))) return; - + // If possible, batch up multiple indirect draw calls of // the same type into one single multiDrawIndirect call auto cmdData = static_cast(m_cmdData); auto stride = 0u; - + if (cmdData && cmdData->type == D3D11CmdType::DrawIndirectIndexed) stride = GetIndirectCommandStride(cmdData, AlignedByteOffsetForArgs, sizeof(VkDrawIndexedIndirectCommand)); - + if (stride) { cmdData->count += 1; cmdData->stride = stride; @@ -1251,16 +1059,17 @@ namespace dxvk { [] (DxvkContext* ctx, const D3D11CmdDrawIndirectData* data) { ctx->drawIndexedIndirect(data->offset, data->count, data->stride); }); - + cmdData->type = D3D11CmdType::DrawIndirectIndexed; cmdData->offset = AlignedByteOffsetForArgs; cmdData->count = 1; cmdData->stride = 0; } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DrawInstancedIndirect( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DrawInstancedIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs) { D3D10DeviceLock lock = LockContext(); @@ -1273,10 +1082,10 @@ namespace dxvk { // the same type into one single multiDrawIndirect call auto cmdData = static_cast(m_cmdData); auto stride = 0u; - + if (cmdData && cmdData->type == D3D11CmdType::DrawIndirect) stride = GetIndirectCommandStride(cmdData, AlignedByteOffsetForArgs, sizeof(VkDrawIndirectCommand)); - + if (stride) { cmdData->count += 1; cmdData->stride = stride; @@ -1285,21 +1094,22 @@ namespace dxvk { [] (DxvkContext* ctx, const D3D11CmdDrawIndirectData* data) { ctx->drawIndirect(data->offset, data->count, data->stride); }); - + cmdData->type = D3D11CmdType::DrawIndirect; cmdData->offset = AlignedByteOffsetForArgs; cmdData->count = 1; cmdData->stride = 0; } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::Dispatch( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::Dispatch( UINT ThreadGroupCountX, UINT ThreadGroupCountY, UINT ThreadGroupCountZ) { D3D10DeviceLock lock = LockContext(); - + EmitCs([=] (DxvkContext* ctx) { ctx->dispatch( ThreadGroupCountX, @@ -1307,14 +1117,15 @@ namespace dxvk { ThreadGroupCountZ); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DispatchIndirect( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DispatchIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs) { D3D10DeviceLock lock = LockContext(); SetDrawBuffers(pBufferForArgs, nullptr); - + if (!ValidateDrawBufferSize(pBufferForArgs, AlignedByteOffsetForArgs, sizeof(VkDispatchIndirectCommand))) return; @@ -1323,941 +1134,929 @@ namespace dxvk { ctx->dispatchIndirect(cOffset); }); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IASetInputLayout(ID3D11InputLayout* pInputLayout) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IASetInputLayout(ID3D11InputLayout* pInputLayout) { D3D10DeviceLock lock = LockContext(); - + auto inputLayout = static_cast(pInputLayout); - + if (m_state.ia.inputLayout != inputLayout) { bool equal = false; - + // Some games (e.g. Grim Dawn) create lots and lots of // identical input layouts, so we'll only apply the state // if the input layouts has actually changed between calls. if (m_state.ia.inputLayout != nullptr && inputLayout != nullptr) equal = m_state.ia.inputLayout->Compare(inputLayout); - + m_state.ia.inputLayout = inputLayout; - + if (!equal) ApplyInputLayout(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY Topology) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY Topology) { D3D10DeviceLock lock = LockContext(); - + if (m_state.ia.primitiveTopology != Topology) { m_state.ia.primitiveTopology = Topology; ApplyPrimitiveTopology(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IASetVertexBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IASetVertexBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppVertexBuffers, const UINT* pStrides, const UINT* pOffsets) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumBuffers; i++) { auto newBuffer = static_cast(ppVertexBuffers[i]); - bool needsUpdate = m_state.ia.vertexBuffers[StartSlot + i].buffer != newBuffer; - if (needsUpdate) + if (m_state.ia.vertexBuffers[StartSlot + i].buffer != newBuffer) { m_state.ia.vertexBuffers[StartSlot + i].buffer = newBuffer; - - needsUpdate |= m_state.ia.vertexBuffers[StartSlot + i].offset != pOffsets[i] - || m_state.ia.vertexBuffers[StartSlot + i].stride != pStrides[i]; - - if (needsUpdate) { m_state.ia.vertexBuffers[StartSlot + i].offset = pOffsets[i]; m_state.ia.vertexBuffers[StartSlot + i].stride = pStrides[i]; BindVertexBuffer(StartSlot + i, newBuffer, pOffsets[i], pStrides[i]); + } else if (m_state.ia.vertexBuffers[StartSlot + i].offset != pOffsets[i] + || m_state.ia.vertexBuffers[StartSlot + i].stride != pStrides[i]) { + m_state.ia.vertexBuffers[StartSlot + i].offset = pOffsets[i]; + m_state.ia.vertexBuffers[StartSlot + i].stride = pStrides[i]; + + BindVertexBufferRange(StartSlot + i, newBuffer, pOffsets[i], pStrides[i]); } } + + m_state.ia.maxVbCount = std::clamp(StartSlot + NumBuffers, + m_state.ia.maxVbCount, uint32_t(m_state.ia.vertexBuffers.size())); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IASetIndexBuffer( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IASetIndexBuffer( ID3D11Buffer* pIndexBuffer, DXGI_FORMAT Format, UINT Offset) { D3D10DeviceLock lock = LockContext(); - + auto newBuffer = static_cast(pIndexBuffer); - bool needsUpdate = m_state.ia.indexBuffer.buffer != newBuffer; - if (needsUpdate) + if (m_state.ia.indexBuffer.buffer != newBuffer) { m_state.ia.indexBuffer.buffer = newBuffer; - - needsUpdate |= m_state.ia.indexBuffer.offset != Offset - || m_state.ia.indexBuffer.format != Format; - - if (needsUpdate) { m_state.ia.indexBuffer.offset = Offset; m_state.ia.indexBuffer.format = Format; BindIndexBuffer(newBuffer, Offset, Format); + } else if (m_state.ia.indexBuffer.offset != Offset + || m_state.ia.indexBuffer.format != Format) { + m_state.ia.indexBuffer.offset = Offset; + m_state.ia.indexBuffer.format = Format; + + BindIndexBufferRange(newBuffer, Offset, Format); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IAGetInputLayout(ID3D11InputLayout** ppInputLayout) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IAGetInputLayout(ID3D11InputLayout** ppInputLayout) { D3D10DeviceLock lock = LockContext(); - + *ppInputLayout = m_state.ia.inputLayout.ref(); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IAGetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY* pTopology) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IAGetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY* pTopology) { D3D10DeviceLock lock = LockContext(); - + *pTopology = m_state.ia.primitiveTopology; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IAGetVertexBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IAGetVertexBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppVertexBuffers, UINT* pStrides, UINT* pOffsets) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumBuffers; i++) { const bool inRange = StartSlot + i < m_state.ia.vertexBuffers.size(); - if (ppVertexBuffers != nullptr) { + if (ppVertexBuffers) { ppVertexBuffers[i] = inRange ? m_state.ia.vertexBuffers[StartSlot + i].buffer.ref() : nullptr; } - - if (pStrides != nullptr) { + + if (pStrides) { pStrides[i] = inRange ? m_state.ia.vertexBuffers[StartSlot + i].stride : 0u; } - - if (pOffsets != nullptr) { + + if (pOffsets) { pOffsets[i] = inRange ? m_state.ia.vertexBuffers[StartSlot + i].offset : 0u; } } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::IAGetIndexBuffer( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::IAGetIndexBuffer( ID3D11Buffer** ppIndexBuffer, DXGI_FORMAT* pFormat, UINT* pOffset) { D3D10DeviceLock lock = LockContext(); - - if (ppIndexBuffer != nullptr) + + if (ppIndexBuffer) *ppIndexBuffer = m_state.ia.indexBuffer.buffer.ref(); - - if (pFormat != nullptr) + + if (pFormat) *pFormat = m_state.ia.indexBuffer.format; - - if (pOffset != nullptr) + + if (pOffset) *pOffset = m_state.ia.indexBuffer.offset; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSSetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSSetShader( ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances) { D3D10DeviceLock lock = LockContext(); - + auto shader = static_cast(pVertexShader); - - if (NumClassInstances != 0) + + if (NumClassInstances) Logger::err("D3D11: Class instances not supported"); - - if (m_state.vs.shader != shader) { - m_state.vs.shader = shader; + + if (m_state.vs != shader) { + m_state.vs = shader; BindShader(GetCommonShader(shader)); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSSetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers( - m_state.vs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); + StartSlot, NumBuffers, ppConstantBuffers); } - void STDMETHODCALLTYPE D3D11DeviceContext::VSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, - const UINT* pNumConstants) { - D3D10DeviceLock lock = LockContext(); - - SetConstantBuffers1( - m_state.vs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSSetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView* const* ppShaderResourceViews) { - D3D10DeviceLock lock = LockContext(); - - SetShaderResources( - m_state.vs.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSSetSamplers( - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState* const* ppSamplers) { - D3D10DeviceLock lock = LockContext(); - - SetSamplers( - m_state.vs.samplers, - StartSlot, NumSamplers, - ppSamplers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSGetShader( - ID3D11VertexShader** ppVertexShader, - ID3D11ClassInstance** ppClassInstances, - UINT* pNumClassInstances) { - D3D10DeviceLock lock = LockContext(); - - if (ppVertexShader != nullptr) - *ppVertexShader = m_state.vs.shader.ref(); - - if (pNumClassInstances != nullptr) - *pNumClassInstances = 0; - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSGetConstantBuffers( + template + void STDMETHODCALLTYPE D3D11CommonContext::VSSetConstantBuffers1( UINT StartSlot, UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers) { - D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.vs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - nullptr, nullptr); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSGetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, - UINT* pNumConstants) { - D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.vs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSGetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView** ppShaderResourceViews) { - D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.vs.shaderResources, - StartSlot, NumViews, ppShaderResourceViews); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::VSGetSamplers( - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState** ppSamplers) { - D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.vs.samplers, - StartSlot, NumSamplers, ppSamplers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSSetShader( - ID3D11HullShader* pHullShader, - ID3D11ClassInstance* const* ppClassInstances, - UINT NumClassInstances) { - D3D10DeviceLock lock = LockContext(); - - auto shader = static_cast(pHullShader); - - if (NumClassInstances != 0) - Logger::err("D3D11: Class instances not supported"); - - if (m_state.hs.shader != shader) { - m_state.hs.shader = shader; - - BindShader(GetCommonShader(shader)); - } - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSSetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView* const* ppShaderResourceViews) { - D3D10DeviceLock lock = LockContext(); - - SetShaderResources( - m_state.hs.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSSetConstantBuffers( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers) { - D3D10DeviceLock lock = LockContext(); - - SetConstantBuffers( - m_state.hs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, - const UINT* pNumConstants) { - D3D10DeviceLock lock = LockContext(); - - SetConstantBuffers1( - m_state.hs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSSetSamplers( - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState* const* ppSamplers) { - D3D10DeviceLock lock = LockContext(); - - SetSamplers( - m_state.hs.samplers, - StartSlot, NumSamplers, - ppSamplers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSGetShader( - ID3D11HullShader** ppHullShader, - ID3D11ClassInstance** ppClassInstances, - UINT* pNumClassInstances) { - D3D10DeviceLock lock = LockContext(); - - if (ppHullShader != nullptr) - *ppHullShader = m_state.hs.shader.ref(); - - if (pNumClassInstances != nullptr) - *pNumClassInstances = 0; - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSGetConstantBuffers( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers) { - D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.hs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - nullptr, nullptr); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSGetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, - UINT* pNumConstants) { - D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.hs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSGetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView** ppShaderResourceViews) { - D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.hs.shaderResources, - StartSlot, NumViews, ppShaderResourceViews); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::HSGetSamplers( - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState** ppSamplers) { - D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.hs.samplers, - StartSlot, NumSamplers, ppSamplers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSSetShader( - ID3D11DomainShader* pDomainShader, - ID3D11ClassInstance* const* ppClassInstances, - UINT NumClassInstances) { - D3D10DeviceLock lock = LockContext(); - - auto shader = static_cast(pDomainShader); - - if (NumClassInstances != 0) - Logger::err("D3D11: Class instances not supported"); - - if (m_state.ds.shader != shader) { - m_state.ds.shader = shader; - - BindShader(GetCommonShader(shader)); - } - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSSetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView* const* ppShaderResourceViews) { - D3D10DeviceLock lock = LockContext(); - - SetShaderResources( - m_state.ds.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSSetConstantBuffers( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers) { - D3D10DeviceLock lock = LockContext(); - - SetConstantBuffers( - m_state.ds.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); - } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - - SetConstantBuffers1( - m_state.ds.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + + SetConstantBuffers1( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSSetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSSetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView* const* ppShaderResourceViews) { + D3D10DeviceLock lock = LockContext(); + + SetShaderResources( + StartSlot, NumViews, ppShaderResourceViews); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) { D3D10DeviceLock lock = LockContext(); - - SetSamplers( - m_state.ds.samplers, - StartSlot, NumSamplers, - ppSamplers); + + SetSamplers( + StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSGetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSGetShader( + ID3D11VertexShader** ppVertexShader, + ID3D11ClassInstance** ppClassInstances, + UINT* pNumClassInstances) { + D3D10DeviceLock lock = LockContext(); + + if (ppVertexShader) + *ppVertexShader = m_state.vs.ref(); + + if (pNumClassInstances) + *pNumClassInstances = 0; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSGetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers) { + D3D10DeviceLock lock = LockContext(); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + nullptr, nullptr); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, + UINT* pNumConstants) { + D3D10DeviceLock lock = LockContext(); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSGetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView** ppShaderResourceViews) { + D3D10DeviceLock lock = LockContext(); + + GetShaderResources( + StartSlot, NumViews, ppShaderResourceViews); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::VSGetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState** ppSamplers) { + D3D10DeviceLock lock = LockContext(); + + GetSamplers( + StartSlot, NumSamplers, ppSamplers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSSetShader( + ID3D11HullShader* pHullShader, + ID3D11ClassInstance* const* ppClassInstances, + UINT NumClassInstances) { + D3D10DeviceLock lock = LockContext(); + + auto shader = static_cast(pHullShader); + + if (NumClassInstances) + Logger::err("D3D11: Class instances not supported"); + + if (m_state.hs != shader) { + m_state.hs = shader; + + BindShader(GetCommonShader(shader)); + } + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSSetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers) { + D3D10DeviceLock lock = LockContext(); + + SetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, + const UINT* pNumConstants) { + D3D10DeviceLock lock = LockContext(); + + SetConstantBuffers1( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSSetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView* const* ppShaderResourceViews) { + D3D10DeviceLock lock = LockContext(); + + SetShaderResources( + StartSlot, NumViews, ppShaderResourceViews); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSSetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState* const* ppSamplers) { + D3D10DeviceLock lock = LockContext(); + + SetSamplers( + StartSlot, NumSamplers, ppSamplers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSGetShader( + ID3D11HullShader** ppHullShader, + ID3D11ClassInstance** ppClassInstances, + UINT* pNumClassInstances) { + D3D10DeviceLock lock = LockContext(); + + if (ppHullShader) + *ppHullShader = m_state.hs.ref(); + + if (pNumClassInstances) + *pNumClassInstances = 0; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSGetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers) { + D3D10DeviceLock lock = LockContext(); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + nullptr, nullptr); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, + UINT* pNumConstants) { + D3D10DeviceLock lock = LockContext(); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSGetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView** ppShaderResourceViews) { + D3D10DeviceLock lock = LockContext(); + + GetShaderResources( + StartSlot, NumViews, ppShaderResourceViews); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::HSGetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState** ppSamplers) { + D3D10DeviceLock lock = LockContext(); + + GetSamplers( + StartSlot, NumSamplers, ppSamplers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSSetShader( + ID3D11DomainShader* pDomainShader, + ID3D11ClassInstance* const* ppClassInstances, + UINT NumClassInstances) { + D3D10DeviceLock lock = LockContext(); + + auto shader = static_cast(pDomainShader); + + if (NumClassInstances) + Logger::err("D3D11: Class instances not supported"); + + if (m_state.ds != shader) { + m_state.ds = shader; + + BindShader(GetCommonShader(shader)); + } + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSSetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers) { + D3D10DeviceLock lock = LockContext(); + + SetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, + const UINT* pNumConstants) { + D3D10DeviceLock lock = LockContext(); + + SetConstantBuffers1( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSSetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView* const* ppShaderResourceViews) { + D3D10DeviceLock lock = LockContext(); + + SetShaderResources( + StartSlot, NumViews, ppShaderResourceViews); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSSetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState* const* ppSamplers) { + D3D10DeviceLock lock = LockContext(); + + SetSamplers( + StartSlot, NumSamplers, ppSamplers); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSGetShader( ID3D11DomainShader** ppDomainShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances) { D3D10DeviceLock lock = LockContext(); - - if (ppDomainShader != nullptr) - *ppDomainShader = m_state.ds.shader.ref(); - - if (pNumClassInstances != nullptr) + + if (ppDomainShader) + *ppDomainShader = m_state.ds.ref(); + + if (pNumClassInstances) *pNumClassInstances = 0; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSGetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.ds.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, nullptr, nullptr); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSGetConstantBuffers1( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSGetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, + UINT* pFirstConstant, UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.ds.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - void STDMETHODCALLTYPE D3D11DeviceContext::DSGetShaderResources( + template + void STDMETHODCALLTYPE D3D11CommonContext::DSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.ds.shaderResources, + + GetShaderResources( StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::DSGetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::DSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) { D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.ds.samplers, + + GetSamplers( StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSSetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSSetShader( ID3D11GeometryShader* pShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances) { D3D10DeviceLock lock = LockContext(); - + auto shader = static_cast(pShader); - - if (NumClassInstances != 0) + + if (NumClassInstances) Logger::err("D3D11: Class instances not supported"); - - if (m_state.gs.shader != shader) { - m_state.gs.shader = shader; + + if (m_state.gs != shader) { + m_state.gs = shader; BindShader(GetCommonShader(shader)); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSSetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers( - m_state.gs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); + StartSlot, NumBuffers, ppConstantBuffers); } - void STDMETHODCALLTYPE D3D11DeviceContext::GSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, + template + void STDMETHODCALLTYPE D3D11CommonContext::GSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, + const UINT* pFirstConstant, const UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers1( - m_state.gs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSSetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - + SetShaderResources( - m_state.gs.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); + StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSSetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) { D3D10DeviceLock lock = LockContext(); - + SetSamplers( - m_state.gs.samplers, - StartSlot, NumSamplers, - ppSamplers); + StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSGetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSGetShader( ID3D11GeometryShader** ppGeometryShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances) { D3D10DeviceLock lock = LockContext(); - - if (ppGeometryShader != nullptr) - *ppGeometryShader = m_state.gs.shader.ref(); - - if (pNumClassInstances != nullptr) + + if (ppGeometryShader) + *ppGeometryShader = m_state.gs.ref(); + + if (pNumClassInstances) *pNumClassInstances = 0; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSGetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.gs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, nullptr, nullptr); } - void STDMETHODCALLTYPE D3D11DeviceContext::GSGetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, + template + void STDMETHODCALLTYPE D3D11CommonContext::GSGetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.gs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSGetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.gs.shaderResources, + + GetShaderResources( StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::GSGetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::GSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) { D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.gs.samplers, + + GetSamplers( StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSSetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSSetShader( ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances) { D3D10DeviceLock lock = LockContext(); - + auto shader = static_cast(pPixelShader); - - if (NumClassInstances != 0) + + if (NumClassInstances) Logger::err("D3D11: Class instances not supported"); - - if (m_state.ps.shader != shader) { - m_state.ps.shader = shader; + + if (m_state.ps != shader) { + m_state.ps = shader; BindShader(GetCommonShader(shader)); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSSetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers( - m_state.ps.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); + StartSlot, NumBuffers, ppConstantBuffers); } - void STDMETHODCALLTYPE D3D11DeviceContext::PSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, + template + void STDMETHODCALLTYPE D3D11CommonContext::PSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, const UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers1( - m_state.ps.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSSetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - + SetShaderResources( - m_state.ps.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); + StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSSetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) { D3D10DeviceLock lock = LockContext(); - + SetSamplers( - m_state.ps.samplers, - StartSlot, NumSamplers, - ppSamplers); + StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSGetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSGetShader( ID3D11PixelShader** ppPixelShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances) { D3D10DeviceLock lock = LockContext(); - - if (ppPixelShader != nullptr) - *ppPixelShader = m_state.ps.shader.ref(); - - if (pNumClassInstances != nullptr) + + if (ppPixelShader) + *ppPixelShader = m_state.ps.ref(); + + if (pNumClassInstances) *pNumClassInstances = 0; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSGetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.ps.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, nullptr, nullptr); } - void STDMETHODCALLTYPE D3D11DeviceContext::PSGetConstantBuffers1( + template + void STDMETHODCALLTYPE D3D11CommonContext::PSGetConstantBuffers1( UINT StartSlot, - UINT NumBuffers, + UINT NumBuffers, ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, + UINT* pFirstConstant, UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.ps.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSGetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.ps.shaderResources, + + GetShaderResources( StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::PSGetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::PSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) { D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.ps.samplers, + + GetSamplers( StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetShader( ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances) { D3D10DeviceLock lock = LockContext(); - + auto shader = static_cast(pComputeShader); - - if (NumClassInstances != 0) + + if (NumClassInstances) Logger::err("D3D11: Class instances not supported"); - - if (m_state.cs.shader != shader) { - m_state.cs.shader = shader; + + if (m_state.cs != shader) { + m_state.cs = shader; BindShader(GetCommonShader(shader)); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers( - m_state.cs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers); + StartSlot, NumBuffers, ppConstantBuffers); } - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetConstantBuffers1( - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, const UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - + SetConstantBuffers1( - m_state.cs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - + SetShaderResources( - m_state.cs.shaderResources, - StartSlot, NumViews, - ppShaderResourceViews); + StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) { D3D10DeviceLock lock = LockContext(); - + SetSamplers( - m_state.cs.samplers, - StartSlot, NumSamplers, - ppSamplers); + StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSSetUnorderedAccessViews( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSSetUnorderedAccessViews( UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, @@ -2266,31 +2065,31 @@ namespace dxvk { if (TestRtvUavHazards(0, nullptr, NumUAVs, ppUnorderedAccessViews)) return; - + // Unbind previously bound conflicting UAVs uint32_t uavSlotId = computeUavBinding (DxbcProgramType::ComputeShader, 0); uint32_t ctrSlotId = computeUavCounterBinding(DxbcProgramType::ComputeShader, 0); - int32_t uavId = m_state.cs.uavMask.findNext(0); + int32_t uavId = m_state.uav.mask.findNext(0); while (uavId >= 0) { if (uint32_t(uavId) < StartSlot || uint32_t(uavId) >= StartSlot + NumUAVs) { for (uint32_t i = 0; i < NumUAVs; i++) { auto uav = static_cast(ppUnorderedAccessViews[i]); - if (CheckViewOverlap(uav, m_state.cs.unorderedAccessViews[uavId].ptr())) { - m_state.cs.unorderedAccessViews[uavId] = nullptr; - m_state.cs.uavMask.clr(uavId); + if (CheckViewOverlap(uav, m_state.uav.views[uavId].ptr())) { + m_state.uav.views[uavId] = nullptr; + m_state.uav.mask.clr(uavId); - BindUnorderedAccessView( + BindUnorderedAccessView( uavSlotId + uavId, nullptr, ctrSlotId + uavId, ~0u); } } - uavId = m_state.cs.uavMask.findNext(uavId + 1); + uavId = m_state.uav.mask.findNext(uavId + 1); } else { - uavId = m_state.cs.uavMask.findNext(StartSlot + NumUAVs); + uavId = m_state.uav.mask.findNext(StartSlot + NumUAVs); } } @@ -2299,112 +2098,120 @@ namespace dxvk { auto uav = static_cast(ppUnorderedAccessViews[i]); auto ctr = pUAVInitialCounts ? pUAVInitialCounts[i] : ~0u; - if (m_state.cs.unorderedAccessViews[StartSlot + i] != uav || ctr != ~0u) { - m_state.cs.unorderedAccessViews[StartSlot + i] = uav; - m_state.cs.uavMask.set(StartSlot + i, uav != nullptr); + if (m_state.uav.views[StartSlot + i] != uav || ctr != ~0u) { + m_state.uav.views[StartSlot + i] = uav; + m_state.uav.mask.set(StartSlot + i, uav != nullptr); - BindUnorderedAccessView( + BindUnorderedAccessView( uavSlotId + StartSlot + i, uav, ctrSlotId + StartSlot + i, ctr); - + ResolveCsSrvHazards(uav); } } + + m_state.uav.maxCount = std::clamp(StartSlot + NumUAVs, + m_state.uav.maxCount, uint32_t(m_state.uav.views.size())); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetShader( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetShader( ID3D11ComputeShader** ppComputeShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances) { D3D10DeviceLock lock = LockContext(); - - if (ppComputeShader != nullptr) - *ppComputeShader = m_state.cs.shader.ref(); - - if (pNumClassInstances != nullptr) + + if (ppComputeShader) + *ppComputeShader = m_state.cs.ref(); + + if (pNumClassInstances) *pNumClassInstances = 0; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetConstantBuffers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.cs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, nullptr, nullptr); } - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetConstantBuffers1( - UINT StartSlot, + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetConstantBuffers1( + UINT StartSlot, UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, UINT* pNumConstants) { D3D10DeviceLock lock = LockContext(); - - GetConstantBuffers( - m_state.cs.constantBuffers, - StartSlot, NumBuffers, - ppConstantBuffers, - pFirstConstant, - pNumConstants); + + GetConstantBuffers( + StartSlot, NumBuffers, ppConstantBuffers, + pFirstConstant, pNumConstants); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetShaderResources( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews) { D3D10DeviceLock lock = LockContext(); - - GetShaderResources(m_state.cs.shaderResources, + + GetShaderResources( StartSlot, NumViews, ppShaderResourceViews); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetSamplers( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) { D3D10DeviceLock lock = LockContext(); - - GetSamplers(m_state.cs.samplers, + + GetSamplers( StartSlot, NumSamplers, ppSamplers); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::CSGetUnorderedAccessViews( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CSGetUnorderedAccessViews( UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumUAVs; i++) { - ppUnorderedAccessViews[i] = StartSlot + i < m_state.cs.unorderedAccessViews.size() - ? m_state.cs.unorderedAccessViews[StartSlot + i].ref() + ppUnorderedAccessViews[i] = StartSlot + i < m_state.uav.views.size() + ? m_state.uav.views[StartSlot + i].ref() : nullptr; } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMSetRenderTargets( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMSetRenderTargets( UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) { - OMSetRenderTargetsAndUnorderedAccessViews( + D3D10DeviceLock lock = LockContext(); + + SetRenderTargetsAndUnorderedAccessViews( NumViews, ppRenderTargetViews, pDepthStencilView, NumViews, 0, nullptr, nullptr); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMSetRenderTargetsAndUnorderedAccessViews( UINT NumRTVs, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, @@ -2414,233 +2221,177 @@ namespace dxvk { const UINT* pUAVInitialCounts) { D3D10DeviceLock lock = LockContext(); - if (TestRtvUavHazards(NumRTVs, ppRenderTargetViews, NumUAVs, ppUnorderedAccessViews)) - return; - - bool needsUpdate = false; - - if (likely(NumRTVs != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL)) { - // Native D3D11 does not change the render targets if - // the parameters passed to this method are invalid. - if (!ValidateRenderTargets(NumRTVs, ppRenderTargetViews, pDepthStencilView)) - return; - - for (uint32_t i = 0; i < m_state.om.renderTargetViews.size(); i++) { - auto rtv = i < NumRTVs - ? static_cast(ppRenderTargetViews[i]) - : nullptr; - - if (m_state.om.renderTargetViews[i] != rtv) { - m_state.om.renderTargetViews[i] = rtv; - needsUpdate = true; - ResolveOmSrvHazards(rtv); - - if (NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS) - ResolveOmUavHazards(rtv); - } - } - - auto dsv = static_cast(pDepthStencilView); - - if (m_state.om.depthStencilView != dsv) { - m_state.om.depthStencilView = dsv; - needsUpdate = true; - ResolveOmSrvHazards(dsv); - } - - m_state.om.maxRtv = NumRTVs; - } - - if (unlikely(NumUAVs || m_state.om.maxUav)) { - uint32_t uavSlotId = computeUavBinding (DxbcProgramType::PixelShader, 0); - uint32_t ctrSlotId = computeUavCounterBinding(DxbcProgramType::PixelShader, 0); - - if (likely(NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS)) { - uint32_t newMaxUav = NumUAVs ? UAVStartSlot + NumUAVs : 0; - uint32_t oldMaxUav = std::exchange(m_state.om.maxUav, newMaxUav); - - for (uint32_t i = 0; i < std::max(oldMaxUav, newMaxUav); i++) { - D3D11UnorderedAccessView* uav = nullptr; - uint32_t ctr = ~0u; - - if (i >= UAVStartSlot && i < UAVStartSlot + NumUAVs) { - uav = static_cast(ppUnorderedAccessViews[i - UAVStartSlot]); - ctr = pUAVInitialCounts ? pUAVInitialCounts[i - UAVStartSlot] : ~0u; - } - - if (m_state.ps.unorderedAccessViews[i] != uav || ctr != ~0u) { - m_state.ps.unorderedAccessViews[i] = uav; - - BindUnorderedAccessView( - uavSlotId + i, uav, - ctrSlotId + i, ctr); - - ResolveOmSrvHazards(uav); - - if (NumRTVs == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) - needsUpdate |= ResolveOmRtvHazards(uav); - } - } - } - } - - if (needsUpdate) - BindFramebuffer(); + SetRenderTargetsAndUnorderedAccessViews( + NumRTVs, ppRenderTargetViews, pDepthStencilView, + UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMSetBlendState( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMSetBlendState( ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask) { D3D10DeviceLock lock = LockContext(); - + auto blendState = static_cast(pBlendState); - + if (m_state.om.cbState != blendState || m_state.om.sampleMask != SampleMask) { m_state.om.cbState = blendState; m_state.om.sampleMask = SampleMask; - + ApplyBlendState(); } - + if (BlendFactor != nullptr) { for (uint32_t i = 0; i < 4; i++) m_state.om.blendFactor[i] = BlendFactor[i]; - + ApplyBlendFactor(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMSetDepthStencilState( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMSetDepthStencilState( ID3D11DepthStencilState* pDepthStencilState, UINT StencilRef) { D3D10DeviceLock lock = LockContext(); - + auto depthStencilState = static_cast(pDepthStencilState); - + if (m_state.om.dsState != depthStencilState) { m_state.om.dsState = depthStencilState; ApplyDepthStencilState(); } - + + // The D3D11 runtime only appears to store the low 8 bits, + // and some games rely on this behaviour. Do the same here. + StencilRef &= 0xFF; + if (m_state.om.stencilRef != StencilRef) { m_state.om.stencilRef = StencilRef; ApplyStencilRef(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMGetRenderTargets( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMGetRenderTargets( UINT NumViews, ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView) { - D3D10DeviceLock lock = LockContext(); - - if (ppRenderTargetViews != nullptr) { - for (UINT i = 0; i < NumViews; i++) { - ppRenderTargetViews[i] = i < m_state.om.renderTargetViews.size() - ? m_state.om.renderTargetViews[i].ref() - : nullptr; - } - } - - if (ppDepthStencilView != nullptr) - *ppDepthStencilView = m_state.om.depthStencilView.ref(); + OMGetRenderTargetsAndUnorderedAccessViews( + NumViews, ppRenderTargetViews, ppDepthStencilView, + NumViews, 0, nullptr); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMGetRenderTargetsAndUnorderedAccessViews( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMGetRenderTargetsAndUnorderedAccessViews( UINT NumRTVs, ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews) { - OMGetRenderTargets(NumRTVs, ppRenderTargetViews, ppDepthStencilView); - D3D10DeviceLock lock = LockContext(); - - if (ppUnorderedAccessViews != nullptr) { + + if (ppRenderTargetViews) { + for (UINT i = 0; i < NumRTVs; i++) { + ppRenderTargetViews[i] = i < m_state.om.rtvs.size() + ? m_state.om.rtvs[i].ref() + : nullptr; + } + } + + if (ppDepthStencilView) + *ppDepthStencilView = m_state.om.dsv.ref(); + + if (ppUnorderedAccessViews) { for (UINT i = 0; i < NumUAVs; i++) { - ppUnorderedAccessViews[i] = UAVStartSlot + i < m_state.ps.unorderedAccessViews.size() - ? m_state.ps.unorderedAccessViews[UAVStartSlot + i].ref() + ppUnorderedAccessViews[i] = UAVStartSlot + i < m_state.om.uavs.size() + ? m_state.om.uavs[UAVStartSlot + i].ref() : nullptr; } } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMGetBlendState( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMGetBlendState( ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask) { D3D10DeviceLock lock = LockContext(); - - if (ppBlendState != nullptr) + + if (ppBlendState) *ppBlendState = ref(m_state.om.cbState); - - if (BlendFactor != nullptr) + + if (BlendFactor) std::memcpy(BlendFactor, m_state.om.blendFactor, sizeof(FLOAT) * 4); - - if (pSampleMask != nullptr) + + if (pSampleMask) *pSampleMask = m_state.om.sampleMask; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::OMGetDepthStencilState( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::OMGetDepthStencilState( ID3D11DepthStencilState** ppDepthStencilState, UINT* pStencilRef) { D3D10DeviceLock lock = LockContext(); - - if (ppDepthStencilState != nullptr) + + if (ppDepthStencilState) *ppDepthStencilState = ref(m_state.om.dsState); - - if (pStencilRef != nullptr) + + if (pStencilRef) *pStencilRef = m_state.om.stencilRef; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSSetState(ID3D11RasterizerState* pRasterizerState) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSSetState(ID3D11RasterizerState* pRasterizerState) { D3D10DeviceLock lock = LockContext(); - - auto rasterizerState = static_cast(pRasterizerState); - - bool currScissorEnable = m_state.rs.state != nullptr - ? m_state.rs.state->Desc()->ScissorEnable - : false; - - bool nextScissorEnable = rasterizerState != nullptr - ? rasterizerState->Desc()->ScissorEnable - : false; - if (m_state.rs.state != rasterizerState) { - m_state.rs.state = rasterizerState; + auto currRasterizerState = m_state.rs.state; + auto nextRasterizerState = static_cast(pRasterizerState); - // In D3D11, the rasterizer state defines whether the - // scissor test is enabled, so we have to update the - // scissor rectangles as well. + if (m_state.rs.state != nextRasterizerState) { + m_state.rs.state = nextRasterizerState; ApplyRasterizerState(); + // If necessary, update the rasterizer sample count push constant + uint32_t currSampleCount = currRasterizerState != nullptr ? currRasterizerState->Desc()->ForcedSampleCount : 0; + uint32_t nextSampleCount = nextRasterizerState != nullptr ? nextRasterizerState->Desc()->ForcedSampleCount : 0; + + if (currSampleCount != nextSampleCount) + ApplyRasterizerSampleCount(); + + // In D3D11, the rasterizer state defines whether the scissor test is + // enabled, so if that changes, we need to update scissor rects as well. + bool currScissorEnable = currRasterizerState != nullptr ? currRasterizerState->Desc()->ScissorEnable : false; + bool nextScissorEnable = nextRasterizerState != nullptr ? nextRasterizerState->Desc()->ScissorEnable : false; + if (currScissorEnable != nextScissorEnable) ApplyViewportState(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSSetViewports( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSSetViewports( UINT NumViewports, const D3D11_VIEWPORT* pViewports) { D3D10DeviceLock lock = LockContext(); if (unlikely(NumViewports > m_state.rs.viewports.size())) return; - + bool dirty = m_state.rs.numViewports != NumViewports; m_state.rs.numViewports = NumViewports; - + for (uint32_t i = 0; i < NumViewports; i++) { const D3D11_VIEWPORT& vp = m_state.rs.viewports[i]; @@ -2653,23 +2404,24 @@ namespace dxvk { m_state.rs.viewports[i] = pViewports[i]; } - + if (dirty) ApplyViewportState(); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSSetScissorRects( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSSetScissorRects( UINT NumRects, const D3D11_RECT* pRects) { D3D10DeviceLock lock = LockContext(); if (unlikely(NumRects > m_state.rs.scissors.size())) return; - + bool dirty = m_state.rs.numScissors != NumRects; m_state.rs.numScissors = NumRects; - + for (uint32_t i = 0; i < NumRects; i++) { if (pRects[i].bottom >= pRects[i].top && pRects[i].right >= pRects[i].left) { @@ -2687,22 +2439,24 @@ namespace dxvk { if (m_state.rs.state != nullptr && dirty) { D3D11_RASTERIZER_DESC rsDesc; m_state.rs.state->GetDesc(&rsDesc); - + if (rsDesc.ScissorEnable) ApplyViewportState(); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSGetState(ID3D11RasterizerState** ppRasterizerState) { + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSGetState(ID3D11RasterizerState** ppRasterizerState) { D3D10DeviceLock lock = LockContext(); - - if (ppRasterizerState != nullptr) + + if (ppRasterizerState) *ppRasterizerState = ref(m_state.rs.state); } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSGetViewports( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSGetViewports( UINT* pNumViewports, D3D11_VIEWPORT* pViewports) { D3D10DeviceLock lock = LockContext(); @@ -2727,14 +2481,15 @@ namespace dxvk { *pNumViewports = numWritten; } - - - void STDMETHODCALLTYPE D3D11DeviceContext::RSGetScissorRects( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::RSGetScissorRects( UINT* pNumRects, D3D11_RECT* pRects) { D3D10DeviceLock lock = LockContext(); uint32_t numWritten = m_state.rs.numScissors; - + if (pRects) { numWritten = std::min(numWritten, *pNumRects); @@ -2754,12 +2509,13 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContext::SOSetTargets( + template + void STDMETHODCALLTYPE D3D11CommonContext::SOSetTargets( UINT NumBuffers, ID3D11Buffer* const* ppSOTargets, const UINT* pOffsets) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumBuffers; i++) { D3D11Buffer* buffer = static_cast(ppSOTargets[i]); UINT offset = pOffsets != nullptr ? pOffsets[i] : 0; @@ -2779,37 +2535,39 @@ namespace dxvk { m_state.so.targets[i].offset); } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::SOGetTargets( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::SOGetTargets( UINT NumBuffers, ID3D11Buffer** ppSOTargets) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumBuffers; i++) { ppSOTargets[i] = i < m_state.so.targets.size() ? m_state.so.targets[i].buffer.ref() : nullptr; } } - - - void STDMETHODCALLTYPE D3D11DeviceContext::SOGetTargetsWithOffsets( + + + template + void STDMETHODCALLTYPE D3D11CommonContext::SOGetTargetsWithOffsets( UINT NumBuffers, ID3D11Buffer** ppSOTargets, UINT* pOffsets) { D3D10DeviceLock lock = LockContext(); - + for (uint32_t i = 0; i < NumBuffers; i++) { const bool inRange = i < m_state.so.targets.size(); - if (ppSOTargets != nullptr) { + if (ppSOTargets) { ppSOTargets[i] = inRange ? m_state.so.targets[i].buffer.ref() : nullptr; } - if (pOffsets != nullptr) { + if (pOffsets) { pOffsets[i] = inRange ? m_state.so.targets[i].offset : 0u; @@ -2818,43 +2576,458 @@ namespace dxvk { } - BOOL STDMETHODCALLTYPE D3D11DeviceContext::IsAnnotationEnabled() { - return m_device->instance()->extensions().extDebugUtils; + template + void STDMETHODCALLTYPE D3D11CommonContext::SetPredication( + ID3D11Predicate* pPredicate, + BOOL PredicateValue) { + D3D10DeviceLock lock = LockContext(); + + auto predicate = D3D11Query::FromPredicate(pPredicate); + m_state.pr.predicateObject = predicate; + m_state.pr.predicateValue = PredicateValue; + + static bool s_errorShown = false; + + if (pPredicate && !std::exchange(s_errorShown, true)) + Logger::err("D3D11DeviceContext::SetPredication: Stub"); } - void STDMETHODCALLTYPE D3D11DeviceContext::SetMarkerInt( + template + void STDMETHODCALLTYPE D3D11CommonContext::GetPredication( + ID3D11Predicate** ppPredicate, + BOOL* pPredicateValue) { + D3D10DeviceLock lock = LockContext(); + + if (ppPredicate) + *ppPredicate = D3D11Query::AsPredicate(m_state.pr.predicateObject.ref()); + + if (pPredicateValue) + *pPredicateValue = m_state.pr.predicateValue; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::SetResourceMinLOD( + ID3D11Resource* pResource, + FLOAT MinLOD) { + bool s_errorShown = false; + + if (std::exchange(s_errorShown, true)) + Logger::err("D3D11DeviceContext::SetResourceMinLOD: Not implemented"); + } + + + template + FLOAT STDMETHODCALLTYPE D3D11CommonContext::GetResourceMinLOD(ID3D11Resource* pResource) { + bool s_errorShown = false; + + if (std::exchange(s_errorShown, true)) + Logger::err("D3D11DeviceContext::GetResourceMinLOD: Not implemented"); + + return 0.0f; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::CopyTiles( + ID3D11Resource* pTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pTileRegionStartCoordinate, + const D3D11_TILE_REGION_SIZE* pTileRegionSize, + ID3D11Buffer* pBuffer, + UINT64 BufferStartOffsetInBytes, + UINT Flags) { + D3D10DeviceLock lock = LockContext(); + + if (!pTiledResource || !pBuffer) + return; + + auto buffer = static_cast(pBuffer); + + // Get buffer slice and just forward the call + VkDeviceSize bufferSize = pTileRegionSize->NumTiles * SparseMemoryPageSize; + + if (buffer->Desc()->ByteWidth < BufferStartOffsetInBytes + bufferSize) + return; + + DxvkBufferSlice slice = buffer->GetBufferSlice(BufferStartOffsetInBytes, bufferSize); + + CopyTiledResourceData(pTiledResource, + pTileRegionStartCoordinate, + pTileRegionSize, slice, Flags); + + if (buffer->HasSequenceNumber()) + GetTypedContext()->TrackBufferSequenceNumber(buffer); + } + + + template + HRESULT STDMETHODCALLTYPE D3D11CommonContext::CopyTileMappings( + ID3D11Resource* pDestTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pDestRegionCoordinate, + ID3D11Resource* pSourceTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pSourceRegionCoordinate, + const D3D11_TILE_REGION_SIZE* pTileRegionSize, + UINT Flags) { + D3D10DeviceLock lock = LockContext(); + + if (!pDestTiledResource || !pSourceTiledResource) + return E_INVALIDARG; + + if constexpr (!IsDeferred) + GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint); + + DxvkSparseBindInfo bindInfo; + bindInfo.dstResource = GetPagedResource(pDestTiledResource); + bindInfo.srcResource = GetPagedResource(pSourceTiledResource); + + auto dstPageTable = bindInfo.dstResource->getSparsePageTable(); + auto srcPageTable = bindInfo.srcResource->getSparsePageTable(); + + if (!dstPageTable || !srcPageTable) + return E_INVALIDARG; + + if (pDestRegionCoordinate->Subresource >= dstPageTable->getSubresourceCount() + || pSourceRegionCoordinate->Subresource >= srcPageTable->getSubresourceCount()) + return E_INVALIDARG; + + VkOffset3D dstRegionOffset = { + int32_t(pDestRegionCoordinate->X), + int32_t(pDestRegionCoordinate->Y), + int32_t(pDestRegionCoordinate->Z) }; + + VkOffset3D srcRegionOffset = { + int32_t(pSourceRegionCoordinate->X), + int32_t(pSourceRegionCoordinate->Y), + int32_t(pSourceRegionCoordinate->Z) }; + + VkExtent3D regionExtent = { + uint32_t(pTileRegionSize->Width), + uint32_t(pTileRegionSize->Height), + uint32_t(pTileRegionSize->Depth) }; + + for (uint32_t i = 0; i < pTileRegionSize->NumTiles; i++) { + // We don't know the current tile mappings of either resource since + // this may be called on a deferred context and tile mappings are + // updated on the CS thread, so just resolve the copy in the backend + uint32_t dstTile = dstPageTable->computePageIndex( + pDestRegionCoordinate->Subresource, dstRegionOffset, + regionExtent, !pTileRegionSize->bUseBox, i); + + uint32_t srcTile = srcPageTable->computePageIndex( + pSourceRegionCoordinate->Subresource, srcRegionOffset, + regionExtent, !pTileRegionSize->bUseBox, i); + + if (dstTile >= dstPageTable->getPageCount() + || srcTile >= srcPageTable->getPageCount()) + return E_INVALIDARG; + + DxvkSparseBind bind; + bind.mode = DxvkSparseBindMode::Copy; + bind.dstPage = dstTile; + bind.srcPage = srcTile; + + bindInfo.binds.push_back(bind); + } + + DxvkSparseBindFlags flags = (Flags & D3D11_TILE_MAPPING_NO_OVERWRITE) + ? DxvkSparseBindFlags(DxvkSparseBindFlag::SkipSynchronization) + : DxvkSparseBindFlags(); + + EmitCs([ + cBindInfo = std::move(bindInfo), + cFlags = flags + ] (DxvkContext* ctx) { + ctx->updatePageTable(cBindInfo, cFlags); + }); + + return S_OK; + } + + + template + HRESULT STDMETHODCALLTYPE D3D11CommonContext::ResizeTilePool( + ID3D11Buffer* pTilePool, + UINT64 NewSizeInBytes) { + D3D10DeviceLock lock = LockContext(); + + if (NewSizeInBytes % SparseMemoryPageSize) + return E_INVALIDARG; + + auto buffer = static_cast(pTilePool); + + if (!buffer->IsTilePool()) + return E_INVALIDARG; + + // Perform the resize operation. This is somewhat trivialized + // since all lifetime tracking is done by the backend. + EmitCs([ + cAllocator = buffer->GetSparseAllocator(), + cPageCount = NewSizeInBytes / SparseMemoryPageSize + ] (DxvkContext* ctx) { + cAllocator->setCapacity(cPageCount); + }); + + return S_OK; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::TiledResourceBarrier( + ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, + ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier) { + D3D10DeviceLock lock = LockContext(); + + DxvkGlobalPipelineBarrier srcBarrier = GetTiledResourceDependency(pTiledResourceOrViewAccessBeforeBarrier); + DxvkGlobalPipelineBarrier dstBarrier = GetTiledResourceDependency(pTiledResourceOrViewAccessAfterBarrier); + + if (srcBarrier.stages && dstBarrier.stages) { + EmitCs([ + cSrcBarrier = srcBarrier, + cDstBarrier = dstBarrier + ] (DxvkContext* ctx) { + ctx->emitGraphicsBarrier( + cSrcBarrier.stages, cSrcBarrier.access, + cDstBarrier.stages, cDstBarrier.access); + }); + } + } + + + template + HRESULT STDMETHODCALLTYPE D3D11CommonContext::UpdateTileMappings( + ID3D11Resource* pTiledResource, + UINT NumRegions, + const D3D11_TILED_RESOURCE_COORDINATE* pRegionCoordinates, + const D3D11_TILE_REGION_SIZE* pRegionSizes, + ID3D11Buffer* pTilePool, + UINT NumRanges, + const UINT* pRangeFlags, + const UINT* pRangeTileOffsets, + const UINT* pRangeTileCounts, + UINT Flags) { + D3D10DeviceLock lock = LockContext(); + + if (!pTiledResource || !NumRegions || !NumRanges) + return E_INVALIDARG; + + if constexpr (!IsDeferred) + GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint); + + // Find sparse allocator if the tile pool is defined + DxvkSparseBindInfo bindInfo; + + if (pTilePool) { + auto tilePool = static_cast(pTilePool); + bindInfo.srcAllocator = tilePool->GetSparseAllocator(); + + if (bindInfo.srcAllocator == nullptr) + return E_INVALIDARG; + } + + // Find resource and sparse page table for the given resource + bindInfo.dstResource = GetPagedResource(pTiledResource); + auto pageTable = bindInfo.dstResource->getSparsePageTable(); + + if (!pageTable) + return E_INVALIDARG; + + // Lookup table in case the app tries to bind the same + // page multiple times. We should resolve that here and + // only consider the last bind to any given page. + std::vector bindIndices(pageTable->getPageCount(), ~0u); + + // This function allows pretty much every parameter to be nullptr + // in some way, so initialize some defaults as necessary + D3D11_TILED_RESOURCE_COORDINATE regionCoord = { }; + D3D11_TILE_REGION_SIZE regionSize = { }; + + if (!pRegionSizes) { + regionSize.NumTiles = pRegionCoordinates + ? 1 : pageTable->getPageCount(); + } + + uint32_t rangeFlag = 0u; + uint32_t rangeTileOffset = 0u; + uint32_t rangeTileCount = ~0u; + + // For now, just generate a simple list of tile index to + // page index mappings, and let the backend optimize later + uint32_t regionIdx = 0u; + uint32_t regionTile = 0u; + uint32_t rangeIdx = 0u; + uint32_t rangeTile = 0u; + + while (regionIdx < NumRegions && rangeIdx < NumRanges) { + if (!regionTile) { + if (pRegionCoordinates) + regionCoord = pRegionCoordinates[regionIdx]; + + if (pRegionSizes) + regionSize = pRegionSizes[regionIdx]; + } + + if (!rangeTile) { + if (pRangeFlags) + rangeFlag = pRangeFlags[rangeIdx]; + + if (pRangeTileOffsets) + rangeTileOffset = pRangeTileOffsets[rangeIdx]; + + if (pRangeTileCounts) + rangeTileCount = pRangeTileCounts[rangeIdx]; + } + + if (!(rangeFlag & D3D11_TILE_RANGE_SKIP)) { + if (regionCoord.Subresource >= pageTable->getSubresourceCount()) + return E_INVALIDARG; + + if (regionSize.bUseBox && regionSize.NumTiles != + regionSize.Width * regionSize.Height * regionSize.Depth) + return E_INVALIDARG; + + VkOffset3D regionOffset = { + int32_t(regionCoord.X), + int32_t(regionCoord.Y), + int32_t(regionCoord.Z) }; + + VkExtent3D regionExtent = { + uint32_t(regionSize.Width), + uint32_t(regionSize.Height), + uint32_t(regionSize.Depth) }; + + uint32_t resourceTile = pageTable->computePageIndex(regionCoord.Subresource, + regionOffset, regionExtent, !regionSize.bUseBox, regionTile); + + // Fill in bind info for the current tile + DxvkSparseBind bind = { }; + bind.dstPage = resourceTile; + + if (rangeFlag & D3D11_TILE_RANGE_NULL) { + bind.mode = DxvkSparseBindMode::Null; + } else if (pTilePool) { + bind.mode = DxvkSparseBindMode::Bind; + bind.srcPage = rangeFlag & D3D11_TILE_RANGE_REUSE_SINGLE_TILE + ? rangeTileOffset + : rangeTileOffset + rangeTile; + } else { + return E_INVALIDARG; + } + + // Add bind info to the bind list, overriding + // any existing bind for the same resource page + if (resourceTile < pageTable->getPageCount()) { + if (bindIndices[resourceTile] < bindInfo.binds.size()) + bindInfo.binds[bindIndices[resourceTile]] = bind; + else + bindInfo.binds.push_back(bind); + } + } + + if (++regionTile == regionSize.NumTiles) { + regionTile = 0; + regionIdx += 1; + } + + if (++rangeTile == rangeTileCount) { + rangeTile = 0; + rangeIdx += 1; + } + } + + // Translate flags. The backend benefits from NO_OVERWRITE since + // otherwise we have to serialize execution of the current command + // buffer, the sparse binding operation, and subsequent commands. + // With NO_OVERWRITE, we can execute it more or less asynchronously. + DxvkSparseBindFlags flags = (Flags & D3D11_TILE_MAPPING_NO_OVERWRITE) + ? DxvkSparseBindFlags(DxvkSparseBindFlag::SkipSynchronization) + : DxvkSparseBindFlags(); + + EmitCs([ + cBindInfo = std::move(bindInfo), + cFlags = flags + ] (DxvkContext* ctx) { + ctx->updatePageTable(cBindInfo, cFlags); + }); + + return S_OK; + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::UpdateTiles( + ID3D11Resource* pDestTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pDestTileRegionStartCoordinate, + const D3D11_TILE_REGION_SIZE* pDestTileRegionSize, + const void* pSourceTileData, + UINT Flags) { + D3D10DeviceLock lock = LockContext(); + + if (!pDestTiledResource || !pSourceTileData) + return; + + // Allocate staging memory and copy source data into it, at a + // 64k page granularity. It is not clear whether this behaviour + // is correct in case we're writing to incmplete pages. + VkDeviceSize bufferSize = pDestTileRegionSize->NumTiles * SparseMemoryPageSize; + + DxvkBufferSlice slice = AllocStagingBuffer(bufferSize); + std::memcpy(slice.mapPtr(0), pSourceTileData, bufferSize); + + // Fix up flags. The runtime probably validates this in some + // way but our internal function relies on correct flags anyway. + Flags &= D3D11_TILE_MAPPING_NO_OVERWRITE; + Flags |= D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE; + + CopyTiledResourceData(pDestTiledResource, + pDestTileRegionStartCoordinate, + pDestTileRegionSize, slice, Flags); + } + + + template + BOOL STDMETHODCALLTYPE D3D11CommonContext::IsAnnotationEnabled() { + return m_annotation.GetStatus(); + } + + + template + void STDMETHODCALLTYPE D3D11CommonContext::SetMarkerInt( LPCWSTR pLabel, INT Data) { // Not implemented in the backend, ignore } - void STDMETHODCALLTYPE D3D11DeviceContext::BeginEventInt( + template + void STDMETHODCALLTYPE D3D11CommonContext::BeginEventInt( LPCWSTR pLabel, INT Data) { // Not implemented in the backend, ignore } - void STDMETHODCALLTYPE D3D11DeviceContext::EndEvent() { + template + void STDMETHODCALLTYPE D3D11CommonContext::EndEvent() { // Not implemented in the backend, ignore } - void STDMETHODCALLTYPE D3D11DeviceContext::GetHardwareProtectionState( + template + void STDMETHODCALLTYPE D3D11CommonContext::GetHardwareProtectionState( BOOL* pHwProtectionEnable) { static bool s_errorShown = false; if (!std::exchange(s_errorShown, true)) Logger::err("D3D11DeviceContext::GetHardwareProtectionState: Not implemented"); - + if (pHwProtectionEnable) *pHwProtectionEnable = FALSE; } - - void STDMETHODCALLTYPE D3D11DeviceContext::SetHardwareProtectionState( + + template + void STDMETHODCALLTYPE D3D11CommonContext::SetHardwareProtectionState( BOOL HwProtectionEnable) { static bool s_errorShown = false; @@ -2863,22 +3036,23 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContext::TransitionSurfaceLayout( + template + void STDMETHODCALLTYPE D3D11CommonContext::TransitionSurfaceLayout( IDXGIVkInteropSurface* pSurface, const VkImageSubresourceRange* pSubresources, VkImageLayout OldLayout, VkImageLayout NewLayout) { D3D10DeviceLock lock = LockContext(); - + // Get the underlying D3D11 resource Com resource; - + pSurface->QueryInterface(__uuidof(ID3D11Resource), reinterpret_cast(&resource)); - + // Get the texture from that resource D3D11CommonTexture* texture = GetCommonTexture(resource.ptr()); - + EmitCs([ cImage = texture->GetImage(), cSubresources = *pSubresources, @@ -2890,9 +3064,46 @@ namespace dxvk { cOldLayout, cNewLayout); }); } - - - void D3D11DeviceContext::ApplyInputLayout() { + + + template + DxvkCsChunkRef D3D11CommonContext::AllocCsChunk() { + return m_parent->AllocCsChunk(m_csFlags); + } + + + template + DxvkDataSlice D3D11CommonContext::AllocUpdateBufferSlice(size_t Size) { + constexpr size_t UpdateBufferSize = 1 * 1024 * 1024; + + if (Size >= UpdateBufferSize) { + Rc buffer = new DxvkDataBuffer(Size); + return buffer->alloc(Size); + } else { + if (m_updateBuffer == nullptr) + m_updateBuffer = new DxvkDataBuffer(UpdateBufferSize); + + DxvkDataSlice slice = m_updateBuffer->alloc(Size); + + if (slice.ptr() == nullptr) { + m_updateBuffer = new DxvkDataBuffer(UpdateBufferSize); + slice = m_updateBuffer->alloc(Size); + } + + return slice; + } + } + + + template + DxvkBufferSlice D3D11CommonContext::AllocStagingBuffer( + VkDeviceSize Size) { + return m_staging.alloc(256, Size); + } + + + template + void D3D11CommonContext::ApplyInputLayout() { auto inputLayout = m_state.ia.inputLayout.prvRef(); if (likely(inputLayout != nullptr)) { @@ -2907,9 +3118,10 @@ namespace dxvk { }); } } - - - void D3D11DeviceContext::ApplyPrimitiveTopology() { + + + template + void D3D11CommonContext::ApplyPrimitiveTopology() { D3D11_PRIMITIVE_TOPOLOGY topology = m_state.ia.primitiveTopology; DxvkInputAssemblyState iaState = { }; @@ -2940,9 +3152,10 @@ namespace dxvk { ctx->setInputAssemblyState(iaState); }); } - - - void D3D11DeviceContext::ApplyBlendState() { + + + template + void D3D11CommonContext::ApplyBlendState() { if (m_state.om.cbState != nullptr) { EmitCs([ cBlendState = m_state.om.cbState, @@ -2967,9 +3180,10 @@ namespace dxvk { }); } } - - - void D3D11DeviceContext::ApplyBlendFactor() { + + + template + void D3D11CommonContext::ApplyBlendFactor() { EmitCs([ cBlendConstants = DxvkBlendConstants { m_state.om.blendFactor[0], m_state.om.blendFactor[1], @@ -2978,9 +3192,10 @@ namespace dxvk { ctx->setBlendConstants(cBlendConstants); }); } - - - void D3D11DeviceContext::ApplyDepthStencilState() { + + + template + void D3D11CommonContext::ApplyDepthStencilState() { if (m_state.om.dsState != nullptr) { EmitCs([ cDepthStencilState = m_state.om.dsState @@ -2998,7 +3213,8 @@ namespace dxvk { } - void D3D11DeviceContext::ApplyStencilRef() { + template + void D3D11CommonContext::ApplyStencilRef() { EmitCs([ cStencilRef = m_state.om.stencilRef ] (DxvkContext* ctx) { @@ -3007,7 +3223,8 @@ namespace dxvk { } - void D3D11DeviceContext::ApplyRasterizerState() { + template + void D3D11CommonContext::ApplyRasterizerState() { if (m_state.rs.state != nullptr) { EmitCs([ cRasterizerState = m_state.rs.state @@ -3023,9 +3240,32 @@ namespace dxvk { }); } } - - - void D3D11DeviceContext::ApplyViewportState() { + + + template + void D3D11CommonContext::ApplyRasterizerSampleCount() { + DxbcPushConstants pc; + pc.rasterizerSampleCount = m_state.om.sampleCount; + + if (unlikely(!m_state.om.sampleCount)) { + pc.rasterizerSampleCount = m_state.rs.state + ? m_state.rs.state->Desc()->ForcedSampleCount + : 0; + + if (!pc.rasterizerSampleCount) + pc.rasterizerSampleCount = 1; + } + + EmitCs([ + cPushConstants = pc + ] (DxvkContext* ctx) { + ctx->pushConstants(0, sizeof(cPushConstants), &cPushConstants); + }); + } + + + template + void D3D11CommonContext::ApplyViewportState() { std::array viewports; std::array scissors; @@ -3044,25 +3284,25 @@ namespace dxvk { // corner so we can get away with flipping the viewport. for (uint32_t i = 0; i < m_state.rs.numViewports; i++) { const D3D11_VIEWPORT& vp = m_state.rs.viewports[i]; - + viewports[i] = VkViewport { vp.TopLeftX, vp.Height + vp.TopLeftY, vp.Width, -vp.Height, vp.MinDepth, vp.MaxDepth, }; } - + // Scissor rectangles. Vulkan does not provide an easy way // to disable the scissor test, so we'll have to set scissor // rects that are at least as large as the framebuffer. bool enableScissorTest = false; - + if (m_state.rs.state != nullptr) { D3D11_RASTERIZER_DESC rsDesc; m_state.rs.state->GetDesc(&rsDesc); enableScissorTest = rsDesc.ScissorEnable; } - + for (uint32_t i = 0; i < m_state.rs.numViewports; i++) { if (!enableScissorTest) { scissors[i] = VkRect2D { @@ -3076,23 +3316,23 @@ namespace dxvk { VkExtent2D { 0, 0 } }; } else { D3D11_RECT sr = m_state.rs.scissors[i]; - + VkOffset2D srPosA; srPosA.x = std::max(0, sr.left); srPosA.y = std::max(0, sr.top); - + VkOffset2D srPosB; srPosB.x = std::max(srPosA.x, sr.right); srPosB.y = std::max(srPosA.y, sr.bottom); - + VkExtent2D srSize; srSize.width = uint32_t(srPosB.x - srPosA.x); srSize.height = uint32_t(srPosB.y - srPosA.y); - + scissors[i] = VkRect2D { srPosA, srSize }; } } - + if (likely(viewportCount == 1)) { EmitCs([ cViewport = viewports[0], @@ -3116,84 +3356,136 @@ namespace dxvk { } } - + + template template - void D3D11DeviceContext::BindShader( + void D3D11CommonContext::BindShader( const D3D11CommonShader* pShaderModule) { - // Bind the shader and the ICB at once - EmitCs([ - cSlice = pShaderModule != nullptr - && pShaderModule->GetIcb() != nullptr - ? DxvkBufferSlice(pShaderModule->GetIcb()) - : DxvkBufferSlice(), - cShader = pShaderModule != nullptr - ? pShaderModule->GetShader() - : nullptr - ] (DxvkContext* ctx) { - VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + if (pShaderModule) { + auto buffer = pShaderModule->GetIcb(); + auto shader = pShaderModule->GetShader(); - uint32_t slotId = computeConstantBufferBinding(ShaderStage, - D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT); + if (unlikely(shader->needsLibraryCompile())) + m_device->requestCompileShader(shader); - ctx->bindShader (stage, cShader); - ctx->bindResourceBuffer(slotId, cSlice); - }); + EmitCs([ + cBuffer = std::move(buffer), + cShader = std::move(shader) + ] (DxvkContext* ctx) mutable { + constexpr VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + + uint32_t slotId = computeConstantBufferBinding(ShaderStage, + D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT); + + ctx->bindShader( + Forwarder::move(cShader)); + ctx->bindUniformBuffer(stage, slotId, + Forwarder::move(cBuffer)); + }); + } else { + EmitCs([] (DxvkContext* ctx) { + constexpr VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + + uint32_t slotId = computeConstantBufferBinding(ShaderStage, + D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT); + + ctx->bindShader(nullptr); + ctx->bindUniformBuffer(stage, slotId, DxvkBufferSlice()); + }); + } } - void D3D11DeviceContext::BindFramebuffer() { + static VkDepthBiasRepresentationEXT FormatToDepthBiasRepresentation(DXGI_FORMAT format) { + switch (format) { + default: + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: + case DXGI_FORMAT_D32_FLOAT: + return VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT; + + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_D16_UNORM: + return VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT; + } + } + + template + void D3D11CommonContext::BindFramebuffer() { + DxvkDepthBiasRepresentation depthBiasRepresentation = + { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, + m_device->features().extDepthBiasControl.depthBiasExact }; DxvkRenderTargets attachments; - + uint32_t sampleCount = 0; + // D3D11 doesn't have the concept of a framebuffer object, // so we'll just create a new one every time the render // target bindings are updated. Set up the attachments. - for (UINT i = 0; i < m_state.om.renderTargetViews.size(); i++) { - if (m_state.om.renderTargetViews[i] != nullptr) { + for (UINT i = 0; i < m_state.om.rtvs.size(); i++) { + if (m_state.om.rtvs[i] != nullptr) { attachments.color[i] = { - m_state.om.renderTargetViews[i]->GetImageView(), - m_state.om.renderTargetViews[i]->GetRenderLayout() }; + m_state.om.rtvs[i]->GetImageView(), + m_state.om.rtvs[i]->GetRenderLayout() }; + sampleCount = m_state.om.rtvs[i]->GetSampleCount(); } } - - if (m_state.om.depthStencilView != nullptr) { + + if (m_state.om.dsv != nullptr) { attachments.depth = { - m_state.om.depthStencilView->GetImageView(), - m_state.om.depthStencilView->GetRenderLayout() }; + m_state.om.dsv->GetImageView(), + m_state.om.dsv->GetRenderLayout() }; + sampleCount = m_state.om.dsv->GetSampleCount(); + + if (m_device->features().extDepthBiasControl.leastRepresentableValueForceUnormRepresentation) + depthBiasRepresentation.depthBiasRepresentation = FormatToDepthBiasRepresentation(m_state.om.dsv->GetViewFormat()); } - + // Create and bind the framebuffer object to the context EmitCs([ - cAttachments = std::move(attachments) - ] (DxvkContext* ctx) { - ctx->bindRenderTargets(cAttachments); + cAttachments = std::move(attachments), + cRepresentation = depthBiasRepresentation + ] (DxvkContext* ctx) mutable { + ctx->setDepthBiasRepresentation(cRepresentation); + ctx->bindRenderTargets(Forwarder::move(cAttachments), 0u); }); + + // If necessary, update push constant for the sample count + if (m_state.om.sampleCount != sampleCount) { + m_state.om.sampleCount = sampleCount; + ApplyRasterizerSampleCount(); + } } - - - void D3D11DeviceContext::BindDrawBuffers( + + + template + void D3D11CommonContext::BindDrawBuffers( D3D11Buffer* pBufferForArgs, D3D11Buffer* pBufferForCount) { EmitCs([ cArgBuffer = pBufferForArgs ? pBufferForArgs->GetBufferSlice() : DxvkBufferSlice(), cCntBuffer = pBufferForCount ? pBufferForCount->GetBufferSlice() : DxvkBufferSlice() - ] (DxvkContext* ctx) { - ctx->bindDrawBuffers(cArgBuffer, cCntBuffer); + ] (DxvkContext* ctx) mutable { + ctx->bindDrawBuffers( + Forwarder::move(cArgBuffer), + Forwarder::move(cCntBuffer)); }); } - void D3D11DeviceContext::BindVertexBuffer( + template + void D3D11CommonContext::BindVertexBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset, UINT Stride) { - if (likely(pBuffer != nullptr)) { + if (pBuffer) { EmitCs([ cSlotId = Slot, cBufferSlice = pBuffer->GetBufferSlice(Offset), cStride = Stride - ] (DxvkContext* ctx) { - ctx->bindVertexBuffer(cSlotId, cBufferSlice, cStride); + ] (DxvkContext* ctx) mutable { + ctx->bindVertexBuffer(cSlotId, + Forwarder::move(cBufferSlice), + cStride); }); } else { EmitCs([ @@ -3205,121 +3497,316 @@ namespace dxvk { } - void D3D11DeviceContext::BindIndexBuffer( + template + void D3D11CommonContext::BindVertexBufferRange( + UINT Slot, + D3D11Buffer* pBuffer, + UINT Offset, + UINT Stride) { + if (pBuffer) { + VkDeviceSize offset = Offset; + VkDeviceSize length = pBuffer->GetRemainingSize(Offset); + + EmitCs([ + cSlotId = Slot, + cBufferOffset = offset, + cBufferLength = length, + cStride = Stride + ] (DxvkContext* ctx) mutable { + ctx->bindVertexBufferRange(cSlotId, + cBufferOffset, cBufferLength, cStride); + }); + } + } + + + template + void D3D11CommonContext::BindIndexBuffer( D3D11Buffer* pBuffer, UINT Offset, DXGI_FORMAT Format) { VkIndexType indexType = Format == DXGI_FORMAT_R16_UINT ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32; - - EmitCs([ - cBufferSlice = pBuffer != nullptr ? pBuffer->GetBufferSlice(Offset) : DxvkBufferSlice(), - cIndexType = indexType - ] (DxvkContext* ctx) { - ctx->bindIndexBuffer(cBufferSlice, cIndexType); - }); - } - - void D3D11DeviceContext::BindXfbBuffer( + if (pBuffer) { + EmitCs([ + cBufferSlice = pBuffer->GetBufferSlice(Offset), + cIndexType = indexType + ] (DxvkContext* ctx) mutable { + ctx->bindIndexBuffer( + Forwarder::move(cBufferSlice), + cIndexType); + }); + } else { + EmitCs([ + cIndexType = indexType + ] (DxvkContext* ctx) { + ctx->bindIndexBuffer(DxvkBufferSlice(), cIndexType); + }); + } + } + + + template + void D3D11CommonContext::BindIndexBufferRange( + D3D11Buffer* pBuffer, + UINT Offset, + DXGI_FORMAT Format) { + if (pBuffer) { + VkIndexType indexType = Format == DXGI_FORMAT_R16_UINT + ? VK_INDEX_TYPE_UINT16 + : VK_INDEX_TYPE_UINT32; + + VkDeviceSize offset = Offset; + VkDeviceSize length = pBuffer->GetRemainingSize(Offset); + + EmitCs([ + cBufferOffset = offset, + cBufferLength = length, + cIndexType = indexType + ] (DxvkContext* ctx) mutable { + ctx->bindIndexBufferRange( + cBufferOffset, cBufferLength, + cIndexType); + }); + } + } + + + template + void D3D11CommonContext::BindXfbBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset) { - DxvkBufferSlice bufferSlice; - DxvkBufferSlice counterSlice; - - if (pBuffer != nullptr) { - bufferSlice = pBuffer->GetBufferSlice(); - counterSlice = pBuffer->GetSOCounter(); + if (pBuffer) { + EmitCs([ + cSlotId = Slot, + cOffset = Offset, + cBufferSlice = pBuffer->GetBufferSlice(), + cCounterSlice = pBuffer->GetSOCounter() + ] (DxvkContext* ctx) mutable { + if (cCounterSlice.defined() && cOffset != ~0u) { + ctx->updateBuffer( + cCounterSlice.buffer(), + cCounterSlice.offset(), + sizeof(cOffset), + &cOffset); + } + + ctx->bindXfbBuffer(cSlotId, + Forwarder::move(cBufferSlice), + Forwarder::move(cCounterSlice)); + }); + } else { + EmitCs([ + cSlotId = Slot + ] (DxvkContext* ctx) { + ctx->bindXfbBuffer(cSlotId, + DxvkBufferSlice(), + DxvkBufferSlice()); + }); } - - EmitCs([ - cSlotId = Slot, - cOffset = Offset, - cBufferSlice = bufferSlice, - cCounterSlice = counterSlice - ] (DxvkContext* ctx) { - if (cCounterSlice.defined() && cOffset != ~0u) { - ctx->updateBuffer( - cCounterSlice.buffer(), - cCounterSlice.offset(), - sizeof(cOffset), - &cOffset); - } - - ctx->bindXfbBuffer(cSlotId, cBufferSlice, cCounterSlice); - }); } - void D3D11DeviceContext::BindConstantBuffer( + template + template + void D3D11CommonContext::BindConstantBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset, UINT Length) { - EmitCs([ - cSlotId = Slot, - cBufferSlice = Length ? pBuffer->GetBufferSlice(16 * Offset, 16 * Length) : DxvkBufferSlice() - ] (DxvkContext* ctx) { - ctx->bindResourceBuffer(cSlotId, cBufferSlice); - }); + if (pBuffer) { + EmitCs([ + cSlotId = Slot, + cBufferSlice = pBuffer->GetBufferSlice(16 * Offset, 16 * Length) + ] (DxvkContext* ctx) mutable { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindUniformBuffer(stage, cSlotId, + Forwarder::move(cBufferSlice)); + }); + } else { + EmitCs([ + cSlotId = Slot + ] (DxvkContext* ctx) { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindUniformBuffer(stage, cSlotId, DxvkBufferSlice()); + }); + } } - void D3D11DeviceContext::BindSampler( + template + template + void D3D11CommonContext::BindConstantBufferRange( + UINT Slot, + UINT Offset, + UINT Length) { + EmitCs([ + cSlotId = Slot, + cOffset = 16 * Offset, + cLength = 16 * Length + ] (DxvkContext* ctx) { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindUniformBufferRange(stage, cSlotId, cOffset, cLength); + }); + } + + + template + template + void D3D11CommonContext::BindSampler( UINT Slot, D3D11SamplerState* pSampler) { - EmitCs([ - cSlotId = Slot, - cSampler = pSampler != nullptr ? pSampler->GetDXVKSampler() : nullptr - ] (DxvkContext* ctx) { - ctx->bindResourceSampler(cSlotId, cSampler); - }); + if (pSampler) { + EmitCs([ + cSlotId = Slot, + cSampler = pSampler->GetDXVKSampler() + ] (DxvkContext* ctx) mutable { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindResourceSampler(stage, cSlotId, + Forwarder::move(cSampler)); + }); + } else { + EmitCs([ + cSlotId = Slot + ] (DxvkContext* ctx) { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindResourceSampler(stage, cSlotId, nullptr); + }); + } } - - - void D3D11DeviceContext::BindShaderResource( + + + template + template + void D3D11CommonContext::BindShaderResource( UINT Slot, D3D11ShaderResourceView* pResource) { - EmitCs([ - cSlotId = Slot, - cImageView = pResource != nullptr ? pResource->GetImageView() : nullptr, - cBufferView = pResource != nullptr ? pResource->GetBufferView() : nullptr - ] (DxvkContext* ctx) { - ctx->bindResourceView(cSlotId, cImageView, cBufferView); - }); + if (pResource) { + if (pResource->GetViewInfo().Dimension != D3D11_RESOURCE_DIMENSION_BUFFER) { + EmitCs([ + cSlotId = Slot, + cView = pResource->GetImageView() + ] (DxvkContext* ctx) mutable { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindResourceImageView(stage, cSlotId, + Forwarder::move(cView)); + }); + } else { + EmitCs([ + cSlotId = Slot, + cView = pResource->GetBufferView() + ] (DxvkContext* ctx) mutable { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindResourceBufferView(stage, cSlotId, + Forwarder::move(cView)); + }); + } + } else { + EmitCs([ + cSlotId = Slot + ] (DxvkContext* ctx) { + VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindResourceImageView(stage, cSlotId, nullptr); + }); + } } - - - void D3D11DeviceContext::BindUnorderedAccessView( + + + template + template + void D3D11CommonContext::BindUnorderedAccessView( UINT UavSlot, D3D11UnorderedAccessView* pUav, UINT CtrSlot, UINT Counter) { - EmitCs([ - cUavSlotId = UavSlot, - cCtrSlotId = CtrSlot, - cImageView = pUav != nullptr ? pUav->GetImageView() : nullptr, - cBufferView = pUav != nullptr ? pUav->GetBufferView() : nullptr, - cCounterSlice = pUav != nullptr ? pUav->GetCounterSlice() : DxvkBufferSlice(), - cCounterValue = Counter - ] (DxvkContext* ctx) { - if (cCounterSlice.defined() && cCounterValue != ~0u) { - ctx->updateBuffer( - cCounterSlice.buffer(), - cCounterSlice.offset(), - sizeof(uint32_t), - &cCounterValue); - } + if (pUav) { + if (pUav->GetViewInfo().Dimension == D3D11_RESOURCE_DIMENSION_BUFFER) { + EmitCs([ + cUavSlotId = UavSlot, + cCtrSlotId = CtrSlot, + cBufferView = pUav->GetBufferView(), + cCounterView = pUav->GetCounterView(), + cCounterValue = Counter + ] (DxvkContext* ctx) mutable { + VkShaderStageFlags stages = ShaderStage == DxbcProgramType::ComputeShader + ? VK_SHADER_STAGE_COMPUTE_BIT + : VK_SHADER_STAGE_ALL_GRAPHICS; - ctx->bindResourceView (cUavSlotId, cImageView, cBufferView); - ctx->bindResourceBuffer (cCtrSlotId, cCounterSlice); - }); + if (cCounterView != nullptr && cCounterValue != ~0u) { + auto counterSlice = cCounterView->slice(); + + ctx->updateBuffer( + counterSlice.buffer(), + counterSlice.offset(), + sizeof(uint32_t), + &cCounterValue); + } + + ctx->bindResourceBufferView(stages, cUavSlotId, + Forwarder::move(cBufferView)); + ctx->bindResourceBufferView(stages, cCtrSlotId, + Forwarder::move(cCounterView)); + }); + } else { + EmitCs([ + cUavSlotId = UavSlot, + cCtrSlotId = CtrSlot, + cImageView = pUav->GetImageView() + ] (DxvkContext* ctx) mutable { + VkShaderStageFlags stages = ShaderStage == DxbcProgramType::ComputeShader + ? VK_SHADER_STAGE_COMPUTE_BIT + : VK_SHADER_STAGE_ALL_GRAPHICS; + + ctx->bindResourceImageView(stages, cUavSlotId, + Forwarder::move(cImageView)); + ctx->bindResourceBufferView(stages, cCtrSlotId, nullptr); + }); + } + } else { + EmitCs([ + cUavSlotId = UavSlot, + cCtrSlotId = CtrSlot + ] (DxvkContext* ctx) { + VkShaderStageFlags stages = ShaderStage == DxbcProgramType::ComputeShader + ? VK_SHADER_STAGE_COMPUTE_BIT + : VK_SHADER_STAGE_ALL_GRAPHICS; + + ctx->bindResourceImageView(stages, cUavSlotId, nullptr); + ctx->bindResourceBufferView(stages, cCtrSlotId, nullptr); + }); + } } - - - void D3D11DeviceContext::CopyBuffer( + + + template + VkClearValue D3D11CommonContext::ConvertColorValue( + const FLOAT Color[4], + const DxvkFormatInfo* pFormatInfo) { + VkClearValue result; + + if (pFormatInfo->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) { + for (uint32_t i = 0; i < 4; i++) { + if (pFormatInfo->flags.test(DxvkFormatFlag::SampledUInt)) + result.color.uint32[i] = uint32_t(std::max(0.0f, Color[i])); + else if (pFormatInfo->flags.test(DxvkFormatFlag::SampledSInt)) + result.color.int32[i] = int32_t(Color[i]); + else + result.color.float32[i] = Color[i]; + } + } else { + result.depthStencil.depth = Color[0]; + result.depthStencil.stencil = 0; + } + + return result; + } + + + template + void D3D11CommonContext::CopyBuffer( D3D11Buffer* pDstBuffer, VkDeviceSize DstOffset, D3D11Buffer* pSrcBuffer, @@ -3356,13 +3843,14 @@ namespace dxvk { }); if (pDstBuffer->HasSequenceNumber()) - TrackBufferSequenceNumber(pDstBuffer); + GetTypedContext()->TrackBufferSequenceNumber(pDstBuffer); if (pSrcBuffer->HasSequenceNumber()) - TrackBufferSequenceNumber(pSrcBuffer); + GetTypedContext()->TrackBufferSequenceNumber(pSrcBuffer); } - void D3D11DeviceContext::CopyImage( + template + void D3D11CommonContext::CopyImage( D3D11CommonTexture* pDstTexture, const VkImageSubresourceLayers* pDstLayers, VkOffset3D DstOffset, @@ -3371,20 +3859,16 @@ namespace dxvk { VkOffset3D SrcOffset, VkExtent3D SrcExtent) { // Image formats must be size-compatible - auto dstFormatInfo = imageFormatInfo(pDstTexture->GetPackedFormat()); - auto srcFormatInfo = imageFormatInfo(pSrcTexture->GetPackedFormat()); + auto dstFormatInfo = lookupFormatInfo(pDstTexture->GetPackedFormat()); + auto srcFormatInfo = lookupFormatInfo(pSrcTexture->GetPackedFormat()); - if (dstFormatInfo->elementSize != srcFormatInfo->elementSize) { - Logger::err("D3D11: CopyImage: Incompatible texel size"); + if (dstFormatInfo->elementSize != srcFormatInfo->elementSize) return; - } // Sample counts must match - if (pDstTexture->Desc()->SampleDesc.Count != pSrcTexture->Desc()->SampleDesc.Count) { - Logger::err("D3D11: CopyImage: Incompatible sample count"); + if (pDstTexture->Desc()->SampleDesc.Count != pSrcTexture->Desc()->SampleDesc.Count) return; - } - + // Obviously, the copy region must not be empty VkExtent3D dstMipExtent = pDstTexture->MipLevelExtent(pDstLayers->mipLevel); VkExtent3D srcMipExtent = pSrcTexture->MipLevelExtent(pSrcLayers->mipLevel); @@ -3401,19 +3885,17 @@ namespace dxvk { // Don't perform the copy if the offsets aren't block-aligned if (!util::isBlockAligned(SrcOffset, srcFormatInfo->blockSize) - || !util::isBlockAligned(DstOffset, dstFormatInfo->blockSize)) { - Logger::err(str::format("D3D11: CopyImage: Unaligned block offset")); + || !util::isBlockAligned(DstOffset, dstFormatInfo->blockSize)) return; - } // Clamp the image region in order to avoid out-of-bounds access VkExtent3D blockCount = util::computeBlockCount(SrcExtent, srcFormatInfo->blockSize); VkExtent3D dstBlockCount = util::computeMaxBlockCount(DstOffset, dstMipExtent, dstFormatInfo->blockSize); VkExtent3D srcBlockCount = util::computeMaxBlockCount(SrcOffset, srcMipExtent, srcFormatInfo->blockSize); - + blockCount = util::minExtent3D(blockCount, dstBlockCount); blockCount = util::minExtent3D(blockCount, srcBlockCount); - + SrcExtent = util::computeBlockExtent(blockCount, srcFormatInfo->blockSize); SrcExtent = util::snapExtent3D(SrcOffset, SrcExtent, srcMipExtent); @@ -3596,21 +4078,110 @@ namespace dxvk { if (pDstTexture->HasSequenceNumber()) { for (uint32_t i = 0; i < pDstLayers->layerCount; i++) { - TrackTextureSequenceNumber(pDstTexture, D3D11CalcSubresource( + GetTypedContext()->TrackTextureSequenceNumber(pDstTexture, D3D11CalcSubresource( pDstLayers->mipLevel, pDstLayers->baseArrayLayer + i, pDstTexture->Desc()->MipLevels)); } } if (pSrcTexture->HasSequenceNumber()) { for (uint32_t i = 0; i < pSrcLayers->layerCount; i++) { - TrackTextureSequenceNumber(pSrcTexture, D3D11CalcSubresource( + GetTypedContext()->TrackTextureSequenceNumber(pSrcTexture, D3D11CalcSubresource( pSrcLayers->mipLevel, pSrcLayers->baseArrayLayer + i, pSrcTexture->Desc()->MipLevels)); } } } - void D3D11DeviceContext::DiscardBuffer( + template + void D3D11CommonContext::CopyTiledResourceData( + ID3D11Resource* pResource, + const D3D11_TILED_RESOURCE_COORDINATE* pRegionCoordinate, + const D3D11_TILE_REGION_SIZE* pRegionSize, + DxvkBufferSlice BufferSlice, + UINT Flags) { + Rc resource = GetPagedResource(pResource); + + // Do some validation based on page table properties + auto pageTable = resource->getSparsePageTable(); + + if (!pageTable) + return; + + if (pRegionSize->bUseBox && pRegionSize->NumTiles != + pRegionSize->Width * pRegionSize->Height * pRegionSize->Depth) + return; + + if (pRegionSize->NumTiles > pageTable->getPageCount()) + return; + + // Ignore call if buffer access would be out of bounds + VkDeviceSize bufferSize = pRegionSize->NumTiles * SparseMemoryPageSize; + + if (BufferSlice.length() < bufferSize) + return; + + // Compute list of tile indices to copy + std::vector tiles(pRegionSize->NumTiles); + + for (uint32_t i = 0; i < pRegionSize->NumTiles; i++) { + VkOffset3D regionOffset = { + int32_t(pRegionCoordinate->X), + int32_t(pRegionCoordinate->Y), + int32_t(pRegionCoordinate->Z) }; + + VkExtent3D regionExtent = { + uint32_t(pRegionSize->Width), + uint32_t(pRegionSize->Height), + uint32_t(pRegionSize->Depth) }; + + uint32_t tile = pageTable->computePageIndex( + pRegionCoordinate->Subresource, regionOffset, + regionExtent, !pRegionSize->bUseBox, i); + + // Check that the tile is valid and not part of the mip tail + auto tileInfo = pageTable->getPageInfo(tile); + + if (tileInfo.type != DxvkSparsePageType::Buffer + && tileInfo.type != DxvkSparsePageType::Image) + return; + + tiles[i] = tile; + } + + // If D3D12 is anything to go by, not passing this flag will trigger + // the other code path, regardless of whether TO_LINEAR_BUFFER is set. + if (Flags & D3D11_TILE_COPY_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE) { + EmitCs([ + cResource = std::move(resource), + cTiles = std::move(tiles), + cBuffer = std::move(BufferSlice) + ] (DxvkContext* ctx) { + ctx->copySparsePagesFromBuffer( + cResource, + cTiles.size(), + cTiles.data(), + cBuffer.buffer(), + cBuffer.offset()); + }); + } else { + EmitCs([ + cResource = std::move(resource), + cTiles = std::move(tiles), + cBuffer = std::move(BufferSlice) + ] (DxvkContext* ctx) { + ctx->copySparsePagesToBuffer( + cBuffer.buffer(), + cBuffer.offset(), + cResource, + cTiles.size(), + cTiles.data()); + }); + } + } + + + template + void D3D11CommonContext::DiscardBuffer( ID3D11Resource* pResource) { auto buffer = static_cast(pResource); @@ -3623,7 +4194,8 @@ namespace dxvk { } - void D3D11DeviceContext::DiscardTexture( + template + void D3D11CommonContext::DiscardTexture( ID3D11Resource* pResource, UINT Subresource) { auto texture = GetCommonTexture(pResource); @@ -3637,7 +4209,866 @@ namespace dxvk { } - void D3D11DeviceContext::UpdateBuffer( + template + template + void D3D11CommonContext::GetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, + UINT* pNumConstants) { + const auto& bindings = m_state.cbv[ShaderStage]; + + for (uint32_t i = 0; i < NumBuffers; i++) { + const bool inRange = StartSlot + i < bindings.buffers.size(); + + if (ppConstantBuffers) { + ppConstantBuffers[i] = inRange + ? bindings.buffers[StartSlot + i].buffer.ref() + : nullptr; + } + + if (pFirstConstant) { + pFirstConstant[i] = inRange + ? bindings.buffers[StartSlot + i].constantOffset + : 0u; + } + + if (pNumConstants) { + pNumConstants[i] = inRange + ? bindings.buffers[StartSlot + i].constantCount + : 0u; + } + } + } + + + template + template + void D3D11CommonContext::GetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView** ppShaderResourceViews) { + const auto& bindings = m_state.srv[ShaderStage]; + + for (uint32_t i = 0; i < NumViews; i++) { + ppShaderResourceViews[i] = StartSlot + i < bindings.views.size() + ? bindings.views[StartSlot + i].ref() + : nullptr; + } + } + + + template + template + void D3D11CommonContext::GetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState** ppSamplers) { + const auto& bindings = m_state.samplers[ShaderStage]; + + for (uint32_t i = 0; i < NumSamplers; i++) { + ppSamplers[i] = StartSlot + i < bindings.samplers.size() + ? ref(bindings.samplers[StartSlot + i]) + : nullptr; + } + } + + + template + DxvkGlobalPipelineBarrier D3D11CommonContext::GetTiledResourceDependency( + ID3D11DeviceChild* pObject) { + if (!pObject) { + DxvkGlobalPipelineBarrier result; + result.stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + result.access = VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT; + return result; + } else { + Com resource; + + if (FAILED(pObject->QueryInterface(IID_PPV_ARGS(&resource)))) { + Com view; + + if (FAILED(pObject->QueryInterface(IID_PPV_ARGS(&view)))) + return DxvkGlobalPipelineBarrier(); + + view->GetResource(&resource); + } + + D3D11CommonTexture* texture = GetCommonTexture(resource.ptr()); + + if (texture) { + Rc image = texture->GetImage(); + + DxvkGlobalPipelineBarrier result; + result.stages = image->info().stages; + result.access = image->info().access; + return result; + } else { + Rc buffer = static_cast(resource.ptr())->GetBuffer(); + + if (buffer == nullptr) + return DxvkGlobalPipelineBarrier(); + + DxvkGlobalPipelineBarrier result; + result.stages = buffer->info().stages; + result.access = buffer->info().access; + return result; + } + } + } + + + template + D3D11MaxUsedBindings D3D11CommonContext::GetMaxUsedBindings() { + D3D11MaxUsedBindings result; + + for (uint32_t i = 0; i < result.stages.size(); i++) { + auto stage = DxbcProgramType(i); + + result.stages[i].cbvCount = m_state.cbv[stage].maxCount; + result.stages[i].srvCount = m_state.srv[stage].maxCount; + result.stages[i].uavCount = 0; + result.stages[i].samplerCount = m_state.samplers[stage].maxCount; + result.stages[i].reserved = 0; + } + + result.stages[uint32_t(DxbcProgramType::PixelShader)].uavCount = m_state.om.maxUav; + result.stages[uint32_t(DxbcProgramType::ComputeShader)].uavCount = m_state.uav.maxCount; + + result.vbCount = m_state.ia.maxVbCount; + result.soCount = D3D11_SO_BUFFER_SLOT_COUNT; + return result; + } + + + template + void D3D11CommonContext::ResetCommandListState() { + EmitCs([ + cUsedBindings = GetMaxUsedBindings() + ] (DxvkContext* ctx) { + // Reset render targets + ctx->bindRenderTargets(DxvkRenderTargets(), 0u); + + // Reset vertex input state + ctx->setInputLayout(0, nullptr, 0, nullptr); + + // Reset render states + DxvkInputAssemblyState iaState; + InitDefaultPrimitiveTopology(&iaState); + + DxvkDepthStencilState dsState; + InitDefaultDepthStencilState(&dsState); + + DxvkRasterizerState rsState; + InitDefaultRasterizerState(&rsState); + + DxvkBlendMode cbState; + DxvkLogicOpState loState; + DxvkMultisampleState msState; + InitDefaultBlendState(&cbState, &loState, &msState, D3D11_DEFAULT_SAMPLE_MASK); + + ctx->setInputAssemblyState(iaState); + ctx->setDepthStencilState(dsState); + ctx->setRasterizerState(rsState); + ctx->setLogicOpState(loState); + ctx->setMultisampleState(msState); + + for (uint32_t i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++) + ctx->setBlendMode(i, cbState); + + // Reset dynamic states + ctx->setBlendConstants(DxvkBlendConstants { 1.0f, 1.0f, 1.0f, 1.0f }); + ctx->setStencilReference(D3D11_DEFAULT_STENCIL_REFERENCE); + + // Reset viewports + auto viewport = VkViewport(); + auto scissor = VkRect2D(); + + ctx->setViewports(1, &viewport, &scissor); + + // Unbind indirect draw buffer + ctx->bindDrawBuffers(DxvkBufferSlice(), DxvkBufferSlice()); + + // Unbind index and vertex buffers + ctx->bindIndexBuffer(DxvkBufferSlice(), VK_INDEX_TYPE_UINT32); + + for (uint32_t i = 0; i < cUsedBindings.vbCount; i++) + ctx->bindVertexBuffer(i, DxvkBufferSlice(), 0); + + // Unbind transform feedback buffers + for (uint32_t i = 0; i < cUsedBindings.soCount; i++) + ctx->bindXfbBuffer(i, DxvkBufferSlice(), DxvkBufferSlice()); + + // Unbind all shaders + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + + // Unbind per-shader stage resources + for (uint32_t i = 0; i < 6; i++) { + auto programType = DxbcProgramType(i); + auto stage = GetShaderStage(programType); + + // Unbind constant buffers, including the shader's ICB + auto cbSlotId = computeConstantBufferBinding(programType, 0); + ctx->bindUniformBuffer(stage, cbSlotId + D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, DxvkBufferSlice()); + + for (uint32_t j = 0; j < cUsedBindings.stages[i].cbvCount; j++) + ctx->bindUniformBuffer(stage, cbSlotId + j, DxvkBufferSlice()); + + // Unbind shader resource views + auto srvSlotId = computeSrvBinding(programType, 0); + + for (uint32_t j = 0; j < cUsedBindings.stages[i].srvCount; j++) + ctx->bindResourceImageView(stage, srvSlotId + j, nullptr); + + // Unbind texture samplers + auto samplerSlotId = computeSamplerBinding(programType, 0); + + for (uint32_t j = 0; j < cUsedBindings.stages[i].samplerCount; j++) + ctx->bindResourceSampler(stage, samplerSlotId + j, nullptr); + + // Unbind UAVs for supported stages + if (programType == DxbcProgramType::PixelShader + || programType == DxbcProgramType::ComputeShader) { + VkShaderStageFlags stages = programType == DxbcProgramType::PixelShader + ? VK_SHADER_STAGE_ALL_GRAPHICS + : VK_SHADER_STAGE_COMPUTE_BIT; + + auto uavSlotId = computeUavBinding(programType, 0); + auto ctrSlotId = computeUavCounterBinding(programType, 0); + + for (uint32_t j = 0; j < cUsedBindings.stages[i].uavCount; j++) { + ctx->bindResourceImageView(stages, uavSlotId, nullptr); + ctx->bindResourceBufferView(stages, ctrSlotId, nullptr); + } + } + } + + // Initialize push constants + DxbcPushConstants pc; + pc.rasterizerSampleCount = 1; + ctx->pushConstants(0, sizeof(pc), &pc); + }); + } + + + template + void D3D11CommonContext::ResetContextState() { + // Reset shaders + m_state.vs = nullptr; + m_state.hs = nullptr; + m_state.ds = nullptr; + m_state.gs = nullptr; + m_state.ps = nullptr; + m_state.cs = nullptr; + + // Reset render state + m_state.id.reset(); + m_state.ia.reset(); + m_state.om.reset(); + m_state.rs.reset(); + m_state.so.reset(); + m_state.pr.reset(); + + // Reset resource bindings + m_state.cbv.reset(); + m_state.srv.reset(); + m_state.uav.reset(); + m_state.samplers.reset(); + } + + + template + void D3D11CommonContext::ResetStagingBuffer() { + m_staging.reset(); + } + + + template + template + void D3D11CommonContext::ResolveSrvHazards( + T* pView) { + auto& bindings = m_state.srv[ShaderStage]; + + uint32_t slotId = computeSrvBinding(ShaderStage, 0); + int32_t srvId = bindings.hazardous.findNext(0); + + while (srvId >= 0) { + auto srv = bindings.views[srvId].ptr(); + + if (likely(srv && srv->TestHazards())) { + bool hazard = CheckViewOverlap(pView, srv); + + if (unlikely(hazard)) { + bindings.views[srvId] = nullptr; + bindings.hazardous.clr(srvId); + + BindShaderResource(slotId + srvId, nullptr); + } + } else { + // Avoid further redundant iterations + bindings.hazardous.clr(srvId); + } + + srvId = bindings.hazardous.findNext(srvId + 1); + } + } + + + template + template + void D3D11CommonContext::ResolveCsSrvHazards( + T* pView) { + if (!pView) return; + ResolveSrvHazards(pView); + } + + + template + template + void D3D11CommonContext::ResolveOmSrvHazards( + T* pView) { + if (!pView) return; + ResolveSrvHazards(pView); + ResolveSrvHazards(pView); + ResolveSrvHazards(pView); + ResolveSrvHazards(pView); + ResolveSrvHazards(pView); + } + + + template + bool D3D11CommonContext::ResolveOmRtvHazards( + D3D11UnorderedAccessView* pView) { + if (!pView || !pView->HasBindFlag(D3D11_BIND_RENDER_TARGET)) + return false; + + bool hazard = false; + + if (CheckViewOverlap(pView, m_state.om.dsv.ptr())) { + m_state.om.dsv = nullptr; + hazard = true; + } + + for (uint32_t i = 0; i < m_state.om.maxRtv; i++) { + if (CheckViewOverlap(pView, m_state.om.rtvs[i].ptr())) { + m_state.om.rtvs[i] = nullptr; + hazard = true; + } + } + + return hazard; + } + + + template + void D3D11CommonContext::ResolveOmUavHazards( + D3D11RenderTargetView* pView) { + if (!pView || !pView->HasBindFlag(D3D11_BIND_UNORDERED_ACCESS)) + return; + + uint32_t uavSlotId = computeUavBinding (DxbcProgramType::PixelShader, 0); + uint32_t ctrSlotId = computeUavCounterBinding(DxbcProgramType::PixelShader, 0); + + for (uint32_t i = 0; i < m_state.om.maxUav; i++) { + if (CheckViewOverlap(pView, m_state.om.uavs[i].ptr())) { + m_state.om.uavs[i] = nullptr; + + BindUnorderedAccessView( + uavSlotId + i, nullptr, + ctrSlotId + i, ~0u); + } + } + } + + + template + void D3D11CommonContext::RestoreCommandListState() { + BindFramebuffer(); + + BindShader(GetCommonShader(m_state.vs.ptr())); + BindShader(GetCommonShader(m_state.hs.ptr())); + BindShader(GetCommonShader(m_state.ds.ptr())); + BindShader(GetCommonShader(m_state.gs.ptr())); + BindShader(GetCommonShader(m_state.ps.ptr())); + BindShader(GetCommonShader(m_state.cs.ptr())); + + ApplyInputLayout(); + ApplyPrimitiveTopology(); + ApplyBlendState(); + ApplyBlendFactor(); + ApplyDepthStencilState(); + ApplyStencilRef(); + ApplyRasterizerState(); + ApplyRasterizerSampleCount(); + ApplyViewportState(); + + BindDrawBuffers( + m_state.id.argBuffer.ptr(), + m_state.id.cntBuffer.ptr()); + + BindIndexBuffer( + m_state.ia.indexBuffer.buffer.ptr(), + m_state.ia.indexBuffer.offset, + m_state.ia.indexBuffer.format); + + for (uint32_t i = 0; i < m_state.ia.maxVbCount; i++) { + BindVertexBuffer(i, + m_state.ia.vertexBuffers[i].buffer.ptr(), + m_state.ia.vertexBuffers[i].offset, + m_state.ia.vertexBuffers[i].stride); + } + + for (uint32_t i = 0; i < m_state.so.targets.size(); i++) + BindXfbBuffer(i, m_state.so.targets[i].buffer.ptr(), ~0u); + + RestoreConstantBuffers(); + RestoreConstantBuffers(); + RestoreConstantBuffers(); + RestoreConstantBuffers(); + RestoreConstantBuffers(); + RestoreConstantBuffers(); + + RestoreShaderResources(); + RestoreShaderResources(); + RestoreShaderResources(); + RestoreShaderResources(); + RestoreShaderResources(); + RestoreShaderResources(); + + RestoreUnorderedAccessViews(); + RestoreUnorderedAccessViews(); + + RestoreSamplers(); + RestoreSamplers(); + RestoreSamplers(); + RestoreSamplers(); + RestoreSamplers(); + RestoreSamplers(); + } + + + template + template + void D3D11CommonContext::RestoreConstantBuffers() { + const auto& bindings = m_state.cbv[Stage]; + uint32_t slotId = computeConstantBufferBinding(Stage, 0); + + for (uint32_t i = 0; i < bindings.maxCount; i++) { + BindConstantBuffer(slotId + i, bindings.buffers[i].buffer.ptr(), + bindings.buffers[i].constantOffset, bindings.buffers[i].constantBound); + } + } + + + template + template + void D3D11CommonContext::RestoreSamplers() { + const auto& bindings = m_state.samplers[Stage]; + uint32_t slotId = computeSamplerBinding(Stage, 0); + + for (uint32_t i = 0; i < bindings.maxCount; i++) + BindSampler(slotId + i, bindings.samplers[i]); + } + + + template + template + void D3D11CommonContext::RestoreShaderResources() { + const auto& bindings = m_state.srv[Stage]; + uint32_t slotId = computeSrvBinding(Stage, 0); + + for (uint32_t i = 0; i < bindings.maxCount; i++) + BindShaderResource(slotId + i, bindings.views[i].ptr()); + } + + + template + template + void D3D11CommonContext::RestoreUnorderedAccessViews() { + const auto& views = Stage == DxbcProgramType::ComputeShader + ? m_state.uav.views + : m_state.om.uavs; + + uint32_t maxCount = Stage == DxbcProgramType::ComputeShader + ? m_state.uav.maxCount + : m_state.om.maxUav; + + uint32_t uavSlotId = computeUavBinding(Stage, 0); + uint32_t ctrSlotId = computeUavCounterBinding(Stage, 0); + + for (uint32_t i = 0; i < maxCount; i++) { + BindUnorderedAccessView( + uavSlotId + i, views[i].ptr(), + ctrSlotId + i, ~0u); + } + } + + + template + template + void D3D11CommonContext::SetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers) { + auto& bindings = m_state.cbv[ShaderStage]; + uint32_t slotId = computeConstantBufferBinding(ShaderStage, StartSlot); + + for (uint32_t i = 0; i < NumBuffers; i++) { + auto newBuffer = static_cast(ppConstantBuffers[i]); + + uint32_t constantCount = newBuffer + ? std::min(newBuffer->Desc()->ByteWidth / 16, UINT(D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)) + : 0u; + + if (bindings.buffers[StartSlot + i].buffer != newBuffer + || bindings.buffers[StartSlot + i].constantOffset != 0 + || bindings.buffers[StartSlot + i].constantCount != constantCount) { + bindings.buffers[StartSlot + i].buffer = newBuffer; + bindings.buffers[StartSlot + i].constantOffset = 0; + bindings.buffers[StartSlot + i].constantCount = constantCount; + bindings.buffers[StartSlot + i].constantBound = constantCount; + + BindConstantBuffer(slotId + i, newBuffer, 0, constantCount); + } + } + + bindings.maxCount = std::clamp(StartSlot + NumBuffers, + bindings.maxCount, uint32_t(bindings.buffers.size())); + } + + + template + template + void D3D11CommonContext::SetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, + const UINT* pNumConstants) { + auto& bindings = m_state.cbv[ShaderStage]; + + uint32_t slotId = computeConstantBufferBinding(ShaderStage, StartSlot); + + for (uint32_t i = 0; i < NumBuffers; i++) { + auto newBuffer = static_cast(ppConstantBuffers[i]); + + UINT constantOffset; + UINT constantCount; + UINT constantBound; + + if (likely(newBuffer != nullptr)) { + UINT bufferConstantsCount = newBuffer->Desc()->ByteWidth / 16; + constantBound = std::min(bufferConstantsCount, UINT(D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)); + + if (likely(pFirstConstant && pNumConstants)) { + constantOffset = pFirstConstant[i]; + constantCount = pNumConstants [i]; + + if (unlikely(constantCount > D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)) + continue; + + constantBound = (constantOffset + constantCount > bufferConstantsCount) + ? bufferConstantsCount - std::min(constantOffset, bufferConstantsCount) + : constantCount; + } else { + constantOffset = 0; + constantCount = constantBound; + } + } else { + constantOffset = 0; + constantCount = 0; + constantBound = 0; + } + + // Do a full rebind if either the buffer changes + if (bindings.buffers[StartSlot + i].buffer != newBuffer) { + bindings.buffers[StartSlot + i].buffer = newBuffer; + bindings.buffers[StartSlot + i].constantOffset = constantOffset; + bindings.buffers[StartSlot + i].constantCount = constantCount; + bindings.buffers[StartSlot + i].constantBound = constantBound; + + BindConstantBuffer(slotId + i, newBuffer, constantOffset, constantBound); + } else if (bindings.buffers[StartSlot + i].constantOffset != constantOffset + || bindings.buffers[StartSlot + i].constantCount != constantCount) { + bindings.buffers[StartSlot + i].constantOffset = constantOffset; + bindings.buffers[StartSlot + i].constantCount = constantCount; + bindings.buffers[StartSlot + i].constantBound = constantBound; + + BindConstantBufferRange(slotId + i, constantOffset, constantBound); + } + } + + bindings.maxCount = std::clamp(StartSlot + NumBuffers, + bindings.maxCount, uint32_t(bindings.buffers.size())); + } + + + template + template + void D3D11CommonContext::SetShaderResources( + UINT StartSlot, + UINT NumResources, + ID3D11ShaderResourceView* const* ppResources) { + auto& bindings = m_state.srv[ShaderStage]; + uint32_t slotId = computeSrvBinding(ShaderStage, StartSlot); + + for (uint32_t i = 0; i < NumResources; i++) { + auto resView = static_cast(ppResources[i]); + + if (bindings.views[StartSlot + i] != resView) { + if (likely(resView != nullptr)) { + if (unlikely(resView->TestHazards())) { + if (TestSrvHazards(resView)) + resView = nullptr; + + // Only set if necessary, but don't reset it on every + // bind as this would be more expensive than a few + // redundant checks in OMSetRenderTargets and friends. + bindings.hazardous.set(StartSlot + i, resView); + } + } + + bindings.views[StartSlot + i] = resView; + BindShaderResource(slotId + i, resView); + } + } + + bindings.maxCount = std::clamp(StartSlot + NumResources, + bindings.maxCount, uint32_t(bindings.views.size())); + } + + + template + template + void D3D11CommonContext::SetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState* const* ppSamplers) { + auto& bindings = m_state.samplers[ShaderStage]; + uint32_t slotId = computeSamplerBinding(ShaderStage, StartSlot); + + for (uint32_t i = 0; i < NumSamplers; i++) { + auto sampler = static_cast(ppSamplers[i]); + + if (bindings.samplers[StartSlot + i] != sampler) { + bindings.samplers[StartSlot + i] = sampler; + BindSampler(slotId + i, sampler); + } + } + + bindings.maxCount = std::clamp(StartSlot + NumSamplers, + bindings.maxCount, uint32_t(bindings.samplers.size())); + } + + + template + void D3D11CommonContext::SetRenderTargetsAndUnorderedAccessViews( + UINT NumRTVs, + ID3D11RenderTargetView* const* ppRenderTargetViews, + ID3D11DepthStencilView* pDepthStencilView, + UINT UAVStartSlot, + UINT NumUAVs, + ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, + const UINT* pUAVInitialCounts) { + if (TestRtvUavHazards(NumRTVs, ppRenderTargetViews, NumUAVs, ppUnorderedAccessViews)) + return; + + bool needsUpdate = false; + + if (likely(NumRTVs != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL)) { + // Native D3D11 does not change the render targets if + // the parameters passed to this method are invalid. + if (!ValidateRenderTargets(NumRTVs, ppRenderTargetViews, pDepthStencilView)) + return; + + for (uint32_t i = 0; i < m_state.om.rtvs.size(); i++) { + auto rtv = i < NumRTVs + ? static_cast(ppRenderTargetViews[i]) + : nullptr; + + if (m_state.om.rtvs[i] != rtv) { + m_state.om.rtvs[i] = rtv; + needsUpdate = true; + ResolveOmSrvHazards(rtv); + + if (NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS) + ResolveOmUavHazards(rtv); + } + } + + auto dsv = static_cast(pDepthStencilView); + + if (m_state.om.dsv != dsv) { + m_state.om.dsv = dsv; + needsUpdate = true; + ResolveOmSrvHazards(dsv); + } + + m_state.om.maxRtv = NumRTVs; + } + + if (unlikely(NumUAVs || m_state.om.maxUav)) { + uint32_t uavSlotId = computeUavBinding (DxbcProgramType::PixelShader, 0); + uint32_t ctrSlotId = computeUavCounterBinding(DxbcProgramType::PixelShader, 0); + + if (likely(NumUAVs != D3D11_KEEP_UNORDERED_ACCESS_VIEWS)) { + uint32_t newMaxUav = NumUAVs ? UAVStartSlot + NumUAVs : 0; + uint32_t oldMaxUav = std::exchange(m_state.om.maxUav, newMaxUav); + + for (uint32_t i = 0; i < std::max(oldMaxUav, newMaxUav); i++) { + D3D11UnorderedAccessView* uav = nullptr; + uint32_t ctr = ~0u; + + if (i >= UAVStartSlot && i < UAVStartSlot + NumUAVs) { + uav = static_cast(ppUnorderedAccessViews[i - UAVStartSlot]); + ctr = pUAVInitialCounts ? pUAVInitialCounts[i - UAVStartSlot] : ~0u; + } + + if (m_state.om.uavs[i] != uav || ctr != ~0u) { + m_state.om.uavs[i] = uav; + + BindUnorderedAccessView( + uavSlotId + i, uav, + ctrSlotId + i, ctr); + + ResolveOmSrvHazards(uav); + + if (NumRTVs == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) + needsUpdate |= ResolveOmRtvHazards(uav); + } + } + } + } + + if (needsUpdate) { + BindFramebuffer(); + + if constexpr (!IsDeferred) { + // Doing this makes it less likely to flush during render passes + GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint); + } + } + } + + + template + void D3D11CommonContext::SetDrawBuffers( + ID3D11Buffer* pBufferForArgs, + ID3D11Buffer* pBufferForCount) { + auto argBuffer = static_cast(pBufferForArgs); + auto cntBuffer = static_cast(pBufferForCount); + + if (m_state.id.argBuffer != argBuffer + || m_state.id.cntBuffer != cntBuffer) { + m_state.id.argBuffer = argBuffer; + m_state.id.cntBuffer = cntBuffer; + + BindDrawBuffers(argBuffer, cntBuffer); + } + } + + + template + bool D3D11CommonContext::TestRtvUavHazards( + UINT NumRTVs, + ID3D11RenderTargetView* const* ppRTVs, + UINT NumUAVs, + ID3D11UnorderedAccessView* const* ppUAVs) { + if (NumRTVs == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) NumRTVs = 0; + if (NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS) NumUAVs = 0; + + for (uint32_t i = 0; i < NumRTVs; i++) { + auto rtv = static_cast(ppRTVs[i]); + + if (!rtv) + continue; + + for (uint32_t j = 0; j < i; j++) { + if (CheckViewOverlap(rtv, static_cast(ppRTVs[j]))) + return true; + } + + if (rtv->HasBindFlag(D3D11_BIND_UNORDERED_ACCESS)) { + for (uint32_t j = 0; j < NumUAVs; j++) { + if (CheckViewOverlap(rtv, static_cast(ppUAVs[j]))) + return true; + } + } + } + + for (uint32_t i = 0; i < NumUAVs; i++) { + auto uav = static_cast(ppUAVs[i]); + + if (!uav) + continue; + + for (uint32_t j = 0; j < i; j++) { + if (CheckViewOverlap(uav, static_cast(ppUAVs[j]))) + return true; + } + } + + return false; + } + + + template + template + bool D3D11CommonContext::TestSrvHazards( + D3D11ShaderResourceView* pView) { + bool hazard = false; + + if (ShaderStage == DxbcProgramType::ComputeShader) { + int32_t uav = m_state.uav.mask.findNext(0); + + while (uav >= 0 && !hazard) { + hazard = CheckViewOverlap(pView, m_state.uav.views[uav].ptr()); + uav = m_state.uav.mask.findNext(uav + 1); + } + } else { + hazard = CheckViewOverlap(pView, m_state.om.dsv.ptr()); + + for (uint32_t i = 0; !hazard && i < m_state.om.maxRtv; i++) + hazard = CheckViewOverlap(pView, m_state.om.rtvs[i].ptr()); + + for (uint32_t i = 0; !hazard && i < m_state.om.maxUav; i++) + hazard = CheckViewOverlap(pView, m_state.om.uavs[i].ptr()); + } + + return hazard; + } + + + template + void D3D11CommonContext::TrackResourceSequenceNumber( + ID3D11Resource* pResource) { + if (!pResource) + return; + + D3D11CommonTexture* texture = GetCommonTexture(pResource); + + if (texture) { + if (texture->HasSequenceNumber()) { + for (uint32_t i = 0; i < texture->CountSubresources(); i++) + GetTypedContext()->TrackTextureSequenceNumber(texture, i); + } + } else { + D3D11Buffer* buffer = static_cast(pResource); + + if (buffer->HasSequenceNumber()) + GetTypedContext()->TrackBufferSequenceNumber(buffer); + } + } + + + template + void D3D11CommonContext::UpdateBuffer( D3D11Buffer* pDstBuffer, UINT Offset, UINT Length, @@ -3680,11 +5111,12 @@ namespace dxvk { } if (pDstBuffer->HasSequenceNumber()) - TrackBufferSequenceNumber(pDstBuffer); + GetTypedContext()->TrackBufferSequenceNumber(pDstBuffer); } - void D3D11DeviceContext::UpdateTexture( + template + void D3D11CommonContext::UpdateTexture( D3D11CommonTexture* pDstTexture, UINT DstSubresource, const D3D11_BOX* pDstBox, @@ -3696,7 +5128,7 @@ namespace dxvk { VkFormat packedFormat = pDstTexture->GetPackedFormat(); - auto formatInfo = imageFormatInfo(packedFormat); + auto formatInfo = lookupFormatInfo(packedFormat); auto subresource = pDstTexture->GetSubresourceFromIndex( formatInfo->aspectMask, DstSubresource); @@ -3720,10 +5152,8 @@ namespace dxvk { extent.depth = pDstBox->back - pDstBox->front; } - if (!util::isBlockAligned(offset, extent, formatInfo->blockSize, mipExtent)) { - Logger::err("D3D11: UpdateSubresource1: Unaligned region"); + if (!util::isBlockAligned(offset, extent, formatInfo->blockSize, mipExtent)) return; - } auto stagingSlice = AllocStagingBuffer(util::computeImageDataSize(packedFormat, extent)); @@ -3737,7 +5167,8 @@ namespace dxvk { } - void D3D11DeviceContext::UpdateImage( + template + void D3D11CommonContext::UpdateImage( D3D11CommonTexture* pDstTexture, const VkImageSubresource* pDstSubresource, VkOffset3D DstOffset, @@ -3780,7 +5211,7 @@ namespace dxvk { VkExtent3D dstMipExtent = pDstTexture->MipLevelExtent(pDstSubresource->mipLevel); auto dstFormat = pDstTexture->GetPackedFormat(); - auto dstFormatInfo = imageFormatInfo(dstFormat); + auto dstFormatInfo = lookupFormatInfo(dstFormat); uint32_t planeCount = 1; @@ -3828,612 +5259,115 @@ namespace dxvk { } if (pDstTexture->HasSequenceNumber()) - TrackTextureSequenceNumber(pDstTexture, dstSubresource); + GetTypedContext()->TrackTextureSequenceNumber(pDstTexture, dstSubresource); } - void D3D11DeviceContext::SetDrawBuffers( - ID3D11Buffer* pBufferForArgs, - ID3D11Buffer* pBufferForCount) { - auto argBuffer = static_cast(pBufferForArgs); - auto cntBuffer = static_cast(pBufferForCount); - - if (m_state.id.argBuffer != argBuffer - || m_state.id.cntBuffer != cntBuffer) { - m_state.id.argBuffer = argBuffer; - m_state.id.cntBuffer = cntBuffer; - - BindDrawBuffers(argBuffer, cntBuffer); - } - } - - - template - void D3D11DeviceContext::SetConstantBuffers( - D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers) { - uint32_t slotId = computeConstantBufferBinding(ShaderStage, StartSlot); - - for (uint32_t i = 0; i < NumBuffers; i++) { - auto newBuffer = static_cast(ppConstantBuffers[i]); - - UINT constantCount = 0; - - if (likely(newBuffer != nullptr)) - constantCount = std::min(newBuffer->Desc()->ByteWidth / 16, UINT(D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)); - - if (Bindings[StartSlot + i].buffer != newBuffer - || Bindings[StartSlot + i].constantCount != constantCount) { - Bindings[StartSlot + i].buffer = newBuffer; - Bindings[StartSlot + i].constantOffset = 0; - Bindings[StartSlot + i].constantCount = constantCount; - Bindings[StartSlot + i].constantBound = constantCount; - - BindConstantBuffer(slotId + i, newBuffer, 0, constantCount); - } - } - } - - - template - void D3D11DeviceContext::SetConstantBuffers1( - D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, - const UINT* pNumConstants) { - uint32_t slotId = computeConstantBufferBinding(ShaderStage, StartSlot); - - for (uint32_t i = 0; i < NumBuffers; i++) { - auto newBuffer = static_cast(ppConstantBuffers[i]); - - UINT constantOffset; - UINT constantCount; - UINT constantBound; - - if (likely(newBuffer != nullptr)) { - UINT bufferConstantsCount = newBuffer->Desc()->ByteWidth / 16; - constantBound = std::min(bufferConstantsCount, UINT(D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)); - - if (likely(pFirstConstant && pNumConstants)) { - constantOffset = pFirstConstant[i]; - constantCount = pNumConstants [i]; - - if (unlikely(constantCount > D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT)) - continue; - - constantBound = (constantOffset + constantCount > bufferConstantsCount) - ? bufferConstantsCount - std::min(constantOffset, bufferConstantsCount) - : constantCount; - } else { - constantOffset = 0; - constantCount = constantBound; - } - } else { - constantOffset = 0; - constantCount = 0; - constantBound = 0; - } - - bool needsUpdate = Bindings[StartSlot + i].buffer != newBuffer; - - if (needsUpdate) - Bindings[StartSlot + i].buffer = newBuffer; - - needsUpdate |= Bindings[StartSlot + i].constantOffset != constantOffset - || Bindings[StartSlot + i].constantCount != constantCount; - - if (needsUpdate) { - Bindings[StartSlot + i].constantOffset = constantOffset; - Bindings[StartSlot + i].constantCount = constantCount; - Bindings[StartSlot + i].constantBound = constantBound; - - BindConstantBuffer(slotId + i, newBuffer, constantOffset, constantBound); - } - } - } - - - template - void D3D11DeviceContext::SetSamplers( - D3D11SamplerBindings& Bindings, - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState* const* ppSamplers) { - uint32_t slotId = computeSamplerBinding(ShaderStage, StartSlot); - - for (uint32_t i = 0; i < NumSamplers; i++) { - auto sampler = static_cast(ppSamplers[i]); - - if (Bindings[StartSlot + i] != sampler) { - Bindings[StartSlot + i] = sampler; - BindSampler(slotId + i, sampler); - } - } - } - - - template - void D3D11DeviceContext::SetShaderResources( - D3D11ShaderResourceBindings& Bindings, - UINT StartSlot, - UINT NumResources, - ID3D11ShaderResourceView* const* ppResources) { - uint32_t slotId = computeSrvBinding(ShaderStage, StartSlot); - - for (uint32_t i = 0; i < NumResources; i++) { - auto resView = static_cast(ppResources[i]); - - if (Bindings.views[StartSlot + i] != resView) { - if (unlikely(resView && resView->TestHazards())) { - if (TestSrvHazards(resView)) - resView = nullptr; - - // Only set if necessary, but don't reset it on every - // bind as this would be more expensive than a few - // redundant checks in OMSetRenderTargets and friends. - Bindings.hazardous.set(StartSlot + i, resView); - } - - Bindings.views[StartSlot + i] = resView; - BindShaderResource(slotId + i, resView); - } - } - } - - - void D3D11DeviceContext::GetConstantBuffers( - const D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, - UINT* pNumConstants) { - for (uint32_t i = 0; i < NumBuffers; i++) { - const bool inRange = StartSlot + i < Bindings.size(); - - if (ppConstantBuffers != nullptr) { - ppConstantBuffers[i] = inRange - ? Bindings[StartSlot + i].buffer.ref() - : nullptr; - } - - if (pFirstConstant != nullptr) { - pFirstConstant[i] = inRange - ? Bindings[StartSlot + i].constantOffset - : 0u; - } - - if (pNumConstants != nullptr) { - pNumConstants[i] = inRange - ? Bindings[StartSlot + i].constantCount - : 0u; - } - } - } - - - void D3D11DeviceContext::GetShaderResources( - const D3D11ShaderResourceBindings& Bindings, - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView** ppShaderResourceViews) { - for (uint32_t i = 0; i < NumViews; i++) { - ppShaderResourceViews[i] = StartSlot + i < Bindings.views.size() - ? Bindings.views[StartSlot + i].ref() - : nullptr; - } - } - - - void D3D11DeviceContext::GetSamplers( - const D3D11SamplerBindings& Bindings, - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState** ppSamplers) { - for (uint32_t i = 0; i < NumSamplers; i++) { - ppSamplers[i] = StartSlot + i < Bindings.size() - ? ref(Bindings[StartSlot + i]) - : nullptr; - } - } - - - void D3D11DeviceContext::ResetState() { - EmitCs([] (DxvkContext* ctx) { - // Reset render targets - ctx->bindRenderTargets(DxvkRenderTargets()); - - // Reset vertex input state - ctx->setInputLayout(0, nullptr, 0, nullptr); - - // Reset render states - DxvkInputAssemblyState iaState; - InitDefaultPrimitiveTopology(&iaState); - - DxvkDepthStencilState dsState; - InitDefaultDepthStencilState(&dsState); - - DxvkRasterizerState rsState; - InitDefaultRasterizerState(&rsState); - - DxvkBlendMode cbState; - DxvkLogicOpState loState; - DxvkMultisampleState msState; - InitDefaultBlendState(&cbState, &loState, &msState, D3D11_DEFAULT_SAMPLE_MASK); - - ctx->setInputAssemblyState(iaState); - ctx->setDepthStencilState(dsState); - ctx->setRasterizerState(rsState); - ctx->setLogicOpState(loState); - ctx->setMultisampleState(msState); - - for (uint32_t i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++) - ctx->setBlendMode(i, cbState); - - // Reset dynamic states - ctx->setBlendConstants(DxvkBlendConstants { 1.0f, 1.0f, 1.0f, 1.0f }); - ctx->setStencilReference(D3D11_DEFAULT_STENCIL_REFERENCE); - - // Reset viewports - auto viewport = VkViewport(); - auto scissor = VkRect2D(); - - ctx->setViewports(1, &viewport, &scissor); - - // Unbind indirect draw buffer - ctx->bindDrawBuffers(DxvkBufferSlice(), DxvkBufferSlice()); - - // Unbind index and vertex buffers - ctx->bindIndexBuffer(DxvkBufferSlice(), VK_INDEX_TYPE_UINT32); - - for (uint32_t i = 0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; i++) - ctx->bindVertexBuffer(i, DxvkBufferSlice(), 0); - - // Unbind transform feedback buffers - for (uint32_t i = 0; i < D3D11_SO_BUFFER_SLOT_COUNT; i++) - ctx->bindXfbBuffer(i, DxvkBufferSlice(), DxvkBufferSlice()); - - // Unbind per-shader stage resources - for (uint32_t i = 0; i < 6; i++) { - auto programType = DxbcProgramType(i); - ctx->bindShader(GetShaderStage(programType), nullptr); - - // Unbind constant buffers, including the shader's ICB - auto cbSlotId = computeConstantBufferBinding(programType, 0); - - for (uint32_t j = 0; j <= D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; j++) - ctx->bindResourceBuffer(cbSlotId + j, DxvkBufferSlice()); - - // Unbind shader resource views - auto srvSlotId = computeSrvBinding(programType, 0); - - for (uint32_t j = 0; j < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; j++) - ctx->bindResourceView(srvSlotId + j, nullptr, nullptr); - - // Unbind texture samplers - auto samplerSlotId = computeSamplerBinding(programType, 0); - - for (uint32_t j = 0; j < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; j++) - ctx->bindResourceSampler(samplerSlotId + j, nullptr); - - // Unbind UAVs for supported stages - if (programType == DxbcProgramType::PixelShader - || programType == DxbcProgramType::ComputeShader) { - auto uavSlotId = computeUavBinding(programType, 0); - auto ctrSlotId = computeUavCounterBinding(programType, 0); - - for (uint32_t j = 0; j < D3D11_1_UAV_SLOT_COUNT; j++) { - ctx->bindResourceView (uavSlotId, nullptr, nullptr); - ctx->bindResourceBuffer (ctrSlotId, DxvkBufferSlice()); - } - } - } - }); - } - - - void D3D11DeviceContext::RestoreState() { - BindFramebuffer(); - - BindShader (GetCommonShader(m_state.vs.shader.ptr())); - BindShader (GetCommonShader(m_state.hs.shader.ptr())); - BindShader (GetCommonShader(m_state.ds.shader.ptr())); - BindShader (GetCommonShader(m_state.gs.shader.ptr())); - BindShader (GetCommonShader(m_state.ps.shader.ptr())); - BindShader (GetCommonShader(m_state.cs.shader.ptr())); - - ApplyInputLayout(); - ApplyPrimitiveTopology(); - ApplyBlendState(); - ApplyBlendFactor(); - ApplyDepthStencilState(); - ApplyStencilRef(); - ApplyRasterizerState(); - ApplyViewportState(); - - BindDrawBuffers( - m_state.id.argBuffer.ptr(), - m_state.id.cntBuffer.ptr()); - - BindIndexBuffer( - m_state.ia.indexBuffer.buffer.ptr(), - m_state.ia.indexBuffer.offset, - m_state.ia.indexBuffer.format); - - for (uint32_t i = 0; i < m_state.ia.vertexBuffers.size(); i++) { - BindVertexBuffer(i, - m_state.ia.vertexBuffers[i].buffer.ptr(), - m_state.ia.vertexBuffers[i].offset, - m_state.ia.vertexBuffers[i].stride); - } - - for (uint32_t i = 0; i < m_state.so.targets.size(); i++) - BindXfbBuffer(i, m_state.so.targets[i].buffer.ptr(), ~0u); - - RestoreConstantBuffers (m_state.vs.constantBuffers); - RestoreConstantBuffers (m_state.hs.constantBuffers); - RestoreConstantBuffers (m_state.ds.constantBuffers); - RestoreConstantBuffers (m_state.gs.constantBuffers); - RestoreConstantBuffers (m_state.ps.constantBuffers); - RestoreConstantBuffers (m_state.cs.constantBuffers); - - RestoreSamplers (m_state.vs.samplers); - RestoreSamplers (m_state.hs.samplers); - RestoreSamplers (m_state.ds.samplers); - RestoreSamplers(m_state.gs.samplers); - RestoreSamplers (m_state.ps.samplers); - RestoreSamplers (m_state.cs.samplers); - - RestoreShaderResources (m_state.vs.shaderResources); - RestoreShaderResources (m_state.hs.shaderResources); - RestoreShaderResources (m_state.ds.shaderResources); - RestoreShaderResources (m_state.gs.shaderResources); - RestoreShaderResources (m_state.ps.shaderResources); - RestoreShaderResources (m_state.cs.shaderResources); - - RestoreUnorderedAccessViews (m_state.ps.unorderedAccessViews); - RestoreUnorderedAccessViews (m_state.cs.unorderedAccessViews); - } - - - template - void D3D11DeviceContext::RestoreConstantBuffers( - D3D11ConstantBufferBindings& Bindings) { - uint32_t slotId = computeConstantBufferBinding(Stage, 0); - - for (uint32_t i = 0; i < Bindings.size(); i++) { - BindConstantBuffer(slotId + i, Bindings[i].buffer.ptr(), - Bindings[i].constantOffset, Bindings[i].constantBound); - } - } - - - template - void D3D11DeviceContext::RestoreSamplers( - D3D11SamplerBindings& Bindings) { - uint32_t slotId = computeSamplerBinding(Stage, 0); - - for (uint32_t i = 0; i < Bindings.size(); i++) - BindSampler(slotId + i, Bindings[i]); - } - - - template - void D3D11DeviceContext::RestoreShaderResources( - D3D11ShaderResourceBindings& Bindings) { - uint32_t slotId = computeSrvBinding(Stage, 0); - - for (uint32_t i = 0; i < Bindings.views.size(); i++) - BindShaderResource(slotId + i, Bindings.views[i].ptr()); - } - - - template - void D3D11DeviceContext::RestoreUnorderedAccessViews( - D3D11UnorderedAccessBindings& Bindings) { - uint32_t uavSlotId = computeUavBinding (Stage, 0); - uint32_t ctrSlotId = computeUavCounterBinding(Stage, 0); - - for (uint32_t i = 0; i < Bindings.size(); i++) { - BindUnorderedAccessView( - uavSlotId + i, - Bindings[i].ptr(), - ctrSlotId + i, ~0u); - } - } - - - bool D3D11DeviceContext::TestRtvUavHazards( - UINT NumRTVs, - ID3D11RenderTargetView* const* ppRTVs, - UINT NumUAVs, - ID3D11UnorderedAccessView* const* ppUAVs) { - if (NumRTVs == D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL) NumRTVs = 0; - if (NumUAVs == D3D11_KEEP_UNORDERED_ACCESS_VIEWS) NumUAVs = 0; - - for (uint32_t i = 0; i < NumRTVs; i++) { - auto rtv = static_cast(ppRTVs[i]); - - if (!rtv) - continue; - - for (uint32_t j = 0; j < i; j++) { - if (CheckViewOverlap(rtv, static_cast(ppRTVs[j]))) - return true; - } - - if (rtv->HasBindFlag(D3D11_BIND_UNORDERED_ACCESS)) { - for (uint32_t j = 0; j < NumUAVs; j++) { - if (CheckViewOverlap(rtv, static_cast(ppUAVs[j]))) - return true; - } - } - } - - for (uint32_t i = 0; i < NumUAVs; i++) { - auto uav = static_cast(ppUAVs[i]); - - if (!uav) - continue; - - for (uint32_t j = 0; j < i; j++) { - if (CheckViewOverlap(uav, static_cast(ppUAVs[j]))) - return true; - } - } - - return false; - } - - - template - bool D3D11DeviceContext::TestSrvHazards( - D3D11ShaderResourceView* pView) { - bool hazard = false; - - if (ShaderStage == DxbcProgramType::ComputeShader) { - int32_t uav = m_state.cs.uavMask.findNext(0); - - while (uav >= 0 && !hazard) { - hazard = CheckViewOverlap(pView, m_state.cs.unorderedAccessViews[uav].ptr()); - uav = m_state.cs.uavMask.findNext(uav + 1); - } - } else { - hazard = CheckViewOverlap(pView, m_state.om.depthStencilView.ptr()); - - for (uint32_t i = 0; !hazard && i < m_state.om.maxRtv; i++) - hazard = CheckViewOverlap(pView, m_state.om.renderTargetViews[i].ptr()); - - for (uint32_t i = 0; !hazard && i < m_state.om.maxUav; i++) - hazard = CheckViewOverlap(pView, m_state.ps.unorderedAccessViews[i].ptr()); - } - - return hazard; - } - - - template - void D3D11DeviceContext::ResolveSrvHazards( - T* pView, - D3D11ShaderResourceBindings& Bindings) { - uint32_t slotId = computeSrvBinding(ShaderStage, 0); - int32_t srvId = Bindings.hazardous.findNext(0); - - while (srvId >= 0) { - auto srv = Bindings.views[srvId].ptr(); - - if (likely(srv && srv->TestHazards())) { - bool hazard = CheckViewOverlap(pView, srv); - - if (unlikely(hazard)) { - Bindings.views[srvId] = nullptr; - Bindings.hazardous.clr(srvId); - - BindShaderResource(slotId + srvId, nullptr); - } - } else { - // Avoid further redundant iterations - Bindings.hazardous.clr(srvId); - } - - srvId = Bindings.hazardous.findNext(srvId + 1); - } - } - - - template - void D3D11DeviceContext::ResolveCsSrvHazards( - T* pView) { - if (!pView) return; - ResolveSrvHazards (pView, m_state.cs.shaderResources); - } - - - template - void D3D11DeviceContext::ResolveOmSrvHazards( - T* pView) { - if (!pView) return; - ResolveSrvHazards (pView, m_state.vs.shaderResources); - ResolveSrvHazards (pView, m_state.hs.shaderResources); - ResolveSrvHazards (pView, m_state.ds.shaderResources); - ResolveSrvHazards (pView, m_state.gs.shaderResources); - ResolveSrvHazards (pView, m_state.ps.shaderResources); - } - - - bool D3D11DeviceContext::ResolveOmRtvHazards( - D3D11UnorderedAccessView* pView) { - if (!pView || !pView->HasBindFlag(D3D11_BIND_RENDER_TARGET)) - return false; - - bool hazard = false; - - if (CheckViewOverlap(pView, m_state.om.depthStencilView.ptr())) { - m_state.om.depthStencilView = nullptr; - hazard = true; - } - - for (uint32_t i = 0; i < m_state.om.maxRtv; i++) { - if (CheckViewOverlap(pView, m_state.om.renderTargetViews[i].ptr())) { - m_state.om.renderTargetViews[i] = nullptr; - hazard = true; - } - } - - return hazard; - } - - - void D3D11DeviceContext::ResolveOmUavHazards( - D3D11RenderTargetView* pView) { - if (!pView || !pView->HasBindFlag(D3D11_BIND_UNORDERED_ACCESS)) + template + void D3D11CommonContext::UpdateResource( + ID3D11Resource* pDstResource, + UINT DstSubresource, + const D3D11_BOX* pDstBox, + const void* pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch, + UINT CopyFlags) { + auto context = static_cast(this); + D3D10DeviceLock lock = context->LockContext(); + + if (!pDstResource) return; - uint32_t uavSlotId = computeUavBinding (DxbcProgramType::PixelShader, 0); - uint32_t ctrSlotId = computeUavCounterBinding(DxbcProgramType::PixelShader, 0); + // We need a different code path for buffers + D3D11_RESOURCE_DIMENSION resourceType; + pDstResource->GetType(&resourceType); - for (uint32_t i = 0; i < m_state.om.maxUav; i++) { - if (CheckViewOverlap(pView, m_state.ps.unorderedAccessViews[i].ptr())) { - m_state.ps.unorderedAccessViews[i] = nullptr; + if (likely(resourceType == D3D11_RESOURCE_DIMENSION_BUFFER)) { + const auto bufferResource = static_cast(pDstResource); + uint64_t bufferSize = bufferResource->Desc()->ByteWidth; - BindUnorderedAccessView( - uavSlotId + i, nullptr, - ctrSlotId + i, ~0u); + // Provide a fast path for mapped buffer updates since some + // games use UpdateSubresource to update constant buffers. + if (likely(bufferResource->GetMapMode() == D3D11_COMMON_BUFFER_MAP_MODE_DIRECT) && likely(!pDstBox)) { + context->UpdateMappedBuffer(bufferResource, 0, bufferSize, pSrcData, 0); + return; } + + // Validate buffer range to update + uint64_t offset = 0; + uint64_t length = bufferSize; + + if (pDstBox) { + offset = pDstBox->left; + length = pDstBox->right - offset; + } + + if (unlikely(offset + length > bufferSize)) + return; + + // Still try to be fast if a box is provided but we update the full buffer + if (likely(bufferResource->GetMapMode() == D3D11_COMMON_BUFFER_MAP_MODE_DIRECT)) { + CopyFlags &= D3D11_COPY_DISCARD | D3D11_COPY_NO_OVERWRITE; + + if (likely(length == bufferSize) || unlikely(CopyFlags != 0)) { + context->UpdateMappedBuffer(bufferResource, offset, length, pSrcData, CopyFlags); + return; + } + } + + // Otherwise we can't really do anything fancy, so just do a GPU copy + context->UpdateBuffer(bufferResource, offset, length, pSrcData); + } else { + D3D11CommonTexture* textureResource = GetCommonTexture(pDstResource); + + context->UpdateTexture(textureResource, + DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); } } - bool D3D11DeviceContext::ValidateRenderTargets( + template + bool D3D11CommonContext::ValidateRenderTargets( UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView) { Rc refView; - + + VkExtent3D dsvExtent = { 0u, 0u, 0u }; + VkExtent3D rtvExtent = { 0u, 0u, 0u }; + if (pDepthStencilView != nullptr) { refView = static_cast( pDepthStencilView)->GetImageView(); + dsvExtent = refView->mipLevelExtent(0); } - + for (uint32_t i = 0; i < NumViews; i++) { if (ppRenderTargetViews[i] != nullptr) { auto curView = static_cast( ppRenderTargetViews[i])->GetImageView(); - + + if (!rtvExtent.width) + rtvExtent = curView->mipLevelExtent(0); + if (refView != nullptr) { - // Render target views must all have the same - // size, sample count, layer count, and type + // Render target views must all have the same sample count, + // layer count, and type. The size can mismatch under certain + // conditions, the D3D11 documentation is wrong here. if (curView->info().type != refView->info().type || curView->info().numLayers != refView->info().numLayers) return false; - + if (curView->imageInfo().sampleCount != refView->imageInfo().sampleCount) return false; + + // Color targets must all be the same size + VkExtent3D curExtent = curView->mipLevelExtent(0); + + if (curExtent.width != rtvExtent.width + || curExtent.height != rtvExtent.height) + return false; } else { // Set reference view. All remaining views // must be compatible to the reference view. @@ -4441,73 +5375,21 @@ namespace dxvk { } } } - + + // Based on testing, the depth-stencil target is allowed + // to be larger than all color targets, but not smaller + if (rtvExtent.width && dsvExtent.width) { + if (rtvExtent.width > dsvExtent.width + || rtvExtent.height > dsvExtent.height) + return false; + } + return true; } - - - VkClearValue D3D11DeviceContext::ConvertColorValue( - const FLOAT Color[4], - const DxvkFormatInfo* pFormatInfo) { - VkClearValue result; - - if (pFormatInfo->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) { - for (uint32_t i = 0; i < 4; i++) { - if (pFormatInfo->flags.test(DxvkFormatFlag::SampledUInt)) - result.color.uint32[i] = uint32_t(std::max(0.0f, Color[i])); - else if (pFormatInfo->flags.test(DxvkFormatFlag::SampledSInt)) - result.color.int32[i] = int32_t(Color[i]); - else - result.color.float32[i] = Color[i]; - } - } else { - result.depthStencil.depth = Color[0]; - result.depthStencil.stencil = 0; - } - - return result; - } - DxvkDataSlice D3D11DeviceContext::AllocUpdateBufferSlice(size_t Size) { - constexpr size_t UpdateBufferSize = 1 * 1024 * 1024; - - if (Size >= UpdateBufferSize) { - Rc buffer = new DxvkDataBuffer(Size); - return buffer->alloc(Size); - } else { - if (m_updateBuffer == nullptr) - m_updateBuffer = new DxvkDataBuffer(UpdateBufferSize); - - DxvkDataSlice slice = m_updateBuffer->alloc(Size); - - if (slice.ptr() == nullptr) { - m_updateBuffer = new DxvkDataBuffer(UpdateBufferSize); - slice = m_updateBuffer->alloc(Size); - } - - return slice; - } - } - - - DxvkBufferSlice D3D11DeviceContext::AllocStagingBuffer( - VkDeviceSize Size) { - return m_staging.alloc(256, Size); - } - - - void D3D11DeviceContext::ResetStagingBuffer() { - m_staging.reset(); - } - - - DxvkCsChunkRef D3D11DeviceContext::AllocCsChunk() { - return m_parent->AllocCsChunk(m_csFlags); - } - - - void D3D11DeviceContext::InitDefaultPrimitiveTopology( + template + void D3D11CommonContext::InitDefaultPrimitiveTopology( DxvkInputAssemblyState* pIaState) { pIaState->primitiveTopology = VK_PRIMITIVE_TOPOLOGY_MAX_ENUM; pIaState->primitiveRestart = VK_FALSE; @@ -4515,7 +5397,8 @@ namespace dxvk { } - void D3D11DeviceContext::InitDefaultRasterizerState( + template + void D3D11CommonContext::InitDefaultRasterizerState( DxvkRasterizerState* pRsState) { pRsState->polygonMode = VK_POLYGON_MODE_FILL; pRsState->cullMode = VK_CULL_MODE_BACK_BIT; @@ -4524,10 +5407,13 @@ namespace dxvk { pRsState->depthBiasEnable = VK_FALSE; pRsState->conservativeMode = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT; pRsState->sampleCount = 0; + pRsState->flatShading = VK_FALSE; + pRsState->lineMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT; } - void D3D11DeviceContext::InitDefaultDepthStencilState( + template + void D3D11CommonContext::InitDefaultDepthStencilState( DxvkDepthStencilState* pDsState) { VkStencilOpState stencilOp; stencilOp.failOp = VK_STENCIL_OP_KEEP; @@ -4546,8 +5432,9 @@ namespace dxvk { pDsState->stencilOpBack = stencilOp; } - - void D3D11DeviceContext::InitDefaultBlendState( + + template + void D3D11CommonContext::InitDefaultBlendState( DxvkBlendMode* pCbState, DxvkLogicOpState* pLoState, DxvkMultisampleState* pMsState, @@ -4569,25 +5456,8 @@ namespace dxvk { pMsState->enableAlphaToCoverage = VK_FALSE; } - - void D3D11DeviceContext::TrackResourceSequenceNumber( - ID3D11Resource* pResource) { - if (!pResource) - return; - - D3D11CommonTexture* texture = GetCommonTexture(pResource); - - if (texture) { - if (texture->HasSequenceNumber()) { - for (uint32_t i = 0; i < texture->CountSubresources(); i++) - TrackTextureSequenceNumber(texture, i); - } - } else { - D3D11Buffer* buffer = static_cast(pResource); - - if (buffer->HasSequenceNumber()) - TrackBufferSequenceNumber(buffer); - } - } + // Explicitly instantiate here + template class D3D11CommonContext; + template class D3D11CommonContext; } diff --git a/src/d3d11/d3d11_context.h b/src/d3d11/d3d11_context.h index 3bd60a57..618c07d6 100644 --- a/src/d3d11/d3d11_context.h +++ b/src/d3d11/d3d11_context.h @@ -1,5 +1,8 @@ #pragma once +#include +#include + #include "../dxvk/dxvk_adapter.h" #include "../dxvk/dxvk_cs.h" #include "../dxvk/dxvk_device.h" @@ -7,7 +10,10 @@ #include "../d3d10/d3d10_multithread.h" +#include "../util/util_flush.h" + #include "d3d11_annotation.h" +#include "d3d11_buffer.h" #include "d3d11_cmd.h" #include "d3d11_context_ext.h" #include "d3d11_context_state.h" @@ -15,27 +21,78 @@ #include "d3d11_texture.h" namespace dxvk { - - class D3D11Device; - - class D3D11DeviceContext : public D3D11DeviceChild { - friend class D3D11DeviceContextExt; - // Needed in order to call EmitCs for pushing markers - friend class D3D11UserDefinedAnnotation; + + class D3D11DeferredContext; + class D3D11ImmediateContext; + + template + struct D3D11ContextObjectForwarder; + + /** + * \brief Object forwarder for immediate contexts + * + * Binding methods can use this to efficiently bind objects + * to the DXVK context without redundant reference counting. + */ + template<> + struct D3D11ContextObjectForwarder { + template + static T&& move(T& object) { + return std::move(object); + } + }; + + /** + * \brief Object forwarder for deferred contexts + * + * This forwarder will create a copy of the object passed + * into it, so that CS chunks can be reused if necessary. + */ + template<> + struct D3D11ContextObjectForwarder { + template + static T move(const T& object) { + return object; + } + }; + + /** + * \brief Common D3D11 device context implementation + * + * Implements all common device context methods, but since this is + * templates with the actual context type (deferred or immediate), + * all methods can call back into context-specific methods without + * having to use virtual methods. + */ + template + class D3D11CommonContext : public D3D11DeviceChild { + constexpr static bool IsDeferred = std::is_same_v; + using Forwarder = D3D11ContextObjectForwarder; + + template friend class D3D11DeviceContextExt; + template friend class D3D11UserDefinedAnnotation; constexpr static VkDeviceSize StagingBufferSize = 4ull << 20; public: - D3D11DeviceContext( + D3D11CommonContext( D3D11Device* pParent, const Rc& Device, + UINT ContextFlags, DxvkCsChunkFlags CsFlags); - ~D3D11DeviceContext(); - + + ~D3D11CommonContext(); + HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, void** ppvObject); + + D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType(); + + UINT STDMETHODCALLTYPE GetContextFlags(); + void STDMETHODCALLTYPE ClearState(); + void STDMETHODCALLTYPE DiscardResource(ID3D11Resource *pResource); void STDMETHODCALLTYPE DiscardView(ID3D11View* pResourceView); @@ -44,17 +101,7 @@ namespace dxvk { ID3D11View* pResourceView, const D3D11_RECT* pRects, UINT NumRects); - - void STDMETHODCALLTYPE ClearState(); - - void STDMETHODCALLTYPE SetPredication( - ID3D11Predicate* pPredicate, - BOOL PredicateValue); - - void STDMETHODCALLTYPE GetPredication( - ID3D11Predicate** ppPredicate, - BOOL* pPredicateValue); - + void STDMETHODCALLTYPE CopySubresourceRegion( ID3D11Resource* pDstResource, UINT DstSubresource, @@ -64,7 +111,7 @@ namespace dxvk { ID3D11Resource* pSrcResource, UINT SrcSubresource, const D3D11_BOX* pSrcBox); - + void STDMETHODCALLTYPE CopySubresourceRegion1( ID3D11Resource* pDstResource, UINT DstSubresource, @@ -75,58 +122,34 @@ namespace dxvk { UINT SrcSubresource, const D3D11_BOX* pSrcBox, UINT CopyFlags); - + void STDMETHODCALLTYPE CopyResource( ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource); - + void STDMETHODCALLTYPE CopyStructureCount( ID3D11Buffer* pDstBuffer, UINT DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView); - void STDMETHODCALLTYPE CopyTiles( - ID3D11Resource* pTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pTileRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pTileRegionSize, - ID3D11Buffer* pBuffer, - UINT64 BufferStartOffsetInBytes, - UINT Flags); - - HRESULT STDMETHODCALLTYPE CopyTileMappings( - ID3D11Resource* pDestTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pDestRegionStartCoordinate, - ID3D11Resource* pSourceTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pSourceRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pTileRegionSize, - UINT Flags); - - HRESULT STDMETHODCALLTYPE ResizeTilePool( - ID3D11Buffer* pTilePool, - UINT64 NewSizeInBytes); - - void STDMETHODCALLTYPE TiledResourceBarrier( - ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, - ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier); - void STDMETHODCALLTYPE ClearRenderTargetView( ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4]); - + void STDMETHODCALLTYPE ClearUnorderedAccessViewUint( ID3D11UnorderedAccessView* pUnorderedAccessView, const UINT Values[4]); - + void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat( ID3D11UnorderedAccessView* pUnorderedAccessView, const FLOAT Values[4]); - + void STDMETHODCALLTYPE ClearDepthStencilView( ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags, FLOAT Depth, UINT8 Stencil); - + void STDMETHODCALLTYPE ClearView( ID3D11View *pView, const FLOAT Color[4], @@ -135,122 +158,113 @@ namespace dxvk { void STDMETHODCALLTYPE GenerateMips( ID3D11ShaderResourceView* pShaderResourceView); - - HRESULT STDMETHODCALLTYPE UpdateTileMappings( - ID3D11Resource* pTiledResource, - UINT NumTiledResourceRegions, - const D3D11_TILED_RESOURCE_COORDINATE* pTiledResourceRegionStartCoordinates, - const D3D11_TILE_REGION_SIZE* pTiledResourceRegionSizes, - ID3D11Buffer* pTilePool, - UINT NumRanges, - const UINT* pRangeFlags, - const UINT* pTilePoolStartOffsets, - const UINT* pRangeTileCounts, - UINT Flags); - void STDMETHODCALLTYPE UpdateTiles( - ID3D11Resource* pDestTiledResource, - const D3D11_TILED_RESOURCE_COORDINATE* pDestTileRegionStartCoordinate, - const D3D11_TILE_REGION_SIZE* pDestTileRegionSize, - const void* pSourceTileData, - UINT Flags); - - void STDMETHODCALLTYPE SetResourceMinLOD( - ID3D11Resource* pResource, - FLOAT MinLOD); - - FLOAT STDMETHODCALLTYPE GetResourceMinLOD( - ID3D11Resource* pResource); - void STDMETHODCALLTYPE ResolveSubresource( ID3D11Resource* pDstResource, UINT DstSubresource, ID3D11Resource* pSrcResource, UINT SrcSubresource, DXGI_FORMAT Format); - + + 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 DrawAuto(); - + void STDMETHODCALLTYPE Draw( UINT VertexCount, UINT StartVertexLocation); - + void STDMETHODCALLTYPE DrawIndexed( UINT IndexCount, UINT StartIndexLocation, INT BaseVertexLocation); - + void STDMETHODCALLTYPE DrawInstanced( UINT VertexCountPerInstance, UINT InstanceCount, UINT StartVertexLocation, UINT StartInstanceLocation); - + void STDMETHODCALLTYPE DrawIndexedInstanced( UINT IndexCountPerInstance, UINT InstanceCount, UINT StartIndexLocation, INT BaseVertexLocation, UINT StartInstanceLocation); - + void STDMETHODCALLTYPE DrawIndexedInstancedIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs); - + void STDMETHODCALLTYPE DrawInstancedIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs); - + void STDMETHODCALLTYPE Dispatch( UINT ThreadGroupCountX, UINT ThreadGroupCountY, UINT ThreadGroupCountZ); - + void STDMETHODCALLTYPE DispatchIndirect( ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs); - + void STDMETHODCALLTYPE IASetInputLayout( ID3D11InputLayout* pInputLayout); - + void STDMETHODCALLTYPE IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY Topology); - + void STDMETHODCALLTYPE IASetVertexBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppVertexBuffers, const UINT* pStrides, const UINT* pOffsets); - + void STDMETHODCALLTYPE IASetIndexBuffer( ID3D11Buffer* pIndexBuffer, DXGI_FORMAT Format, UINT Offset); - + void STDMETHODCALLTYPE IAGetInputLayout( ID3D11InputLayout** ppInputLayout); - + void STDMETHODCALLTYPE IAGetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY* pTopology); - + void STDMETHODCALLTYPE IAGetVertexBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppVertexBuffers, UINT* pStrides, UINT* pOffsets); - + void STDMETHODCALLTYPE IAGetIndexBuffer( ID3D11Buffer** ppIndexBuffer, DXGI_FORMAT* pFormat, UINT* pOffset); - + void STDMETHODCALLTYPE VSSetShader( ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - + void STDMETHODCALLTYPE VSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, @@ -262,22 +276,22 @@ namespace dxvk { ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants); - + void STDMETHODCALLTYPE VSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE VSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE VSGetShader( ID3D11VertexShader** ppVertexShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE VSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, @@ -289,49 +303,49 @@ namespace dxvk { ID3D11Buffer** ppConstantBuffers, UINT* pFirstConstant, UINT* pNumConstants); - + void STDMETHODCALLTYPE VSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE VSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE HSSetShader( ID3D11HullShader* pHullShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - - void STDMETHODCALLTYPE HSSetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE HSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers); - + void STDMETHODCALLTYPE HSSetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants); - + + void STDMETHODCALLTYPE HSSetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView* const* ppShaderResourceViews); + void STDMETHODCALLTYPE HSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE HSGetShader( ID3D11HullShader** ppHullShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE HSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, @@ -343,27 +357,22 @@ namespace dxvk { ID3D11Buffer** ppConstantBuffers, UINT* pFirstConstant, UINT* pNumConstants); - + void STDMETHODCALLTYPE HSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE HSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE DSSetShader( ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - - void STDMETHODCALLTYPE DSSetShaderResources( - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE DSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, @@ -375,49 +384,54 @@ namespace dxvk { ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants); - + + void STDMETHODCALLTYPE DSSetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView* const* ppShaderResourceViews); + void STDMETHODCALLTYPE DSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE DSGetShader( ID3D11DomainShader** ppDomainShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE DSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers); - + void STDMETHODCALLTYPE DSGetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers, UINT* pFirstConstant, UINT* pNumConstants); - + void STDMETHODCALLTYPE DSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE DSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE GSSetShader( ID3D11GeometryShader* pShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - + void STDMETHODCALLTYPE GSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers); - + void STDMETHODCALLTYPE GSSetConstantBuffers1( UINT StartSlot, UINT NumBuffers, @@ -429,44 +443,44 @@ namespace dxvk { UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE GSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE GSGetShader( ID3D11GeometryShader** ppGeometryShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE GSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers); - + void STDMETHODCALLTYPE GSGetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers, UINT* pFirstConstant, UINT* pNumConstants); - + void STDMETHODCALLTYPE GSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE GSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE PSSetShader( ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - + void STDMETHODCALLTYPE PSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, @@ -478,27 +492,27 @@ namespace dxvk { ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants); - + void STDMETHODCALLTYPE PSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE PSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE PSGetShader( ID3D11PixelShader** ppPixelShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE PSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers); - + void STDMETHODCALLTYPE PSGetConstantBuffers1( UINT StartSlot, UINT NumBuffers, @@ -510,82 +524,82 @@ namespace dxvk { UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE PSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE CSSetShader( ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances); - + void STDMETHODCALLTYPE CSSetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers); - + void STDMETHODCALLTYPE CSSetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers, const UINT* pFirstConstant, const UINT* pNumConstants); - + void STDMETHODCALLTYPE CSSetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews); - + void STDMETHODCALLTYPE CSSetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers); - + void STDMETHODCALLTYPE CSSetUnorderedAccessViews( UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts); - + void STDMETHODCALLTYPE CSGetShader( ID3D11ComputeShader** ppComputeShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances); - + void STDMETHODCALLTYPE CSGetConstantBuffers( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers); - + void STDMETHODCALLTYPE CSGetConstantBuffers1( UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers, UINT* pFirstConstant, UINT* pNumConstants); - + void STDMETHODCALLTYPE CSGetShaderResources( UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews); - + void STDMETHODCALLTYPE CSGetSamplers( UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers); - + void STDMETHODCALLTYPE CSGetUnorderedAccessViews( UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews); - + void STDMETHODCALLTYPE OMSetRenderTargets( UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView); - + void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews( UINT NumRTVs, ID3D11RenderTargetView* const* ppRenderTargetViews, @@ -594,21 +608,21 @@ namespace dxvk { UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts); - + void STDMETHODCALLTYPE OMSetBlendState( ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask); - + void STDMETHODCALLTYPE OMSetDepthStencilState( ID3D11DepthStencilState* pDepthStencilState, UINT StencilRef); - + void STDMETHODCALLTYPE OMGetRenderTargets( UINT NumViews, ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView); - + void STDMETHODCALLTYPE OMGetRenderTargetsAndUnorderedAccessViews( UINT NumRTVs, ID3D11RenderTargetView** ppRenderTargetViews, @@ -616,52 +630,110 @@ namespace dxvk { UINT UAVStartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews); - + void STDMETHODCALLTYPE OMGetBlendState( ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask); - + void STDMETHODCALLTYPE OMGetDepthStencilState( ID3D11DepthStencilState** ppDepthStencilState, UINT* pStencilRef); - + void STDMETHODCALLTYPE RSSetState( ID3D11RasterizerState* pRasterizerState); - + void STDMETHODCALLTYPE RSSetViewports( UINT NumViewports, const D3D11_VIEWPORT* pViewports); - + void STDMETHODCALLTYPE RSSetScissorRects( UINT NumRects, const D3D11_RECT* pRects); - + void STDMETHODCALLTYPE RSGetState( ID3D11RasterizerState** ppRasterizerState); - + void STDMETHODCALLTYPE RSGetViewports( UINT* pNumViewports, D3D11_VIEWPORT* pViewports); - + void STDMETHODCALLTYPE RSGetScissorRects( UINT* pNumRects, D3D11_RECT* pRects); - + void STDMETHODCALLTYPE SOSetTargets( UINT NumBuffers, ID3D11Buffer* const* ppSOTargets, const UINT* pOffsets); - + void STDMETHODCALLTYPE SOGetTargets( UINT NumBuffers, ID3D11Buffer** ppSOTargets); - + void STDMETHODCALLTYPE SOGetTargetsWithOffsets( UINT NumBuffers, ID3D11Buffer** ppSOTargets, UINT* pOffsets); - + + void STDMETHODCALLTYPE SetPredication( + ID3D11Predicate* pPredicate, + BOOL PredicateValue); + + void STDMETHODCALLTYPE GetPredication( + ID3D11Predicate** ppPredicate, + BOOL* pPredicateValue); + + void STDMETHODCALLTYPE SetResourceMinLOD( + ID3D11Resource* pResource, + FLOAT MinLOD); + + FLOAT STDMETHODCALLTYPE GetResourceMinLOD( + ID3D11Resource* pResource); + + void STDMETHODCALLTYPE CopyTiles( + ID3D11Resource* pTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pTileRegionStartCoordinate, + const D3D11_TILE_REGION_SIZE* pTileRegionSize, + ID3D11Buffer* pBuffer, + UINT64 BufferStartOffsetInBytes, + UINT Flags); + + HRESULT STDMETHODCALLTYPE CopyTileMappings( + ID3D11Resource* pDestTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pDestRegionCoordinate, + ID3D11Resource* pSourceTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pSourceRegionCoordinate, + const D3D11_TILE_REGION_SIZE* pTileRegionSize, + UINT Flags); + + HRESULT STDMETHODCALLTYPE ResizeTilePool( + ID3D11Buffer* pTilePool, + UINT64 NewSizeInBytes); + + void STDMETHODCALLTYPE TiledResourceBarrier( + ID3D11DeviceChild* pTiledResourceOrViewAccessBeforeBarrier, + ID3D11DeviceChild* pTiledResourceOrViewAccessAfterBarrier); + + HRESULT STDMETHODCALLTYPE UpdateTileMappings( + ID3D11Resource* pTiledResource, + UINT NumRegions, + const D3D11_TILED_RESOURCE_COORDINATE* pRegionCoordinates, + const D3D11_TILE_REGION_SIZE* pRegionSizes, + ID3D11Buffer* pTilePool, + UINT NumRanges, + const UINT* pRangeFlags, + const UINT* pRangeTileOffsets, + const UINT* pRangeTileCounts, + UINT Flags); + + void STDMETHODCALLTYPE UpdateTiles( + ID3D11Resource* pDestTiledResource, + const D3D11_TILED_RESOURCE_COORDINATE* pDestTileRegionStartCoordinate, + const D3D11_TILE_REGION_SIZE* pDestTileRegionSize, + const void* pSourceTileData, + UINT Flags); + BOOL STDMETHODCALLTYPE IsAnnotationEnabled(); void STDMETHODCALLTYPE SetMarkerInt( @@ -676,7 +748,7 @@ namespace dxvk { void STDMETHODCALLTYPE GetHardwareProtectionState( BOOL* pHwProtectionEnable); - + void STDMETHODCALLTYPE SetHardwareProtectionState( BOOL HwProtectionEnable); @@ -686,29 +758,30 @@ namespace dxvk { VkImageLayout OldLayout, VkImageLayout NewLayout); - D3D10DeviceLock LockContext() { - return m_multithread.AcquireLock(); - } - protected: - - D3D11DeviceContextExt m_contextExt; - D3D10Multithread m_multithread; - + + D3D11DeviceContextExt m_contextExt; + D3D11UserDefinedAnnotation m_annotation; + Rc m_device; - Rc m_updateBuffer; + + D3D11ContextState m_state; + UINT m_flags; DxvkStagingBuffer m_staging; - - //has to be declared after m_device, as compiler initialize in order of declaration in the class - D3D11UserDefinedAnnotation m_annotation; + Rc m_updateBuffer; DxvkCsChunkFlags m_csFlags; DxvkCsChunkRef m_csChunk; - - D3D11ContextState m_state; D3D11CmdData* m_cmdData; + + DxvkCsChunkRef AllocCsChunk(); + DxvkDataSlice AllocUpdateBufferSlice(size_t Size); + + DxvkBufferSlice AllocStagingBuffer( + VkDeviceSize Size); + void ApplyInputLayout(); void ApplyPrimitiveTopology(); @@ -723,54 +796,81 @@ namespace dxvk { void ApplyRasterizerState(); + void ApplyRasterizerSampleCount(); + void ApplyViewportState(); template void BindShader( const D3D11CommonShader* pShaderModule); - + void BindFramebuffer(); - + void BindDrawBuffers( D3D11Buffer* pBufferForArgs, D3D11Buffer* pBufferForCount); - + void BindVertexBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset, UINT Stride); - + + void BindVertexBufferRange( + UINT Slot, + D3D11Buffer* pBuffer, + UINT Offset, + UINT Stride); + void BindIndexBuffer( D3D11Buffer* pBuffer, UINT Offset, DXGI_FORMAT Format); - + + void BindIndexBufferRange( + D3D11Buffer* pBuffer, + UINT Offset, + DXGI_FORMAT Format); + void BindXfbBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset); - + + template void BindConstantBuffer( UINT Slot, D3D11Buffer* pBuffer, UINT Offset, UINT Length); - + + template + void BindConstantBufferRange( + UINT Slot, + UINT Offset, + UINT Length); + + template void BindSampler( UINT Slot, D3D11SamplerState* pSampler); - + + template void BindShaderResource( UINT Slot, D3D11ShaderResourceView* pResource); - + + template void BindUnorderedAccessView( UINT UavSlot, D3D11UnorderedAccessView* pUav, UINT CtrSlot, UINT Counter); + VkClearValue ConvertColorValue( + const FLOAT Color[4], + const DxvkFormatInfo* pFormatInfo); + void CopyBuffer( D3D11Buffer* pDstBuffer, VkDeviceSize DstOffset, @@ -787,74 +887,134 @@ namespace dxvk { VkOffset3D SrcOffset, VkExtent3D SrcExtent); + void CopyTiledResourceData( + ID3D11Resource* pResource, + const D3D11_TILED_RESOURCE_COORDINATE* pRegionCoordinate, + const D3D11_TILE_REGION_SIZE* pRegionSize, + DxvkBufferSlice BufferSlice, + UINT Flags); + void DiscardBuffer( ID3D11Resource* pResource); - + void DiscardTexture( ID3D11Resource* pResource, UINT Subresource); - template - static void UpdateResource( - ContextType* pContext, - ID3D11Resource* pDstResource, - UINT DstSubresource, - const D3D11_BOX* pDstBox, - const void* pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch, - UINT CopyFlags) { - D3D10DeviceLock lock = pContext->LockContext(); + template + void GetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer** ppConstantBuffers, + UINT* pFirstConstant, + UINT* pNumConstants); - if (!pDstResource) - return; + template + void GetShaderResources( + UINT StartSlot, + UINT NumViews, + ID3D11ShaderResourceView** ppShaderResourceViews); - // We need a different code path for buffers - D3D11_RESOURCE_DIMENSION resourceType; - pDstResource->GetType(&resourceType); + template + void GetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState** ppSamplers); - if (likely(resourceType == D3D11_RESOURCE_DIMENSION_BUFFER)) { - const auto bufferResource = static_cast(pDstResource); - uint64_t bufferSize = bufferResource->Desc()->ByteWidth; + DxvkGlobalPipelineBarrier GetTiledResourceDependency( + ID3D11DeviceChild* pObject); - // Provide a fast path for mapped buffer updates since some - // games use UpdateSubresource to update constant buffers. - if (likely(bufferResource->GetMapMode() == D3D11_COMMON_BUFFER_MAP_MODE_DIRECT) && likely(!pDstBox)) { - pContext->UpdateMappedBuffer(bufferResource, 0, bufferSize, pSrcData, 0); - return; - } + D3D11MaxUsedBindings GetMaxUsedBindings(); - // Validate buffer range to update - uint64_t offset = 0; - uint64_t length = bufferSize; + void ResetCommandListState(); - if (pDstBox) { - offset = pDstBox->left; - length = pDstBox->right - offset; - } + void ResetContextState(); - if (unlikely(offset + length > bufferSize)) - return; + void ResetStagingBuffer(); - // Still try to be fast if a box is provided but we update the full buffer - if (likely(bufferResource->GetMapMode() == D3D11_COMMON_BUFFER_MAP_MODE_DIRECT)) { - CopyFlags &= D3D11_COPY_DISCARD | D3D11_COPY_NO_OVERWRITE; + template + void ResolveSrvHazards( + T* pView); - if (likely(length == bufferSize) || unlikely(CopyFlags != 0)) { - pContext->UpdateMappedBuffer(bufferResource, offset, length, pSrcData, CopyFlags); - return; - } - } + template + void ResolveCsSrvHazards( + T* pView); - // Otherwise we can't really do anything fancy, so just do a GPU copy - pContext->UpdateBuffer(bufferResource, offset, length, pSrcData); - } else { - D3D11CommonTexture* textureResource = GetCommonTexture(pDstResource); + template + void ResolveOmSrvHazards( + T* pView); - pContext->UpdateTexture(textureResource, - DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); - } - } + bool ResolveOmRtvHazards( + D3D11UnorderedAccessView* pView); + + void ResolveOmUavHazards( + D3D11RenderTargetView* pView); + + void RestoreCommandListState(); + + template + void RestoreConstantBuffers(); + + template + void RestoreSamplers(); + + template + void RestoreShaderResources(); + + template + void RestoreUnorderedAccessViews(); + + template + void SetConstantBuffers( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers); + + template + void SetConstantBuffers1( + UINT StartSlot, + UINT NumBuffers, + ID3D11Buffer* const* ppConstantBuffers, + const UINT* pFirstConstant, + const UINT* pNumConstants); + + template + void SetShaderResources( + UINT StartSlot, + UINT NumResources, + ID3D11ShaderResourceView* const* ppResources); + + template + void SetSamplers( + UINT StartSlot, + UINT NumSamplers, + ID3D11SamplerState* const* ppSamplers); + + void SetRenderTargetsAndUnorderedAccessViews( + UINT NumRTVs, + ID3D11RenderTargetView* const* ppRenderTargetViews, + ID3D11DepthStencilView* pDepthStencilView, + UINT UAVStartSlot, + UINT NumUAVs, + ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, + const UINT* pUAVInitialCounts); + + void SetDrawBuffers( + ID3D11Buffer* pBufferForArgs, + ID3D11Buffer* pBufferForCount); + + bool TestRtvUavHazards( + UINT NumRTVs, + ID3D11RenderTargetView* const* ppRTVs, + UINT NumUAVs, + ID3D11UnorderedAccessView* const* ppUAVs); + + template + bool TestSrvHazards( + D3D11ShaderResourceView* pView); + + void TrackResourceSequenceNumber( + ID3D11Resource* pResource); void UpdateBuffer( D3D11Buffer* pDstBuffer, @@ -877,127 +1037,20 @@ namespace dxvk { VkExtent3D DstExtent, DxvkBufferSlice StagingBuffer); - void SetDrawBuffers( - ID3D11Buffer* pBufferForArgs, - ID3D11Buffer* pBufferForCount); - - template - void SetConstantBuffers( - D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers); - - template - void SetConstantBuffers1( - D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer* const* ppConstantBuffers, - const UINT* pFirstConstant, - const UINT* pNumConstants); - - template - void SetSamplers( - D3D11SamplerBindings& Bindings, - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState* const* ppSamplers); - - template - void SetShaderResources( - D3D11ShaderResourceBindings& Bindings, - UINT StartSlot, - UINT NumResources, - ID3D11ShaderResourceView* const* ppResources); - - void GetConstantBuffers( - const D3D11ConstantBufferBindings& Bindings, - UINT StartSlot, - UINT NumBuffers, - ID3D11Buffer** ppConstantBuffers, - UINT* pFirstConstant, - UINT* pNumConstants); + void UpdateResource( + ID3D11Resource* pDstResource, + UINT DstSubresource, + const D3D11_BOX* pDstBox, + const void* pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch, + UINT CopyFlags); - void GetShaderResources( - const D3D11ShaderResourceBindings& Bindings, - UINT StartSlot, - UINT NumViews, - ID3D11ShaderResourceView** ppShaderResourceViews); - - void GetSamplers( - const D3D11SamplerBindings& Bindings, - UINT StartSlot, - UINT NumSamplers, - ID3D11SamplerState** ppSamplers); - - void ResetState(); - - void RestoreState(); - - template - void RestoreConstantBuffers( - D3D11ConstantBufferBindings& Bindings); - - template - void RestoreSamplers( - D3D11SamplerBindings& Bindings); - - template - void RestoreShaderResources( - D3D11ShaderResourceBindings& Bindings); - - template - void RestoreUnorderedAccessViews( - D3D11UnorderedAccessBindings& Bindings); - - bool TestRtvUavHazards( - UINT NumRTVs, - ID3D11RenderTargetView* const* ppRTVs, - UINT NumUAVs, - ID3D11UnorderedAccessView* const* ppUAVs); - - template - bool TestSrvHazards( - D3D11ShaderResourceView* pView); - - template - void ResolveSrvHazards( - T* pView, - D3D11ShaderResourceBindings& Bindings); - - template - void ResolveCsSrvHazards( - T* pView); - - template - void ResolveOmSrvHazards( - T* pView); - - bool ResolveOmRtvHazards( - D3D11UnorderedAccessView* pView); - - void ResolveOmUavHazards( - D3D11RenderTargetView* pView); - bool ValidateRenderTargets( UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView); - VkClearValue ConvertColorValue( - const FLOAT Color[4], - const DxvkFormatInfo* pFormatInfo); - - DxvkDataSlice AllocUpdateBufferSlice(size_t Size); - - DxvkBufferSlice AllocStagingBuffer( - VkDeviceSize Size); - - void ResetStagingBuffer(); - - DxvkCsChunkRef AllocCsChunk(); - static void InitDefaultPrimitiveTopology( DxvkInputAssemblyState* pIaState); @@ -1013,6 +1066,51 @@ namespace dxvk { DxvkMultisampleState* pMsState, UINT SampleMask); + template + void EmitCs(Cmd&& command) { + m_cmdData = nullptr; + + if (unlikely(!m_csChunk->push(command))) { + GetTypedContext()->EmitCsChunk(std::move(m_csChunk)); + m_csChunk = AllocCsChunk(); + + if constexpr (AllowFlush) + GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint); + + m_csChunk->push(command); + } + } + + template + M* EmitCsCmd(Cmd&& command, Args&&... args) { + M* data = m_csChunk->pushCmd( + command, std::forward(args)...); + + if (unlikely(!data)) { + GetTypedContext()->EmitCsChunk(std::move(m_csChunk)); + m_csChunk = AllocCsChunk(); + + if constexpr (AllowFlush) + GetTypedContext()->ConsiderFlush(GpuFlushType::ImplicitWeakHint); + + // We must record this command after the potential + // flush since the caller may still access the data + data = m_csChunk->pushCmd( + command, std::forward(args)...); + } + + m_cmdData = data; + return data; + } + + void FlushCsChunk() { + if (likely(!m_csChunk->empty())) { + GetTypedContext()->EmitCsChunk(std::move(m_csChunk)); + m_csChunk = AllocCsChunk(); + m_cmdData = nullptr; + } + } + template const D3D11CommonShader* GetCommonShader(T* pShader) const { return pShader != nullptr ? pShader->GetCommonShader() : nullptr; @@ -1034,55 +1132,16 @@ namespace dxvk { return bufferSize >= Offset + Size; } - - template - void EmitCs(Cmd&& command) { - m_cmdData = nullptr; - if (unlikely(!m_csChunk->push(command))) { - EmitCsChunk(std::move(m_csChunk)); - - m_csChunk = AllocCsChunk(); - m_csChunk->push(command); - } + private: + + ContextType* GetTypedContext() { + return static_cast(this); } - template - M* EmitCsCmd(Cmd&& command, Args&&... args) { - M* data = m_csChunk->pushCmd( - command, std::forward(args)...); - - if (unlikely(!data)) { - EmitCsChunk(std::move(m_csChunk)); - - m_csChunk = AllocCsChunk(); - data = m_csChunk->pushCmd( - command, std::forward(args)...); - } - - m_cmdData = data; - return data; + D3D10DeviceLock LockContext() { + return GetTypedContext()->LockContext(); } - - void FlushCsChunk() { - if (likely(!m_csChunk->empty())) { - EmitCsChunk(std::move(m_csChunk)); - m_csChunk = AllocCsChunk(); - m_cmdData = nullptr; - } - } - - void TrackResourceSequenceNumber( - ID3D11Resource* pResource); - - virtual void EmitCsChunk(DxvkCsChunkRef&& chunk) = 0; - - virtual void TrackTextureSequenceNumber( - D3D11CommonTexture* pResource, - UINT Subresource) = 0; - - virtual void TrackBufferSequenceNumber( - D3D11Buffer* pResource) = 0; }; diff --git a/src/d3d11/d3d11_context_def.cpp b/src/d3d11/d3d11_context_def.cpp index 552cfcc8..a3f740f4 100644 --- a/src/d3d11/d3d11_context_def.cpp +++ b/src/d3d11/d3d11_context_def.cpp @@ -7,20 +7,9 @@ namespace dxvk { D3D11Device* pParent, const Rc& Device, UINT ContextFlags) - : D3D11DeviceContext(pParent, Device, GetCsChunkFlags(pParent)), - m_contextFlags(ContextFlags), + : D3D11CommonContext(pParent, Device, ContextFlags, GetCsChunkFlags(pParent)), 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(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(pCommandList); + m_chunkId = m_commandList->AddCommandList(commandList); + // Restore deferred context state if (RestoreContextState) - RestoreState(); + RestoreCommandListState(); else - ClearState(); + ResetContextState(); } @@ -162,17 +163,31 @@ 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(); @@ -236,31 +251,6 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeferredContext::UpdateSubresource( - ID3D11Resource* pDstResource, - UINT DstSubresource, - const D3D11_BOX* pDstBox, - const void* pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch) { - UpdateResource(this, pDstResource, - DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, 0); - } - - - void STDMETHODCALLTYPE D3D11DeferredContext::UpdateSubresource1( - ID3D11Resource* pDstResource, - UINT DstSubresource, - const D3D11_BOX* pDstBox, - const void* pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch, - UINT CopyFlags) { - UpdateResource(this, pDstResource, - DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); - } - - void STDMETHODCALLTYPE D3D11DeferredContext::SwapDeviceContextState( ID3DDeviceContextState* pState, ID3DDeviceContextState** ppPreviousState) { @@ -333,7 +323,7 @@ namespace dxvk { VkFormat packedFormat = pTexture->GetPackedFormat(); - auto formatInfo = imageFormatInfo(packedFormat); + auto formatInfo = lookupFormatInfo(packedFormat); auto subresource = pTexture->GetSubresourceFromIndex( formatInfo->aspectMask, Subresource); @@ -396,12 +386,17 @@ namespace dxvk { Com 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)); + } + + + uint64_t D3D11DeferredContext::GetCurrentChunkId() const { + return m_csChunk->empty() ? m_chunkId : m_chunkId + 1; } @@ -411,14 +406,15 @@ namespace dxvk { m_commandList->TrackResourceUsage( pResource->GetInterface(), pResource->GetDimension(), - Subresource); + Subresource, GetCurrentChunkId()); } void D3D11DeferredContext::TrackBufferSequenceNumber( D3D11Buffer* pResource) { - m_commandList->TrackResourceUsage( - pResource, D3D11_RESOURCE_DIMENSION_BUFFER, 0); + m_commandList->TrackResourceUsage(pResource, + D3D11_RESOURCE_DIMENSION_BUFFER, 0, + GetCurrentChunkId()); } diff --git a/src/d3d11/d3d11_context_def.h b/src/d3d11/d3d11_context_def.h index c5fe49c9..7f1c4eee 100644 --- a/src/d3d11/d3d11_context_def.h +++ b/src/d3d11/d3d11_context_def.h @@ -1,9 +1,7 @@ #pragma once -#include "d3d11_buffer.h" #include "d3d11_cmdlist.h" #include "d3d11_context.h" -#include "d3d11_texture.h" #include @@ -23,8 +21,8 @@ namespace dxvk { D3D11_MAPPED_SUBRESOURCE MapInfo; }; - class D3D11DeferredContext : public D3D11DeviceContext { - friend class D3D11DeviceContext; + class D3D11DeferredContext : public D3D11CommonContext { + friend class D3D11CommonContext; public: D3D11DeferredContext( @@ -32,10 +30,6 @@ namespace dxvk { const Rc& Device, UINT ContextFlags); - D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType(); - - UINT STDMETHODCALLTYPE GetContextFlags(); - HRESULT STDMETHODCALLTYPE GetData( ID3D11Asynchronous* pAsync, void* pData, @@ -81,31 +75,16 @@ 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 SwapDeviceContextState( ID3DDeviceContextState* pState, ID3DDeviceContextState** ppPreviousState); + D3D10DeviceLock LockContext() { + return D3D10DeviceLock(); + } + private: - const UINT m_contextFlags; - // Command list that we're recording Com m_commandList; @@ -117,6 +96,9 @@ namespace dxvk { // Begun and ended queries, will also be stored in command list std::vector> m_queriesBegun; + // Chunk ID within the current command list + uint64_t m_chunkId = 0ull; + HRESULT MapBuffer( ID3D11Resource* pResource, D3D11_MAPPED_SUBRESOURCE* pMappedResource); @@ -139,6 +121,8 @@ namespace dxvk { void EmitCsChunk(DxvkCsChunkRef&& chunk); + uint64_t GetCurrentChunkId() const; + void TrackTextureSequenceNumber( D3D11CommonTexture* pResource, UINT Subresource); diff --git a/src/d3d11/d3d11_context_ext.cpp b/src/d3d11/d3d11_context_ext.cpp index ecd41e83..c89e0bc0 100644 --- a/src/d3d11/d3d11_context_ext.cpp +++ b/src/d3d11/d3d11_context_ext.cpp @@ -3,38 +3,44 @@ #include #include "d3d11_device.h" -#include "d3d11_context.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 + D3D11DeviceContextExt::D3D11DeviceContextExt( + ContextType* pContext) : m_ctx(pContext) { } - ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::AddRef() { + template + ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::AddRef() { return m_ctx->AddRef(); } - ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::Release() { + template + ULONG STDMETHODCALLTYPE D3D11DeviceContextExt::Release() { return m_ctx->Release(); } - HRESULT STDMETHODCALLTYPE D3D11DeviceContextExt::QueryInterface( + template + HRESULT STDMETHODCALLTYPE D3D11DeviceContextExt::QueryInterface( REFIID riid, void** ppvObject) { return m_ctx->QueryInterface(riid, ppvObject); } - void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirect( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirect( UINT DrawCount, ID3D11Buffer* pBufferForArgs, UINT ByteOffsetForArgs, @@ -52,7 +58,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirect( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirect( UINT DrawCount, ID3D11Buffer* pBufferForArgs, UINT ByteOffsetForArgs, @@ -70,7 +77,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirectCount( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndirectCount( UINT MaxDrawCount, ID3D11Buffer* pBufferForCount, UINT ByteOffsetForCount, @@ -91,7 +99,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirectCount( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::MultiDrawIndexedIndirectCount( UINT MaxDrawCount, ID3D11Buffer* pBufferForCount, UINT ByteOffsetForCount, @@ -112,7 +121,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContextExt::SetDepthBoundsTest( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::SetDepthBoundsTest( BOOL Enable, FLOAT MinDepthBounds, FLOAT MaxDepthBounds) { @@ -129,7 +139,8 @@ namespace dxvk { } - void STDMETHODCALLTYPE D3D11DeviceContextExt::SetBarrierControl( + template + void STDMETHODCALLTYPE D3D11DeviceContextExt::SetBarrierControl( UINT ControlFlags) { D3D10DeviceLock lock = m_ctx->LockContext(); DxvkBarrierControlFlags flags; @@ -146,7 +157,8 @@ namespace dxvk { } - bool STDMETHODCALLTYPE D3D11DeviceContextExt::LaunchCubinShaderNVX(IUnknown* hShader, uint32_t GridX, uint32_t GridY, uint32_t GridZ, + template + bool STDMETHODCALLTYPE D3D11DeviceContextExt::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(); @@ -202,4 +214,9 @@ namespace dxvk { return true; } + + + template class D3D11DeviceContextExt; + template class D3D11DeviceContextExt; + } diff --git a/src/d3d11/d3d11_context_ext.h b/src/d3d11/d3d11_context_ext.h index 2109a0de..6b95dcf9 100644 --- a/src/d3d11/d3d11_context_ext.h +++ b/src/d3d11/d3d11_context_ext.h @@ -4,14 +4,16 @@ namespace dxvk { - class D3D11DeviceContext; + class D3D11DeferredContext; + class D3D11ImmediateContext; + template class D3D11DeviceContextExt : public ID3D11VkExtContext1 { public: D3D11DeviceContextExt( - D3D11DeviceContext* pContext); + ContextType* pContext); ULONG STDMETHODCALLTYPE AddRef(); @@ -71,7 +73,7 @@ namespace dxvk { private: - D3D11DeviceContext* m_ctx; + ContextType* m_ctx; }; diff --git a/src/d3d11/d3d11_context_imm.cpp b/src/d3d11/d3d11_context_imm.cpp index 0ff64e25..466e9a96 100644 --- a/src/d3d11/d3d11_context_imm.cpp +++ b/src/d3d11/d3d11_context_imm.cpp @@ -1,8 +1,11 @@ #include "d3d11_cmdlist.h" #include "d3d11_context_imm.h" #include "d3d11_device.h" +#include "d3d11_fence.h" #include "d3d11_texture.h" +#include "../util/util_win32_compat.h" + constexpr static uint32_t MinFlushIntervalUs = 750; constexpr static uint32_t IncFlushIntervalUs = 250; constexpr static uint32_t MaxPendingSubmits = 6; @@ -12,9 +15,11 @@ namespace dxvk { D3D11ImmediateContext::D3D11ImmediateContext( D3D11Device* pParent, const Rc& Device) - : D3D11DeviceContext(pParent, Device, DxvkCsChunkFlag::SingleUse), - m_csThread(Device, Device->createContext()), + : D3D11CommonContext(pParent, Device, 0, DxvkCsChunkFlag::SingleUse), + m_csThread(Device, Device->createContext(DxvkContextType::Primary)), m_maxImplicitDiscardSize(pParent->GetOptions()->maxImplicitDiscardSize), + m_submissionFence(new sync::CallbackFence()), + m_multithread(this, false, pParent->GetOptions()->enableContextLock), m_videoContext(this, Device) { EmitCs([ cDevice = m_device, @@ -39,32 +44,32 @@ namespace dxvk { D3D11ImmediateContext::~D3D11ImmediateContext() { - Flush(); + // Avoids hanging when in this state, see comment + // in DxvkDevice::~DxvkDevice. + if (this_thread::isInModuleDetachment()) + return; + + ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true); SynchronizeCsThread(DxvkCsThread::SynchronizeAll); SynchronizeDevice(); } HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::QueryInterface(REFIID riid, void** ppvObject) { + if (riid == __uuidof(ID3D10Multithread)) { + *ppvObject = ref(&m_multithread); + return S_OK; + } + if (riid == __uuidof(ID3D11VideoContext)) { *ppvObject = ref(&m_videoContext); return S_OK; } - return D3D11DeviceContext::QueryInterface(riid, ppvObject); + return D3D11CommonContext::QueryInterface(riid, ppvObject); } - D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE D3D11ImmediateContext::GetType() { - return D3D11_DEVICE_CONTEXT_IMMEDIATE; - } - - - UINT STDMETHODCALLTYPE D3D11ImmediateContext::GetContextFlags() { - return 0; - } - - HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::GetData( ID3D11Asynchronous* pAsync, void* pData, @@ -95,7 +100,8 @@ namespace dxvk { // Ignore the DONOTFLUSH flag here as some games will spin // on queries without ever flushing the context otherwise. - FlushImplicit(FALSE); + D3D10DeviceLock lock = LockContext(); + ConsiderFlush(GpuFlushType::ImplicitSynchronization); } return hr; @@ -144,57 +150,69 @@ namespace dxvk { query->NotifyEnd(); if (query->IsStalling()) - Flush(); + ExecuteFlush(GpuFlushType::ImplicitSynchronization, nullptr, false); else if (query->IsEvent()) - FlushImplicit(TRUE); + ConsiderFlush(GpuFlushType::ImplicitStrongHint); } } void STDMETHODCALLTYPE D3D11ImmediateContext::Flush() { - Flush1(D3D11_CONTEXT_TYPE_ALL, nullptr); + D3D10DeviceLock lock = LockContext(); + + ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true); } void STDMETHODCALLTYPE D3D11ImmediateContext::Flush1( D3D11_CONTEXT_TYPE ContextType, HANDLE hEvent) { - m_parent->FlushInitContext(); - - if (hEvent) - SignalEvent(hEvent); - D3D10DeviceLock lock = LockContext(); - - if (m_csIsBusy || !m_csChunk->empty()) { - // Add commands to flush the threaded - // context, then flush the command list - EmitCs([] (DxvkContext* ctx) { - ctx->flushCommandList(); - }); - - FlushCsChunk(); - - // Reset flush timer used for implicit flushes - m_lastFlush = dxvk::high_resolution_clock::now(); - m_csIsBusy = false; - } + + ExecuteFlush(GpuFlushType::ExplicitFlush, hEvent, true); } HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::Signal( ID3D11Fence* pFence, UINT64 Value) { - Logger::err("D3D11ImmediateContext::Signal: Not implemented"); - return E_NOTIMPL; + D3D10DeviceLock lock = LockContext(); + auto fence = static_cast(pFence); + + if (!fence) + return E_INVALIDARG; + + EmitCs([ + cFence = fence->GetFence(), + cValue = Value + ] (DxvkContext* ctx) { + ctx->signalFence(cFence, cValue); + }); + + ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true); + return S_OK; } HRESULT STDMETHODCALLTYPE D3D11ImmediateContext::Wait( ID3D11Fence* pFence, UINT64 Value) { - Logger::err("D3D11ImmediateContext::Wait: Not implemented"); - return E_NOTIMPL; + D3D10DeviceLock lock = LockContext(); + auto fence = static_cast(pFence); + + if (!fence) + return E_INVALIDARG; + + ExecuteFlush(GpuFlushType::ExplicitFlush, nullptr, true); + + EmitCs([ + cFence = fence->GetFence(), + cValue = Value + ] (DxvkContext* ctx) { + ctx->waitFence(cFence, cValue); + }); + + return S_OK; } @@ -205,27 +223,39 @@ namespace dxvk { auto commandList = static_cast(pCommandList); + // 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(); // As an optimization, flush everything if the // number of pending draw calls is high enough. - FlushImplicit(FALSE); - - // Dispatch command list to the CS thread and - // restore the immediate context's state - uint64_t csSeqNum = commandList->EmitToCsThread(&m_csThread); - m_csSeqNum = std::max(m_csSeqNum, csSeqNum); - + ConsiderFlush(GpuFlushType::ImplicitWeakHint); + + // Dispatch command list to the CS thread + commandList->EmitToCsThread([this] (DxvkCsChunkRef&& chunk, GpuFlushType flushType) { + EmitCsChunk(std::move(chunk)); + + // Return the sequence number from before the flush since + // that is actually going to be needed for resource tracking + uint64_t csSeqNum = m_csSeqNum; + + // Consider a flush after every chunk in case the app + // submits a very large command list or the GPU is idle + ConsiderFlush(flushType); + return csSeqNum; + }); + + // Restore the immediate context's state if (RestoreContextState) - RestoreState(); + RestoreCommandListState(); else - ClearState(); - - // Mark CS thread as busy so that subsequent - // flush operations get executed correctly. - m_csIsBusy = true; + ResetContextState(); } @@ -290,59 +320,7 @@ namespace dxvk { } } - void STDMETHODCALLTYPE D3D11ImmediateContext::UpdateSubresource( - ID3D11Resource* pDstResource, - UINT DstSubresource, - const D3D11_BOX* pDstBox, - const void* pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch) { - UpdateResource(this, pDstResource, - DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, 0); - } - - void STDMETHODCALLTYPE D3D11ImmediateContext::UpdateSubresource1( - ID3D11Resource* pDstResource, - UINT DstSubresource, - const D3D11_BOX* pDstBox, - const void* pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch, - UINT CopyFlags) { - UpdateResource(this, pDstResource, - DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags); - } - - - void STDMETHODCALLTYPE D3D11ImmediateContext::OMSetRenderTargets( - UINT NumViews, - ID3D11RenderTargetView* const* ppRenderTargetViews, - ID3D11DepthStencilView* pDepthStencilView) { - FlushImplicit(TRUE); - - D3D11DeviceContext::OMSetRenderTargets( - NumViews, ppRenderTargetViews, pDepthStencilView); - } - - - void STDMETHODCALLTYPE D3D11ImmediateContext::OMSetRenderTargetsAndUnorderedAccessViews( - UINT NumRTVs, - ID3D11RenderTargetView* const* ppRenderTargetViews, - ID3D11DepthStencilView* pDepthStencilView, - UINT UAVStartSlot, - UINT NumUAVs, - ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, - const UINT* pUAVInitialCounts) { - FlushImplicit(TRUE); - - D3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews( - NumRTVs, ppRenderTargetViews, pDepthStencilView, - UAVStartSlot, NumUAVs, ppUnorderedAccessViews, - pUAVInitialCounts); - } - - HRESULT D3D11ImmediateContext::MapBuffer( D3D11Buffer* pResource, D3D11_MAP MapType, @@ -407,8 +385,6 @@ namespace dxvk { } if (doInvalidatePreserve) { - FlushImplicit(TRUE); - auto prevSlice = pResource->GetMappedSlice(); auto physSlice = pResource->DiscardSlice(); @@ -472,7 +448,7 @@ namespace dxvk { uint64_t sequenceNumber = pResource->GetSequenceNumber(Subresource); - auto formatInfo = imageFormatInfo(packedFormat); + auto formatInfo = lookupFormatInfo(packedFormat); void* mapPtr; if (mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) { @@ -495,6 +471,20 @@ namespace dxvk { constexpr uint32_t DoWait = (1u << 2); uint32_t doFlags; + if (mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER) { + // If the image can be written by the GPU, we need to update the + // mapped staging buffer to reflect the current image contents. + if (pResource->Desc()->Usage == D3D11_USAGE_DEFAULT) { + bool needsReadback = !pResource->NeedsDirtyRegionTracking(); + + needsReadback |= MapType == D3D11_MAP_READ + || MapType == D3D11_MAP_READ_WRITE; + + if (needsReadback) + ReadbackImageBuffer(pResource, Subresource); + } + } + if (MapType == D3D11_MAP_READ) { // Reads will not change the image content, so we only need // to wait for the GPU to finish writing to the mapped buffer. @@ -540,8 +530,6 @@ namespace dxvk { } if (doFlags & DoInvalidate) { - FlushImplicit(TRUE); - DxvkBufferSliceHandle prevSlice = pResource->GetMappedSlice(Subresource); DxvkBufferSliceHandle physSlice = pResource->DiscardSlice(Subresource); @@ -600,20 +588,116 @@ namespace dxvk { // the given subresource is actually mapped right now m_mappedImageCount -= 1; - if ((mapType != D3D11_MAP_READ) && - (pResource->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER)) { - // Now that data has been written into the buffer, - // we need to copy its contents into the image - VkImageAspectFlags aspectMask = imageFormatInfo(pResource->GetPackedFormat())->aspectMask; - VkImageSubresource subresource = pResource->GetSubresourceFromIndex(aspectMask, Subresource); + if ((mapType != D3D11_MAP_READ) && (pResource->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER)) { + if (pResource->NeedsDirtyRegionTracking()) { + for (uint32_t i = 0; i < pResource->GetDirtyRegionCount(Subresource); i++) { + D3D11_COMMON_TEXTURE_REGION region = pResource->GetDirtyRegion(Subresource, i); + UpdateDirtyImageRegion(pResource, Subresource, ®ion); + } - UpdateImage(pResource, &subresource, VkOffset3D { 0, 0, 0 }, - pResource->MipLevelExtent(subresource.mipLevel), - DxvkBufferSlice(pResource->GetMappedBuffer(Subresource))); + pResource->ClearDirtyRegions(Subresource); + } else { + UpdateDirtyImageRegion(pResource, Subresource, nullptr); + } } } + void D3D11ImmediateContext::ReadbackImageBuffer( + D3D11CommonTexture* pResource, + UINT Subresource) { + VkImageAspectFlags aspectMask = lookupFormatInfo(pResource->GetPackedFormat())->aspectMask; + VkImageSubresource subresource = pResource->GetSubresourceFromIndex(aspectMask, Subresource); + + EmitCs([ + cSrcImage = pResource->GetImage(), + cSrcSubresource = vk::makeSubresourceLayers(subresource), + cDstBuffer = pResource->GetMappedBuffer(Subresource), + cPackedFormat = pResource->GetPackedFormat() + ] (DxvkContext* ctx) { + VkOffset3D offset = { 0, 0, 0 }; + VkExtent3D extent = cSrcImage->mipLevelExtent(cSrcSubresource.mipLevel); + + if (cSrcSubresource.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + ctx->copyImageToBuffer(cDstBuffer, 0, 0, 0, + cSrcImage, cSrcSubresource, offset, extent); + } else { + ctx->copyDepthStencilImageToPackedBuffer(cDstBuffer, 0, + VkOffset2D { 0, 0 }, + VkExtent2D { extent.width, extent.height }, + cSrcImage, cSrcSubresource, + VkOffset2D { 0, 0 }, + VkExtent2D { extent.width, extent.height }, + cPackedFormat); + } + }); + + if (pResource->HasSequenceNumber()) + TrackTextureSequenceNumber(pResource, Subresource); + } + + + void D3D11ImmediateContext::UpdateDirtyImageRegion( + D3D11CommonTexture* pResource, + UINT Subresource, + const D3D11_COMMON_TEXTURE_REGION* pRegion) { + auto formatInfo = lookupFormatInfo(pResource->GetPackedFormat()); + auto subresource = vk::makeSubresourceLayers( + pResource->GetSubresourceFromIndex(formatInfo->aspectMask, Subresource)); + + // Update the entire image if no dirty region was specified + D3D11_COMMON_TEXTURE_REGION region; + + if (pRegion) { + region = *pRegion; + } else { + region.Offset = VkOffset3D { 0, 0, 0 }; + region.Extent = pResource->MipLevelExtent(subresource.mipLevel); + } + + auto subresourceLayout = pResource->GetSubresourceLayout(formatInfo->aspectMask, Subresource); + + // Update dirty region one aspect at a time, due to + // how the data is laid out in the staging buffer. + for (uint32_t i = 0; i < pResource->GetPlaneCount(); i++) { + subresource.aspectMask = formatInfo->aspectMask; + + if (formatInfo->flags.test(DxvkFormatFlag::MultiPlane)) + subresource.aspectMask = vk::getPlaneAspect(i); + + EmitCs([ + cDstImage = pResource->GetImage(), + cDstSubresource = subresource, + cDstOffset = region.Offset, + cDstExtent = region.Extent, + cSrcBuffer = pResource->GetMappedBuffer(Subresource), + cSrcOffset = pResource->ComputeMappedOffset(Subresource, i, region.Offset), + cSrcRowPitch = subresourceLayout.RowPitch, + cSrcDepthPitch = subresourceLayout.DepthPitch, + cPackedFormat = pResource->GetPackedFormat() + ] (DxvkContext* ctx) { + if (cDstSubresource.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + ctx->copyBufferToImage( + cDstImage, cDstSubresource, cDstOffset, cDstExtent, + cSrcBuffer, cSrcOffset, cSrcRowPitch, cSrcDepthPitch); + } else { + ctx->copyPackedBufferToDepthStencilImage( + cDstImage, cDstSubresource, + VkOffset2D { cDstOffset.x, cDstOffset.y }, + VkExtent2D { cDstExtent.width, cDstExtent.height }, + cSrcBuffer, 0, + VkOffset2D { cDstOffset.x, cDstOffset.y }, + VkExtent2D { cDstExtent.width, cDstExtent.height }, + cPackedFormat); + } + }); + } + + if (pResource->HasSequenceNumber()) + TrackTextureSequenceNumber(pResource, Subresource); + } + + void D3D11ImmediateContext::UpdateMappedBuffer( D3D11Buffer* pDstBuffer, UINT Offset, @@ -646,9 +730,12 @@ namespace dxvk { if (!pState) return; - - Com oldState = std::move(m_stateObject); - Com newState = static_cast(pState); + + // Reset all state affected by the current context state + ResetCommandListState(); + + Com oldState = std::move(m_stateObject); + Com newState = static_cast(pState); if (oldState == nullptr) oldState = new D3D11DeviceContextState(m_parent); @@ -661,7 +748,76 @@ namespace dxvk { oldState->SetState(m_state); newState->GetState(m_state); - RestoreState(); + // Restore all state affected by the new context state + RestoreCommandListState(); + } + + + void D3D11ImmediateContext::Acquire11on12Resource( + ID3D11Resource* pResource, + VkImageLayout SrcLayout) { + D3D10DeviceLock lock = LockContext(); + + auto texture = GetCommonTexture(pResource); + auto buffer = GetCommonBuffer(pResource); + + if (buffer) { + EmitCs([ + cBuffer = buffer->GetBuffer() + ] (DxvkContext* ctx) { + ctx->emitBufferBarrier(cBuffer, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT, + cBuffer->info().stages, + cBuffer->info().access); + }); + } else if (texture) { + EmitCs([ + cImage = texture->GetImage(), + cLayout = SrcLayout + ] (DxvkContext* ctx) { + ctx->emitImageBarrier(cImage, cLayout, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT, + cImage->info().layout, + cImage->info().stages, + cImage->info().access); + }); + } + } + + + void D3D11ImmediateContext::Release11on12Resource( + ID3D11Resource* pResource, + VkImageLayout DstLayout) { + D3D10DeviceLock lock = LockContext(); + + auto texture = GetCommonTexture(pResource); + auto buffer = GetCommonBuffer(pResource); + + if (buffer) { + EmitCs([ + cBuffer = buffer->GetBuffer() + ] (DxvkContext* ctx) { + ctx->emitBufferBarrier(cBuffer, + cBuffer->info().stages, + cBuffer->info().access, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT); + }); + } else if (texture) { + EmitCs([ + cImage = texture->GetImage(), + cLayout = DstLayout + ] (DxvkContext* ctx) { + ctx->emitImageBarrier(cImage, + cImage->info().layout, + cImage->info().stages, + cImage->info().access, + cLayout, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT); + }); + } } @@ -682,6 +838,15 @@ namespace dxvk { } + void D3D11ImmediateContext::EndFrame() { + D3D10DeviceLock lock = LockContext(); + + EmitCs([] (DxvkContext* ctx) { + ctx->endFrame(); + }); + } + + bool D3D11ImmediateContext::WaitForResource( const Rc& Resource, uint64_t SequenceNumber, @@ -707,14 +872,14 @@ namespace dxvk { // We don't have to wait, but misbehaving games may // still try to spin on `Map` until the resource is // idle, so we should flush pending commands - FlushImplicit(FALSE); + ConsiderFlush(GpuFlushType::ImplicitSynchronization); return false; } } else { if (isInUse) { // Make sure pending commands using the resource get // executed on the the GPU if we have to wait for it - Flush(); + ExecuteFlush(GpuFlushType::ImplicitSynchronization, nullptr, false); SynchronizeCsThread(SequenceNumber); m_device->waitForResource(Resource, access); @@ -727,7 +892,6 @@ namespace dxvk { void D3D11ImmediateContext::EmitCsChunk(DxvkCsChunkRef&& chunk) { m_csSeqNum = m_csThread.dispatchChunk(std::move(chunk)); - m_csIsBusy = true; } @@ -737,7 +901,7 @@ namespace dxvk { uint64_t sequenceNumber = GetCurrentSequenceNumber(); pResource->TrackSequenceNumber(Subresource, sequenceNumber); - FlushImplicit(TRUE); + ConsiderFlush(GpuFlushType::ImplicitStrongHint); } @@ -746,7 +910,7 @@ namespace dxvk { uint64_t sequenceNumber = GetCurrentSequenceNumber(); pResource->TrackSequenceNumber(sequenceNumber); - FlushImplicit(TRUE); + ConsiderFlush(GpuFlushType::ImplicitStrongHint); } @@ -758,40 +922,67 @@ namespace dxvk { } - void D3D11ImmediateContext::FlushImplicit(BOOL StrongHint) { - // Flush only if the GPU is about to go idle, in - // order to keep the number of submissions low. - uint32_t pending = m_device->pendingSubmissions(); - - if (StrongHint || pending <= MaxPendingSubmits) { - auto now = dxvk::high_resolution_clock::now(); - - uint32_t delay = MinFlushIntervalUs - + IncFlushIntervalUs * pending; - - // Prevent flushing too often in short intervals. - if (now - m_lastFlush >= std::chrono::microseconds(delay)) - Flush(); - } + uint64_t D3D11ImmediateContext::GetPendingCsChunks() { + return GetCurrentSequenceNumber() - m_flushSeqNum; } - void D3D11ImmediateContext::SignalEvent(HANDLE hEvent) { - uint64_t value = ++m_eventCount; + void D3D11ImmediateContext::ConsiderFlush( + GpuFlushType FlushType) { + uint64_t chunkId = GetCurrentSequenceNumber(); + uint64_t submissionId = m_submissionFence->value(); - if (m_eventSignal == nullptr) - m_eventSignal = new sync::CallbackFence(); + if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId)) + ExecuteFlush(FlushType, nullptr, false); + } - m_eventSignal->setCallback(value, [hEvent] { - SetEvent(hEvent); - }); - EmitCs([ - cSignal = m_eventSignal, - cValue = value + void D3D11ImmediateContext::ExecuteFlush( + GpuFlushType FlushType, + HANDLE hEvent, + BOOL Synchronize) { + bool synchronizeSubmission = Synchronize && m_parent->Is11on12Device(); + + if (synchronizeSubmission) + m_submitStatus.result = VK_NOT_READY; + + // Flush init context so that new resources are fully initialized + // before the app can access them in any way. This has to happen + // unconditionally since we may otherwise deadlock on Map. + m_parent->FlushInitContext(); + + // Exit early if there's nothing to do + if (!GetPendingCsChunks() && !hEvent) + return; + + // Signal the submission fence and flush the command list + uint64_t submissionId = ++m_submissionId; + + if (hEvent) { + m_submissionFence->setCallback(submissionId, [hEvent] { + SetEvent(hEvent); + }); + } + + EmitCs([ + cSubmissionFence = m_submissionFence, + cSubmissionId = submissionId, + cSubmissionStatus = synchronizeSubmission ? &m_submitStatus : nullptr ] (DxvkContext* ctx) { - ctx->signal(cSignal, cValue); + ctx->signal(cSubmissionFence, cSubmissionId); + ctx->flushCommandList(cSubmissionStatus); }); + + FlushCsChunk(); + + // Notify flush tracker about the flush + m_flushSeqNum = m_csSeqNum; + m_flushTracker.notifyFlush(m_flushSeqNum, submissionId); + + // If necessary, block calling thread until the + // Vulkan queue submission is performed. + if (synchronizeSubmission) + m_device->waitForSubmission(&m_submitStatus); } } diff --git a/src/d3d11/d3d11_context_imm.h b/src/d3d11/d3d11_context_imm.h index 9a5ba21f..eb3ed88f 100644 --- a/src/d3d11/d3d11_context_imm.h +++ b/src/d3d11/d3d11_context_imm.h @@ -12,11 +12,12 @@ namespace dxvk { class D3D11Buffer; class D3D11CommonTexture; - - class D3D11ImmediateContext : public D3D11DeviceContext { + + class D3D11ImmediateContext : public D3D11CommonContext { + friend class D3D11CommonContext; friend class D3D11SwapChain; friend class D3D11VideoContext; - friend class D3D11DeviceContext; + friend class D3D11DXGIKeyedMutex; public: D3D11ImmediateContext( @@ -28,10 +29,6 @@ namespace dxvk { REFIID riid, void** ppvObject); - D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType(); - - UINT STDMETHODCALLTYPE GetContextFlags(); - HRESULT STDMETHODCALLTYPE GetData( ID3D11Asynchronous* pAsync, void* pData, @@ -77,61 +74,45 @@ 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); + void Acquire11on12Resource( + ID3D11Resource* pResource, + VkImageLayout SrcLayout); + + void Release11on12Resource( + ID3D11Resource* pResource, + VkImageLayout DstLayout); + void SynchronizeCsThread( uint64_t SequenceNumber); - + + D3D10DeviceLock LockContext() { + return m_multithread.AcquireLock(); + } + private: DxvkCsThread m_csThread; uint64_t m_csSeqNum = 0ull; - bool m_csIsBusy = false; - Rc m_eventSignal; - uint64_t m_eventCount = 0ull; uint32_t m_mappedImageCount = 0u; VkDeviceSize m_maxImplicitDiscardSize = 0ull; - dxvk::high_resolution_clock::time_point m_lastFlush - = dxvk::high_resolution_clock::now(); - - D3D11VideoContext m_videoContext; - Com m_stateObject; + Rc m_submissionFence; + uint64_t m_submissionId = 0ull; + DxvkSubmitStatus m_submitStatus; + + uint64_t m_flushSeqNum = 0ull; + GpuFlushTracker m_flushTracker; + + D3D10Multithread m_multithread; + D3D11VideoContext m_videoContext; + + Com m_stateObject; HRESULT MapBuffer( D3D11Buffer* pResource, @@ -150,20 +131,31 @@ 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); + D3D11Buffer* pDstBuffer, + UINT Offset, + UINT Length, + const void* pSrcData, + UINT CopyFlags); void SynchronizeDevice(); + + void EndFrame(); bool WaitForResource( - const Rc& Resource, - uint64_t SequenceNumber, - D3D11_MAP MapType, - UINT MapFlags); + const Rc& Resource, + uint64_t SequenceNumber, + D3D11_MAP MapType, + UINT MapFlags); void EmitCsChunk(DxvkCsChunkRef&& chunk); @@ -176,10 +168,16 @@ namespace dxvk { uint64_t GetCurrentSequenceNumber(); - void FlushImplicit(BOOL StrongHint); + uint64_t GetPendingCsChunks(); + + void ConsiderFlush( + GpuFlushType FlushType); + + void ExecuteFlush( + GpuFlushType FlushType, + HANDLE hEvent, + BOOL Synchronize); - void SignalEvent(HANDLE hEvent); - }; } diff --git a/src/d3d11/d3d11_context_state.h b/src/d3d11/d3d11_context_state.h index eca2a3c9..fd48d8ee 100644 --- a/src/d3d11/d3d11_context_state.h +++ b/src/d3d11/d3d11_context_state.h @@ -15,128 +15,237 @@ namespace dxvk { + /** + * \brief Per-stage state + * + * Stores an object of the given type for each shader stage. + * \tparam Object type + */ + template + 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 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 buffer = nullptr; + Com 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, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT> views = { }; - DxvkBindingSet hazardous = { }; - }; - - - using D3D11UnorderedAccessBindings = std::array< - Com, D3D11_1_UAV_SLOT_COUNT>; - - - struct D3D11ContextStateVS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - }; - - - struct D3D11ContextStateHS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - }; - - - struct D3D11ContextStateDS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - }; - - - struct D3D11ContextStateGS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - }; - - - struct D3D11ContextStatePS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - D3D11UnorderedAccessBindings unorderedAccessViews = { }; - }; - - - struct D3D11ContextStateCS { - Com shader = nullptr; - D3D11ConstantBufferBindings constantBuffers = { }; - D3D11SamplerBindings samplers = { }; - D3D11ShaderResourceBindings shaderResources = { }; - D3D11UnorderedAccessBindings unorderedAccessViews = { }; + struct D3D11ShaderStageCbvBinding { + std::array buffers = { }; - DxvkBindingSet uavMask = { }; + uint32_t maxCount = 0; + + void reset() { + for (uint32_t i = 0; i < maxCount; i++) + buffers[i] = D3D11ConstantBufferBinding(); + + maxCount = 0; + } }; + + using D3D11CbvBindings = D3D11ShaderStageState; + /** + * \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, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT> views = { }; + DxvkBindingSet 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; + + /** + * \brief Sampler bindings + * + * Stores bound samplers. + */ + struct D3D11ShaderStageSamplerBinding { + std::array samplers = { }; + + uint32_t maxCount = 0; + + void reset() { + for (uint32_t i = 0; i < maxCount; i++) + samplers[i] = nullptr; + + maxCount = 0; + } + }; + + using D3D11SamplerBindings = D3D11ShaderStageState; + + /** + * \brief UAV bindings + * + * Stores bound UAVs. For compute shader UAVs, + * we also store a bit mask of bound UAVs. + */ + using D3D11ShaderStageUavBinding = std::array, D3D11_1_UAV_SLOT_COUNT>; + struct D3D11UavBindings { + D3D11ShaderStageUavBinding views = { }; + DxvkBindingSet 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 buffer = nullptr; - UINT offset = 0; - UINT stride = 0; + Com buffer = nullptr; + UINT offset = 0; + UINT stride = 0; }; - struct D3D11IndexBufferBinding { - Com buffer = nullptr; - UINT offset = 0; - DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN; + Com buffer = nullptr; + UINT offset = 0; + DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN; }; - - struct D3D11ContextStateID { - Com argBuffer = nullptr; - Com cntBuffer = nullptr; - }; - - struct D3D11ContextStateIA { - Com inputLayout = nullptr; - D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; + Com inputLayout = nullptr; + D3D11_PRIMITIVE_TOPOLOGY primitiveTopology = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; std::array 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, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT>; struct D3D11ContextStateOM { - std::array, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT> renderTargetViews = { }; - Com depthStencilView = { }; + D3D11ShaderStageUavBinding uavs = { }; + D3D11RenderTargetViewBinding rtvs = { }; + Com 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 maxUav = 0u; + + void reset() { + for (uint32_t i = 0; 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 = 0; + maxUav = 0; + } }; - + /** + * \brief Indirect draw state + * + * Stores the current indirct draw + * argument and draw count buffer. + */ + struct D3D11ContextStateID { + Com argBuffer = nullptr; + Com cntBuffer = nullptr; + + void reset() { + argBuffer = nullptr; + cntBuffer = nullptr; + } + }; + + /** + * \brief Rasterizer state + * + * Stores viewport info and the rasterizer state object. + */ struct D3D11ContextStateRS { uint32_t numViewports = 0; uint32_t numScissors = 0; @@ -145,43 +254,97 @@ namespace dxvk { std::array 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 buffer = nullptr; - UINT offset = 0; + Com buffer = nullptr; + UINT offset = 0; }; - struct D3D11ContextStateSO { std::array targets = { }; + + void reset() { + for (uint32_t i = 0; i < targets.size(); i++) + targets[i] = D3D11ContextSoTarget(); + } }; - + /** + * \brief Predication state + * + * Stores predication info. + */ struct D3D11ContextStatePR { - Com predicateObject = nullptr; - BOOL predicateValue = FALSE; + Com predicateObject = nullptr; + BOOL predicateValue = false; + + void reset() { + predicateObject = nullptr; + predicateValue = false; + } }; - /** * \brief Context state */ struct D3D11ContextState { - D3D11ContextStateCS cs; - D3D11ContextStateDS ds; - D3D11ContextStateGS gs; - D3D11ContextStateHS hs; - D3D11ContextStatePS ps; - D3D11ContextStateVS vs; - + Com vs; + Com hs; + Com ds; + Com gs; + Com ps; + Com cs; + D3D11ContextStateID id; D3D11ContextStateIA ia; D3D11ContextStateOM om; D3D11ContextStateRS rs; D3D11ContextStateSO so; D3D11ContextStatePR pr; + + D3D11CbvBindings cbv; + D3D11SrvBindings srv; + D3D11UavBindings uav; + D3D11SamplerBindings samplers; }; - + + /** + * \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 stages; + uint32_t vbCount; + uint32_t soCount; + }; + } \ No newline at end of file diff --git a/src/d3d11/d3d11_depth_stencil.cpp b/src/d3d11/d3d11_depth_stencil.cpp index b095e5ea..69efe593 100644 --- a/src/d3d11/d3d11_depth_stencil.cpp +++ b/src/d3d11/d3d11_depth_stencil.cpp @@ -37,12 +37,15 @@ namespace dxvk { if (riid == __uuidof(ID3D10DeviceChild) || riid == __uuidof(ID3D10DepthStencilState)) { - *ppvObject = ref(this); + *ppvObject = ref(&m_d3d10); return S_OK; } - Logger::warn("D3D11DepthStencilState::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11DepthStencilState), riid)) { + Logger::warn("D3D11DepthStencilState::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -52,7 +55,7 @@ namespace dxvk { } - void D3D11DepthStencilState::BindToContext(const Rc& ctx) { + void D3D11DepthStencilState::BindToContext(DxvkContext* ctx) { ctx->setDepthStencilState(m_state); } diff --git a/src/d3d11/d3d11_depth_stencil.h b/src/d3d11/d3d11_depth_stencil.h index 6311259f..5cc1dba8 100644 --- a/src/d3d11/d3d11_depth_stencil.h +++ b/src/d3d11/d3d11_depth_stencil.h @@ -29,8 +29,7 @@ namespace dxvk { void STDMETHODCALLTYPE GetDesc( D3D11_DEPTH_STENCIL_DESC* pDesc) final; - void BindToContext( - const Rc& ctx); + void BindToContext(DxvkContext* ctx); D3D10DepthStencilState* GetD3D10Iface() { return &m_d3d10; diff --git a/src/d3d11/d3d11_device.cpp b/src/d3d11/d3d11_device.cpp index 09f3559a..9398e484 100644 --- a/src/d3d11/d3d11_device.cpp +++ b/src/d3d11/d3d11_device.cpp @@ -2,6 +2,7 @@ #include #include "../dxgi/dxgi_monitor.h" +#include "../dxgi/dxgi_surface.h" #include "../dxgi/dxgi_swapchain.h" #include "../dxvk/dxvk_adapter.h" @@ -12,6 +13,7 @@ #include "d3d11_context_def.h" #include "d3d11_context_imm.h" #include "d3d11_device.h" +#include "d3d11_fence.h" #include "d3d11_input_layout.h" #include "d3d11_interop.h" #include "d3d11_query.h" @@ -23,6 +25,8 @@ #include "d3d11_texture.h" #include "d3d11_video.h" +#include "../wsi/wsi_window.h" + #include "../util/util_shared_res.h" namespace dxvk { @@ -35,14 +39,16 @@ namespace dxvk { D3D11DXGIDevice* pContainer, D3D_FEATURE_LEVEL FeatureLevel, UINT FeatureFlags) - : m_container (pContainer), - m_featureLevel (FeatureLevel), - m_featureFlags (FeatureFlags), - m_dxvkDevice (pContainer->GetDXVKDevice()), - m_dxvkAdapter (m_dxvkDevice->adapter()), - m_d3d11Formats (m_dxvkAdapter), - m_d3d11Options (m_dxvkDevice->instance()->config(), m_dxvkDevice), - m_dxbcOptions (m_dxvkDevice, m_d3d11Options) { + : m_container (pContainer), + m_featureLevel (FeatureLevel), + m_featureFlags (FeatureFlags), + m_dxvkDevice (pContainer->GetDXVKDevice()), + m_dxvkAdapter (m_dxvkDevice->adapter()), + m_d3d11Formats (m_dxvkDevice), + m_d3d11Options (m_dxvkDevice->instance()->config(), m_dxvkDevice), + m_dxbcOptions (m_dxvkDevice, m_d3d11Options), + m_maxFeatureLevel (GetMaxFeatureLevel(m_dxvkDevice->instance(), m_dxvkDevice->adapter())), + m_deviceFeatures (m_dxvkDevice->instance(), m_dxvkDevice->adapter(), m_featureLevel) { m_initializer = new D3D11Initializer(this); m_context = new D3D11ImmediateContext(this, m_dxvkDevice); m_d3d10Device = new D3D10Device(this, m_context.ptr()); @@ -86,12 +92,19 @@ namespace dxvk { if (FAILED(hr)) return hr; + if ((desc.MiscFlags & (D3D11_RESOURCE_MISC_TILED | D3D11_RESOURCE_MISC_TILE_POOL)) + && !m_deviceFeatures.GetTiledResourcesTier()) + return E_INVALIDARG; + if (!ppBuffer) return S_FALSE; try { - const Com buffer = new D3D11Buffer(this, &desc); - m_initializer->InitBuffer(buffer.ptr(), pInitialData); + const Com buffer = new D3D11Buffer(this, &desc, nullptr); + + if (!(desc.MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL)) + m_initializer->InitBuffer(buffer.ptr(), pInitialData); + *ppBuffer = buffer.ref(); return S_OK; } catch (const DxvkError& e) { @@ -128,12 +141,15 @@ namespace dxvk { if (FAILED(hr)) return hr; - + + if (desc.MiscFlags & D3D11_RESOURCE_MISC_TILED) + return E_INVALIDARG; + if (!ppTexture1D) return S_FALSE; try { - const Com texture = new D3D11Texture1D(this, &desc); + const Com texture = new D3D11Texture1D(this, &desc, nullptr); m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData); *ppTexture1D = texture.ref(); return S_OK; @@ -202,6 +218,10 @@ namespace dxvk { HRESULT hr = D3D11CommonTexture::NormalizeTextureProperties(&desc); + if ((desc.MiscFlags & D3D11_RESOURCE_MISC_TILED) + && !m_deviceFeatures.GetTiledResourcesTier()) + return E_INVALIDARG; + if (FAILED(hr)) return hr; @@ -209,7 +229,7 @@ namespace dxvk { return S_FALSE; try { - Com texture = new D3D11Texture2D(this, &desc, nullptr); + Com texture = new D3D11Texture2D(this, &desc, nullptr, nullptr); m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData); *ppTexture2D = texture.ref(); return S_OK; @@ -279,12 +299,16 @@ namespace dxvk { if (FAILED(hr)) return hr; - + + if ((desc.MiscFlags & D3D11_RESOURCE_MISC_TILED) + && (m_deviceFeatures.GetTiledResourcesTier() < D3D11_TILED_RESOURCES_TIER_3)) + return E_INVALIDARG; + if (!ppTexture3D) return S_FALSE; try { - Com texture = new D3D11Texture3D(this, &desc); + Com texture = new D3D11Texture3D(this, &desc, nullptr); m_initializer->InitTexture(texture->GetCommonTexture(), pInitialData); *ppTexture3D = texture.ref(); return S_OK; @@ -590,7 +614,10 @@ namespace dxvk { ID3D11InputLayout** ppInputLayout) { InitReturnPtr(ppInputLayout); - if (pInputElementDescs == nullptr) + // This check is somehow even correct, passing null with zero + // size will always fail but passing non-null with zero size + // works, provided the shader does not have any actual inputs + if (!pInputElementDescs) return E_INVALIDARG; try { @@ -602,44 +629,39 @@ namespace dxvk { uint32_t attrMask = 0; uint32_t bindMask = 0; + uint32_t locationMask = 0; + uint32_t bindingsDefined = 0; - std::array attrList; - std::array bindList; + std::array attrList = { }; + std::array bindList = { }; for (uint32_t i = 0; i < NumElements; i++) { const DxbcSgnEntry* entry = inputSignature->find( pInputElementDescs[i].SemanticName, pInputElementDescs[i].SemanticIndex, 0); - - if (entry == nullptr) { - Logger::debug(str::format( - "D3D11Device: No such vertex shader semantic: ", - pInputElementDescs[i].SemanticName, - pInputElementDescs[i].SemanticIndex)); - } - + // Create vertex input attribute description DxvkVertexAttribute attrib; attrib.location = entry != nullptr ? entry->registerId : 0; attrib.binding = pInputElementDescs[i].InputSlot; attrib.format = LookupFormat(pInputElementDescs[i].Format, DXGI_VK_FORMAT_MODE_COLOR).Format; attrib.offset = pInputElementDescs[i].AlignedByteOffset; - + // The application may choose to let the implementation // generate the exact vertex layout. In that case we'll // pack attributes on the same binding in the order they // are declared, aligning each attribute to four bytes. - const DxvkFormatInfo* formatInfo = imageFormatInfo(attrib.format); + const DxvkFormatInfo* formatInfo = lookupFormatInfo(attrib.format); VkDeviceSize alignment = std::min(formatInfo->elementSize, 4); if (attrib.offset == D3D11_APPEND_ALIGNED_ELEMENT) { attrib.offset = 0; - + for (uint32_t j = 1; j <= i; j++) { const DxvkVertexAttribute& prev = attrList.at(i - j); - + if (prev.binding == attrib.binding) { - attrib.offset = align(prev.offset + imageFormatInfo(prev.format)->elementSize, alignment); + attrib.offset = align(prev.offset + lookupFormatInfo(prev.format)->elementSize, alignment); break; } } @@ -647,7 +669,7 @@ namespace dxvk { return E_INVALIDARG; attrList.at(i) = attrib; - + // Create vertex input binding description. The // stride is dynamic state in D3D11 and will be // set by D3D11DeviceContext::IASetVertexBuffers. @@ -656,66 +678,49 @@ namespace dxvk { binding.fetchRate = pInputElementDescs[i].InstanceDataStepRate; binding.inputRate = pInputElementDescs[i].InputSlotClass == D3D11_INPUT_PER_INSTANCE_DATA ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX; - + binding.extent = entry ? uint32_t(attrib.offset + formatInfo->elementSize) : 0u; + // Check if the binding was already defined. If so, the // parameters must be identical (namely, the input rate). - bool bindingDefined = false; - - for (uint32_t j = 0; j < i; j++) { - uint32_t bindingId = attrList.at(j).binding; + if (bindingsDefined & (1u << binding.binding)) { + if (bindList.at(binding.binding).inputRate != binding.inputRate) + return E_INVALIDARG; - if (binding.binding == bindingId) { - bindingDefined = true; - - if (binding.inputRate != bindList.at(bindingId).inputRate) { - Logger::err(str::format( - "D3D11Device: Conflicting input rate for binding ", - binding.binding)); - return E_INVALIDARG; - } - } + bindList.at(binding.binding).extent = std::max( + bindList.at(binding.binding).extent, binding.extent); + } else { + bindList.at(binding.binding) = binding; + bindingsDefined |= 1u << binding.binding; } - if (!bindingDefined) - bindList.at(binding.binding) = binding; - - if (entry != nullptr) { + if (entry) { attrMask |= 1u << i; bindMask |= 1u << binding.binding; + locationMask |= 1u << attrib.location; } } + // Ensure that all inputs used by the shader are defined + for (auto i = inputSignature->begin(); i != inputSignature->end(); i++) { + bool isBuiltIn = DxbcIsgn::compareSemanticNames(i->semanticName, "sv_instanceid") + || DxbcIsgn::compareSemanticNames(i->semanticName, "sv_vertexid"); + + if (!isBuiltIn && !(locationMask & (1u << i->registerId))) + return E_INVALIDARG; + } + // Compact the attribute and binding lists to filter // out attributes and bindings not used by the shader uint32_t attrCount = CompactSparseList(attrList.data(), attrMask); uint32_t bindCount = CompactSparseList(bindList.data(), bindMask); - // Check if there are any semantics defined in the - // shader that are not included in the current input - // layout. - for (auto i = inputSignature->begin(); i != inputSignature->end(); i++) { - bool found = i->systemValue != DxbcSystemValue::None; - - for (uint32_t j = 0; j < attrCount && !found; j++) - found = attrList.at(j).location == i->registerId; - - if (!found) { - Logger::warn(str::format( - "D3D11Device: Vertex input '", - i->semanticName, i->semanticIndex, - "' not defined by input layout")); - } - } - - // Create the actual input layout object - // if the application requests it. - if (ppInputLayout != nullptr) { - *ppInputLayout = ref( - new D3D11InputLayout(this, - attrCount, attrList.data(), - bindCount, bindList.data())); - } - + if (!ppInputLayout) + return S_FALSE; + + *ppInputLayout = ref( + new D3D11InputLayout(this, + attrCount, attrList.data(), + bindCount, bindList.data())); return S_OK; } catch (const DxvkError& e) { Logger::err(e.message()); @@ -1141,7 +1146,7 @@ namespace dxvk { return E_INVALIDARG; if (desc.ConservativeRaster != D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF - && !m_dxvkDevice->extensions().extConservativeRasterization) + && !m_deviceFeatures.GetConservativeRasterizationTier()) return E_INVALIDARG; if (!ppRasterizerState) @@ -1164,8 +1169,13 @@ namespace dxvk { if (FAILED(D3D11SamplerState::NormalizeDesc(&desc))) return E_INVALIDARG; - - if (ppSamplerState == nullptr) + + D3D11_TILED_RESOURCES_TIER tiledResourcesTier = m_deviceFeatures.GetTiledResourcesTier(); + + if (IsMinMaxFilter(desc.Filter) && tiledResourcesTier < D3D11_TILED_RESOURCES_TIER_2) + return E_INVALIDARG; + + if (!ppSamplerState) return S_FALSE; try { @@ -1312,33 +1322,41 @@ namespace dxvk { ID3DDeviceContextState** ppContextState) { InitReturnPtr(ppContextState); - if (!pFeatureLevels || FeatureLevels == 0) + if (!pFeatureLevels || !FeatureLevels) return E_INVALIDARG; - + if (EmulatedInterface != __uuidof(ID3D10Device) && EmulatedInterface != __uuidof(ID3D10Device1) && EmulatedInterface != __uuidof(ID3D11Device) && EmulatedInterface != __uuidof(ID3D11Device1)) return E_INVALIDARG; - - UINT flId; - for (flId = 0; flId < FeatureLevels; flId++) { - if (CheckFeatureLevelSupport(m_dxvkDevice->instance(), m_dxvkAdapter, pFeatureLevels[flId])) + + D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL(); + + for (uint32_t flId = 0; flId < FeatureLevels; flId++) { + if (pFeatureLevels[flId] <= m_maxFeatureLevel) { + featureLevel = pFeatureLevels[flId]; break; + } } - if (flId == FeatureLevels) + if (!featureLevel) return E_INVALIDARG; - if (pFeatureLevels[flId] > m_featureLevel) - m_featureLevel = pFeatureLevels[flId]; - + if (m_featureLevel < featureLevel) { + m_featureLevel = featureLevel; + m_deviceFeatures = D3D11DeviceFeatures( + m_dxvkDevice->instance(), + m_dxvkDevice->adapter(), + m_featureLevel); + } + if (pChosenFeatureLevel) - *pChosenFeatureLevel = pFeatureLevels[flId]; - + *pChosenFeatureLevel = featureLevel; + if (!ppContextState) return S_FALSE; - + *ppContextState = ref(new D3D11DeviceContextState(this)); return S_OK; } @@ -1347,16 +1365,17 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D11Device::CreateFence( UINT64 InitialValue, D3D11_FENCE_FLAG Flags, - REFIID ReturnedInterface, + REFIID riid, void** ppFence) { InitReturnPtr(ppFence); - static bool s_errorShown = false; - - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11Device::CreateFence: Not implemented"); - - return E_NOTIMPL; + try { + Com fence = new D3D11Fence(this, InitialValue, Flags, INVALID_HANDLE_VALUE); + return fence->QueryInterface(riid, ppFence); + } catch (const DxvkError& e) { + Logger::err(e.message()); + return E_FAIL; + } } @@ -1367,9 +1386,25 @@ namespace dxvk { ID3D11Resource* pSrcResource, UINT SrcSubresource, const D3D11_BOX* pSrcBox) { + auto texture = GetCommonTexture(pSrcResource); + + if (!texture) + return; + + if (texture->Desc()->Usage != D3D11_USAGE_DEFAULT + || texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE + || texture->CountSubresources() <= SrcSubresource) + return; + + D3D11_MAP map = texture->GetMapType(SrcSubresource); + + if (map != D3D11_MAP_READ + && map != D3D11_MAP_READ_WRITE) + return; + CopySubresourceData( pDstData, DstRowPitch, DstDepthPitch, - pSrcResource, SrcSubresource, pSrcBox); + texture, SrcSubresource, pSrcBox); } @@ -1380,9 +1415,26 @@ namespace dxvk { const void* pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch) { + auto texture = GetCommonTexture(pDstResource); + + if (!texture) + return; + + if (texture->Desc()->Usage != D3D11_USAGE_DEFAULT + || texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE + || texture->CountSubresources() <= DstSubresource) + return; + + D3D11_MAP map = texture->GetMapType(DstSubresource); + + if (map != D3D11_MAP_WRITE + && map != D3D11_MAP_WRITE_NO_OVERWRITE + && map != D3D11_MAP_READ_WRITE) + return; + CopySubresourceData( pSrcData, SrcRowPitch, SrcRowPitch, - pDstResource, DstSubresource, pDstBox); + texture, DstSubresource, pDstBox); } @@ -1422,8 +1474,16 @@ namespace dxvk { void** ppFence) { InitReturnPtr(ppFence); - Logger::err("D3D11Device::OpenSharedFence: Not implemented"); - return E_NOTIMPL; + if (ppFence == nullptr) + return S_FALSE; + + try { + Com fence = new D3D11Fence(this, 0, D3D11_FENCE_FLAG_SHARED, hFence); + return fence->QueryInterface(ReturnedInterface, ppFence); + } catch (const DxvkError& e) { + Logger::err(e.message()); + return E_FAIL; + } } @@ -1482,17 +1542,29 @@ namespace dxvk { if (FAILED(DecodeSampleCount(SampleCount, &sampleCountFlag))) return SampleCount && SampleCount <= 32 ? S_OK : E_FAIL; - + + // Get image create flags depending on function arguments + VkImageCreateFlags flags = 0; + + if (Flags & D3D11_CHECK_MULTISAMPLE_QUALITY_LEVELS_TILED_RESOURCE) { + flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT + | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; + } + // Check if the device supports the given combination of format // and sample count. D3D exposes the opaque concept of quality // levels to the application, we'll just define one such level. - VkImageFormatProperties formatProps; - - VkResult status = m_dxvkAdapter->imageFormatProperties( - format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_SAMPLED_BIT, 0, formatProps); - - if ((status == VK_SUCCESS) && (formatProps.sampleCounts & sampleCountFlag)) + DxvkFormatQuery formatQuery = { }; + formatQuery.format = format; + formatQuery.type = VK_IMAGE_TYPE_2D; + formatQuery.tiling = VK_IMAGE_TILING_OPTIMAL; + formatQuery.usage = VK_IMAGE_USAGE_SAMPLED_BIT; + formatQuery.flags = flags; + + auto properties = m_dxvkDevice->getFormatLimits(formatQuery); + + if (properties && (properties->sampleCounts & sampleCountFlag)) *pNumQualityLevels = 1; return S_OK; } @@ -1526,29 +1598,8 @@ namespace dxvk { void* pFeatureSupportData, UINT FeatureSupportDataSize) { switch (Feature) { - case D3D11_FEATURE_THREADING: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - // We report native support for command lists here so that we do not actually - // have to re-implement the UpdateSubresource bug from the D3D11 runtime, see - // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476486(v=vs.85).aspx) - info->DriverConcurrentCreates = TRUE; - info->DriverCommandLists = TRUE; - } return S_OK; - - case D3D11_FEATURE_DOUBLES: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->DoublePrecisionFloatShaderOps = m_dxvkDevice->features().core.features.shaderFloat64 - && m_dxvkDevice->features().core.features.shaderInt64; - } return S_OK; - + // Format support queries are special in that they use in-out + // structs, and we need the Vulkan device to query them at all case D3D11_FEATURE_FORMAT_SUPPORT: { auto info = static_cast(pFeatureSupportData); @@ -1557,7 +1608,7 @@ namespace dxvk { return GetFormatSupportFlags(info->InFormat, &info->OutFormatSupport, nullptr); } return S_OK; - + case D3D11_FEATURE_FORMAT_SUPPORT2: { auto info = static_cast(pFeatureSupportData); @@ -1566,181 +1617,11 @@ namespace dxvk { return GetFormatSupportFlags(info->InFormat, nullptr, &info->OutFormatSupport2); } return S_OK; - - case D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x = TRUE; - } return S_OK; - - case D3D11_FEATURE_D3D11_OPTIONS: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - // https://msdn.microsoft.com/en-us/library/windows/desktop/hh404457(v=vs.85).aspx - const auto& features = m_dxvkDevice->features(); - - info->OutputMergerLogicOp = features.core.features.logicOp; - info->UAVOnlyRenderingForcedSampleCount = features.core.features.variableMultisampleRate; - info->DiscardAPIsSeenByDriver = TRUE; - info->FlagsForUpdateAndCopySeenByDriver = TRUE; - info->ClearView = TRUE; - info->CopyWithOverlap = TRUE; - info->ConstantBufferPartialUpdate = TRUE; - info->ConstantBufferOffsetting = TRUE; - info->MapNoOverwriteOnDynamicConstantBuffer = TRUE; - info->MapNoOverwriteOnDynamicBufferSRV = TRUE; - info->MultisampleRTVWithForcedSampleCountOne = TRUE; /* not really */ - info->SAD4ShaderInstructions = TRUE; - info->ExtendedDoublesShaderInstructions = TRUE; - info->ExtendedResourceSharing = TRUE; /* not really */ - } return S_OK; - - case D3D11_FEATURE_ARCHITECTURE_INFO: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->TileBasedDeferredRenderer = FALSE; - } return S_OK; - - case D3D11_FEATURE_D3D9_OPTIONS: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->FullNonPow2TextureSupport = TRUE; - } return S_OK; - - case D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - // Report that we only support full 32-bit operations - info->PixelShaderMinPrecision = 0; - info->AllOtherShaderStagesMinPrecision = 0; - } return S_OK; - - case D3D11_FEATURE_D3D9_SHADOW_SUPPORT: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->SupportsDepthAsTextureWithLessEqualComparisonFilter = TRUE; - } return S_OK; - - case D3D11_FEATURE_D3D11_OPTIONS1: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - // Min/Max filtering requires Tiled Resources Tier 2 for some reason, - // so we cannot support it even though Vulkan exposes this feature - info->TiledResourcesTier = D3D11_TILED_RESOURCES_NOT_SUPPORTED; - info->MinMaxFiltering = FALSE; - info->ClearViewAlsoSupportsDepthOnlyFormats = TRUE; - info->MapOnDefaultBuffers = TRUE; - } return S_OK; - - case D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->SimpleInstancingSupported = TRUE; - } return S_OK; - - case D3D11_FEATURE_MARKER_SUPPORT: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->Profile = FALSE; - } return S_OK; - - case D3D11_FEATURE_D3D9_OPTIONS1: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->FullNonPow2TextureSupported = TRUE; - info->DepthAsTextureWithLessEqualComparisonFilterSupported = TRUE; - info->SimpleInstancingSupported = TRUE; - info->TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported = TRUE; - } return S_OK; - - case D3D11_FEATURE_D3D11_OPTIONS2: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - const auto& extensions = m_dxvkDevice->extensions(); - const auto& features = m_dxvkDevice->features(); - - info->PSSpecifiedStencilRefSupported = extensions.extShaderStencilExport; - info->TypedUAVLoadAdditionalFormats = features.core.features.shaderStorageImageReadWithoutFormat; - info->ROVsSupported = FALSE; - info->ConservativeRasterizationTier = D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED; - info->MapOnDefaultTextures = TRUE; - info->TiledResourcesTier = D3D11_TILED_RESOURCES_NOT_SUPPORTED; - info->StandardSwizzle = FALSE; - info->UnifiedMemoryArchitecture = m_dxvkDevice->isUnifiedMemoryArchitecture(); - - if (m_dxvkDevice->extensions().extConservativeRasterization) { - // We don't have a way to query uncertainty regions, so just check degenerate triangle behaviour - info->ConservativeRasterizationTier = m_dxvkDevice->properties().extConservativeRasterization.degenerateTrianglesRasterized - ? D3D11_CONSERVATIVE_RASTERIZATION_TIER_2 : D3D11_CONSERVATIVE_RASTERIZATION_TIER_1; - } - } return S_OK; - - case D3D11_FEATURE_D3D11_OPTIONS3: { - if (FeatureSupportDataSize != sizeof(D3D11_FEATURE_DATA_D3D11_OPTIONS3)) - return E_INVALIDARG; - - const auto& extensions = m_dxvkDevice->extensions(); - - auto info = static_cast(pFeatureSupportData); - info->VPAndRTArrayIndexFromAnyShaderFeedingRasterizer = extensions.extShaderViewportIndexLayer; - } return S_OK; - - case D3D11_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - // These numbers are not accurate, but it should not have any effect on D3D11 apps - info->MaxGPUVirtualAddressBitsPerResource = 32; - info->MaxGPUVirtualAddressBitsPerProcess = 40; - } return S_OK; - - case D3D11_FEATURE_D3D11_OPTIONS4: { - auto info = static_cast(pFeatureSupportData); - - if (FeatureSupportDataSize != sizeof(*info)) - return E_INVALIDARG; - - info->ExtendedNV12SharedTextureSupported = FALSE; - } return S_OK; default: - Logger::err(str::format("D3D11Device: CheckFeatureSupport: Unknown feature: ", Feature)); - return E_INVALIDARG; + // For everything else, we can use the device feature struct + // that we already initialized during device creation. + return m_deviceFeatures.GetFeatureData(Feature, FeatureSupportDataSize, pFeatureSupportData); } } @@ -1823,27 +1704,90 @@ namespace dxvk { UINT* pNumSubresourceTilings, UINT FirstSubresourceTilingToGet, D3D11_SUBRESOURCE_TILING* pSubresourceTilingsForNonPackedMips) { - static bool s_errorShown = false; + D3D11_COMMON_RESOURCE_DESC desc = { }; + GetCommonResourceDesc(pTiledResource, &desc); - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11Device::GetResourceTiling: Tiled resources not supported"); + if (!(desc.MiscFlags & D3D11_RESOURCE_MISC_TILED)) { + if (pNumTilesForEntireResource) + *pNumTilesForEntireResource = 0; - if (pNumTilesForEntireResource) - *pNumTilesForEntireResource = 0; + if (pPackedMipDesc) + *pPackedMipDesc = D3D11_PACKED_MIP_DESC(); - if (pPackedMipDesc) - *pPackedMipDesc = D3D11_PACKED_MIP_DESC(); + if (pStandardTileShapeForNonPackedMips) + *pStandardTileShapeForNonPackedMips = D3D11_TILE_SHAPE(); - if (pStandardTileShapeForNonPackedMips) - *pStandardTileShapeForNonPackedMips = D3D11_TILE_SHAPE(); + if (pNumSubresourceTilings) { + if (pSubresourceTilingsForNonPackedMips) { + for (uint32_t i = 0; i < *pNumSubresourceTilings; i++) + pSubresourceTilingsForNonPackedMips[i] = D3D11_SUBRESOURCE_TILING(); + } - if (pNumSubresourceTilings) { - if (pSubresourceTilingsForNonPackedMips) { - for (uint32_t i = 0; i < *pNumSubresourceTilings; i++) - pSubresourceTilingsForNonPackedMips[i] = D3D11_SUBRESOURCE_TILING(); + *pNumSubresourceTilings = 0; + } + } else { + DxvkSparsePageTable* sparseInfo = nullptr; + uint32_t mipCount = 0; + + if (desc.Dim == D3D11_RESOURCE_DIMENSION_BUFFER) { + Rc buffer = static_cast(pTiledResource)->GetBuffer(); + sparseInfo = buffer->getSparsePageTable(); + } else { + Rc image = GetCommonTexture(pTiledResource)->GetImage(); + sparseInfo = image->getSparsePageTable(); + mipCount = image->info().mipLevels; } - *pNumSubresourceTilings = 0; + if (pNumTilesForEntireResource) + *pNumTilesForEntireResource = sparseInfo->getPageCount(); + + if (pPackedMipDesc) { + auto properties = sparseInfo->getProperties(); + + if (properties.mipTailSize) { + pPackedMipDesc->NumStandardMips = properties.pagedMipCount; + pPackedMipDesc->NumPackedMips = mipCount - properties.pagedMipCount; + pPackedMipDesc->NumTilesForPackedMips = sparseInfo->getPageCount() - properties.mipTailPageIndex; + pPackedMipDesc->StartTileIndexInOverallResource = properties.mipTailPageIndex; + } else { + pPackedMipDesc->NumStandardMips = mipCount; + pPackedMipDesc->NumPackedMips = 0; + pPackedMipDesc->NumTilesForPackedMips = 0; + pPackedMipDesc->StartTileIndexInOverallResource = 0; + } + } + + if (pStandardTileShapeForNonPackedMips) { + auto properties = sparseInfo->getProperties(); + pStandardTileShapeForNonPackedMips->WidthInTexels = properties.pageRegionExtent.width; + pStandardTileShapeForNonPackedMips->HeightInTexels = properties.pageRegionExtent.height; + pStandardTileShapeForNonPackedMips->DepthInTexels = properties.pageRegionExtent.depth; + } + + if (pNumSubresourceTilings) { + uint32_t subresourceCount = sparseInfo->getSubresourceCount(); + uint32_t tilingCount = subresourceCount - std::min(FirstSubresourceTilingToGet, subresourceCount); + tilingCount = std::min(tilingCount, *pNumSubresourceTilings); + + for (uint32_t i = 0; i < tilingCount; i++) { + auto subresourceInfo = sparseInfo->getSubresourceProperties(FirstSubresourceTilingToGet + i); + auto dstInfo = &pSubresourceTilingsForNonPackedMips[i]; + + if (subresourceInfo.isMipTail) { + dstInfo->WidthInTiles = 0u; + dstInfo->HeightInTiles = 0u; + dstInfo->DepthInTiles = 0u; + dstInfo->StartTileIndexInOverallResource = D3D11_PACKED_TILE; + } else { + dstInfo->WidthInTiles = subresourceInfo.pageCount.width; + dstInfo->HeightInTiles = subresourceInfo.pageCount.height; + dstInfo->DepthInTiles = subresourceInfo.pageCount.depth; + dstInfo->StartTileIndexInOverallResource = subresourceInfo.pageIndex; + } + } + + *pNumSubresourceTilings = tilingCount; + } } } @@ -1888,6 +1832,11 @@ namespace dxvk { DXGI_VK_FORMAT_MODE Mode) const { return m_d3d11Formats.GetFormatFamily(Format, Mode); } + + + bool D3D11Device::Is11on12Device() const { + return m_container->Is11on12Device(); + } void D3D11Device::FlushInitContext() { @@ -1895,107 +1844,120 @@ namespace dxvk { } - bool D3D11Device::CheckFeatureLevelSupport( - const Rc& instance, - const Rc& adapter, - D3D_FEATURE_LEVEL featureLevel) { - if (featureLevel > GetMaxFeatureLevel(instance)) - return false; + D3D_FEATURE_LEVEL D3D11Device::GetMaxFeatureLevel( + const Rc& Instance, + const Rc& Adapter) { + // Check whether baseline features are supported by the device + DxvkDeviceFeatures features = GetDeviceFeatures(Adapter); - // Check whether all features are supported - const DxvkDeviceFeatures features - = GetDeviceFeatures(adapter, featureLevel); + if (!Adapter->checkFeatureSupport(features)) + return D3D_FEATURE_LEVEL(); + + // The feature level override always takes precedence + static const std::array, 9> s_featureLevels = {{ + { "12_1", D3D_FEATURE_LEVEL_12_1 }, + { "12_0", D3D_FEATURE_LEVEL_12_0 }, + { "11_1", D3D_FEATURE_LEVEL_11_1 }, + { "11_0", D3D_FEATURE_LEVEL_11_0 }, + { "10_1", D3D_FEATURE_LEVEL_10_1 }, + { "10_0", D3D_FEATURE_LEVEL_10_0 }, + { "9_3", D3D_FEATURE_LEVEL_9_3 }, + { "9_2", D3D_FEATURE_LEVEL_9_2 }, + { "9_1", D3D_FEATURE_LEVEL_9_1 }, + }}; - if (!adapter->checkFeatureSupport(features)) - return false; - - // TODO also check for required limits - return true; + std::string maxLevel = Instance->config().getOption("d3d11.maxFeatureLevel"); + + auto entry = std::find_if(s_featureLevels.begin(), s_featureLevels.end(), + [&] (const std::pair& pair) { + return pair.first == maxLevel; + }); + + if (entry != s_featureLevels.end()) + return entry->second; + + // Otherwise, check the actually available device features + return D3D11DeviceFeatures::GetMaxFeatureLevel(Instance, Adapter); } DxvkDeviceFeatures D3D11Device::GetDeviceFeatures( - const Rc& adapter, - D3D_FEATURE_LEVEL featureLevel) { - DxvkDeviceFeatures supported = adapter->features(); + const Rc& Adapter) { + DxvkDeviceFeatures supported = Adapter->features(); DxvkDeviceFeatures enabled = {}; + // Required for feature level 10_1 + enabled.core.features.depthBiasClamp = VK_TRUE; + enabled.core.features.depthClamp = VK_TRUE; + enabled.core.features.dualSrcBlend = VK_TRUE; + enabled.core.features.fillModeNonSolid = VK_TRUE; + enabled.core.features.fullDrawIndexUint32 = VK_TRUE; enabled.core.features.geometryShader = VK_TRUE; - enabled.core.features.robustBufferAccess = VK_TRUE; - enabled.core.features.shaderStorageImageWriteWithoutFormat = VK_TRUE; - enabled.core.features.depthBounds = supported.core.features.depthBounds; + enabled.core.features.imageCubeArray = VK_TRUE; + enabled.core.features.independentBlend = VK_TRUE; + enabled.core.features.multiViewport = VK_TRUE; + enabled.core.features.occlusionQueryPrecise = VK_TRUE; + enabled.core.features.pipelineStatisticsQuery = supported.core.features.pipelineStatisticsQuery; + enabled.core.features.sampleRateShading = VK_TRUE; + enabled.core.features.samplerAnisotropy = supported.core.features.samplerAnisotropy; + enabled.core.features.shaderClipDistance = VK_TRUE; + enabled.core.features.shaderCullDistance = VK_TRUE; + enabled.core.features.shaderImageGatherExtended = VK_TRUE; + enabled.core.features.textureCompressionBC = VK_TRUE; - enabled.shaderDrawParameters.shaderDrawParameters = VK_TRUE; + enabled.vk11.shaderDrawParameters = VK_TRUE; - enabled.extMemoryPriority.memoryPriority = supported.extMemoryPriority.memoryPriority; + enabled.vk12.samplerMirrorClampToEdge = VK_TRUE; - enabled.extRobustness2.robustBufferAccess2 = supported.extRobustness2.robustBufferAccess2; - enabled.extRobustness2.robustImageAccess2 = supported.extRobustness2.robustImageAccess2; - enabled.extRobustness2.nullDescriptor = supported.extRobustness2.nullDescriptor; + enabled.vk13.shaderDemoteToHelperInvocation = VK_TRUE; - enabled.extShaderDemoteToHelperInvocation.shaderDemoteToHelperInvocation = supported.extShaderDemoteToHelperInvocation.shaderDemoteToHelperInvocation; + enabled.extCustomBorderColor.customBorderColors = supported.extCustomBorderColor.customBorderColorWithoutFormat; + enabled.extCustomBorderColor.customBorderColorWithoutFormat = supported.extCustomBorderColor.customBorderColorWithoutFormat; + + enabled.extTransformFeedback.transformFeedback = VK_TRUE; + enabled.extTransformFeedback.geometryStreams = VK_TRUE; enabled.extVertexAttributeDivisor.vertexAttributeInstanceRateDivisor = supported.extVertexAttributeDivisor.vertexAttributeInstanceRateDivisor; enabled.extVertexAttributeDivisor.vertexAttributeInstanceRateZeroDivisor = supported.extVertexAttributeDivisor.vertexAttributeInstanceRateZeroDivisor; - - if (supported.extCustomBorderColor.customBorderColorWithoutFormat) { - enabled.extCustomBorderColor.customBorderColors = VK_TRUE; - enabled.extCustomBorderColor.customBorderColorWithoutFormat = VK_TRUE; - } - if (featureLevel >= D3D_FEATURE_LEVEL_9_1) { - enabled.core.features.depthClamp = VK_TRUE; - enabled.core.features.depthBiasClamp = VK_TRUE; - enabled.core.features.fillModeNonSolid = VK_TRUE; - enabled.core.features.pipelineStatisticsQuery = supported.core.features.pipelineStatisticsQuery; - enabled.core.features.sampleRateShading = VK_TRUE; - enabled.core.features.samplerAnisotropy = supported.core.features.samplerAnisotropy; - enabled.core.features.shaderClipDistance = VK_TRUE; - enabled.core.features.shaderCullDistance = VK_TRUE; - enabled.core.features.textureCompressionBC = VK_TRUE; - enabled.extDepthClipEnable.depthClipEnable = supported.extDepthClipEnable.depthClipEnable; - enabled.extHostQueryReset.hostQueryReset = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_9_2) { - enabled.core.features.occlusionQueryPrecise = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_9_3) { - enabled.core.features.independentBlend = VK_TRUE; - enabled.core.features.multiViewport = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_10_0) { - enabled.core.features.fullDrawIndexUint32 = VK_TRUE; - enabled.core.features.logicOp = supported.core.features.logicOp; - enabled.core.features.shaderImageGatherExtended = VK_TRUE; - enabled.core.features.variableMultisampleRate = supported.core.features.variableMultisampleRate; - enabled.extTransformFeedback.transformFeedback = VK_TRUE; - enabled.extTransformFeedback.geometryStreams = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_10_1) { - enabled.core.features.dualSrcBlend = VK_TRUE; - enabled.core.features.imageCubeArray = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_11_0) { - enabled.core.features.drawIndirectFirstInstance = VK_TRUE; - enabled.core.features.fragmentStoresAndAtomics = VK_TRUE; - enabled.core.features.multiDrawIndirect = VK_TRUE; - enabled.core.features.shaderFloat64 = supported.core.features.shaderFloat64; - enabled.core.features.shaderInt64 = supported.core.features.shaderInt64; - enabled.core.features.shaderStorageImageReadWithoutFormat = supported.core.features.shaderStorageImageReadWithoutFormat; - enabled.core.features.tessellationShader = VK_TRUE; - } - - if (featureLevel >= D3D_FEATURE_LEVEL_11_1) { - enabled.core.features.logicOp = VK_TRUE; - enabled.core.features.variableMultisampleRate = VK_TRUE; - enabled.core.features.vertexPipelineStoresAndAtomics = VK_TRUE; - } - + // Required for Feature Level 11_0 + enabled.core.features.drawIndirectFirstInstance = supported.core.features.drawIndirectFirstInstance; + enabled.core.features.fragmentStoresAndAtomics = supported.core.features.fragmentStoresAndAtomics; + enabled.core.features.multiDrawIndirect = supported.core.features.multiDrawIndirect; + enabled.core.features.tessellationShader = supported.core.features.tessellationShader; + + // Required for Feature Level 11_1 + enabled.core.features.logicOp = supported.core.features.logicOp; + enabled.core.features.vertexPipelineStoresAndAtomics = supported.core.features.vertexPipelineStoresAndAtomics; + + // Required for Feature Level 12_0 + enabled.core.features.sparseBinding = supported.core.features.sparseBinding; + enabled.core.features.sparseResidencyBuffer = supported.core.features.sparseResidencyBuffer; + enabled.core.features.sparseResidencyImage2D = supported.core.features.sparseResidencyImage2D; + enabled.core.features.sparseResidencyImage3D = supported.core.features.sparseResidencyImage3D; + enabled.core.features.sparseResidency2Samples = supported.core.features.sparseResidency2Samples; + enabled.core.features.sparseResidency4Samples = supported.core.features.sparseResidency4Samples; + enabled.core.features.sparseResidency8Samples = supported.core.features.sparseResidency8Samples; + enabled.core.features.sparseResidency16Samples = supported.core.features.sparseResidency16Samples; + enabled.core.features.sparseResidencyAliased = supported.core.features.sparseResidencyAliased; + enabled.core.features.shaderResourceResidency = supported.core.features.shaderResourceResidency; + enabled.core.features.shaderResourceMinLod = supported.core.features.shaderResourceMinLod; + enabled.vk12.samplerFilterMinmax = supported.vk12.samplerFilterMinmax; + + // Required for Feature Level 12_1 + enabled.extFragmentShaderInterlock.fragmentShaderSampleInterlock = supported.extFragmentShaderInterlock.fragmentShaderSampleInterlock; + enabled.extFragmentShaderInterlock.fragmentShaderPixelInterlock = supported.extFragmentShaderInterlock.fragmentShaderPixelInterlock; + + // Optional in any feature level + enabled.core.features.depthBounds = supported.core.features.depthBounds; + enabled.core.features.shaderFloat64 = supported.core.features.shaderFloat64; + enabled.core.features.shaderInt64 = supported.core.features.shaderInt64; + + // Depth bias control + enabled.extDepthBiasControl.depthBiasControl = supported.extDepthBiasControl.depthBiasControl; + enabled.extDepthBiasControl.depthBiasExact = supported.extDepthBiasControl.depthBiasExact; + enabled.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation = supported.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation; + return enabled; } @@ -2022,11 +1984,20 @@ namespace dxvk { auto shader = commonShader.GetShader(); if (shader->flags().test(DxvkShaderFlag::ExportsStencilRef) - && !m_dxvkDevice->extensions().extShaderStencilExport) + && !m_dxvkDevice->features().extShaderStencilExport) return E_INVALIDARG; if (shader->flags().test(DxvkShaderFlag::ExportsViewportIndexLayerFromVertexStage) - && !m_dxvkDevice->extensions().extShaderViewportIndexLayer) + && (!m_dxvkDevice->features().vk12.shaderOutputViewportIndex + || !m_dxvkDevice->features().vk12.shaderOutputLayer)) + return E_INVALIDARG; + + if (shader->flags().test(DxvkShaderFlag::UsesSparseResidency) + && !m_dxvkDevice->features().core.features.shaderResourceResidency) + return E_INVALIDARG; + + if (shader->flags().test(DxvkShaderFlag::UsesFragmentCoverage) + && !m_dxvkDevice->properties().extConservativeRasterization.fullyCoveredFragmentShaderInputVariable) return E_INVALIDARG; *pShaderModule = std::move(commonShader); @@ -2042,33 +2013,33 @@ namespace dxvk { if (pFlags2 != nullptr) *pFlags2 = 0; // Unsupported or invalid format - if (Format != DXGI_FORMAT_UNKNOWN && fmtMapping.Format == VK_FORMAT_UNDEFINED) + if (Format && fmtMapping.Format == VK_FORMAT_UNDEFINED) return E_FAIL; // Query Vulkan format properties and supported features for it - const DxvkFormatInfo* fmtProperties = imageFormatInfo(fmtMapping.Format); + const DxvkFormatInfo* fmtProperties = lookupFormatInfo(fmtMapping.Format); - VkFormatProperties fmtSupport = fmtMapping.Format != VK_FORMAT_UNDEFINED - ? m_dxvkAdapter->formatProperties(fmtMapping.Format) - : VkFormatProperties(); + DxvkFormatFeatures fmtSupport = fmtMapping.Format != VK_FORMAT_UNDEFINED + ? m_dxvkDevice->getFormatFeatures(fmtMapping.Format) + : DxvkFormatFeatures(); - VkFormatFeatureFlags bufFeatures = fmtSupport.bufferFeatures; - VkFormatFeatureFlags imgFeatures = fmtSupport.optimalTilingFeatures | fmtSupport.linearTilingFeatures; + VkFormatFeatureFlags2 bufFeatures = fmtSupport.buffer; + VkFormatFeatureFlags2 imgFeatures = fmtSupport.optimal | fmtSupport.linear; // For multi-plane images, we want to check available view formats as well if (fmtProperties->flags.test(DxvkFormatFlag::MultiPlane)) { - const VkFormatFeatureFlags featureMask - = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT - | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT - | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT - | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT - | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; + const VkFormatFeatureFlags2 featureMask + = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT + | VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT + | VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT + | VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT + | VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT; DXGI_VK_FORMAT_FAMILY formatFamily = LookupFamily(Format, DXGI_VK_FORMAT_MODE_ANY); for (uint32_t i = 0; i < formatFamily.FormatCount; i++) { - VkFormatProperties viewFmtSupport = m_dxvkAdapter->formatProperties(formatFamily.Formats[i]); - imgFeatures |= (viewFmtSupport.optimalTilingFeatures | viewFmtSupport.linearTilingFeatures) & featureMask; + DxvkFormatFeatures viewFmtSupport = m_dxvkDevice->getFormatFeatures(formatFamily.Formats[i]); + imgFeatures |= (viewFmtSupport.optimal | viewFmtSupport.linear) & featureMask; } } @@ -2076,12 +2047,11 @@ namespace dxvk { UINT flags2 = 0; // Format can be used for shader resource views with buffers - if (bufFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT - || Format == DXGI_FORMAT_UNKNOWN) + if ((bufFeatures & VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT) || !Format) flags1 |= D3D11_FORMAT_SUPPORT_BUFFER; // Format can be used for vertex data - if (bufFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) + if (bufFeatures & VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT) flags1 |= D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER; // Format can be used for index data. Only @@ -2107,19 +2077,31 @@ namespace dxvk { || Format == DXGI_FORMAT_R32G32B32A32_SINT) flags1 |= D3D11_FORMAT_SUPPORT_SO_BUFFER; - if (imgFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT - || imgFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) { + if (imgFeatures & (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT)) { const VkFormat depthFormat = LookupFormat(Format, DXGI_VK_FORMAT_MODE_DEPTH).Format; - if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_1D)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE1D; - if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_2D)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE2D; - if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_3D)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE3D; - + if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_1D, 0)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE1D; + if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_2D, 0)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE2D; + if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_3D, 0)) flags1 |= D3D11_FORMAT_SUPPORT_TEXTURE3D; + + // We only support tiled resources with a single aspect + D3D11_TILED_RESOURCES_TIER tiledResourcesTier = m_deviceFeatures.GetTiledResourcesTier(); + VkImageAspectFlags sparseAspects = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; + + if (tiledResourcesTier && !(fmtProperties->aspectMask & ~sparseAspects)) { + VkImageCreateFlags flags = VK_IMAGE_CREATE_SPARSE_BINDING_BIT + | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; + + if (GetImageTypeSupport(fmtMapping.Format, VK_IMAGE_TYPE_2D, flags)) + flags2 |= D3D11_FORMAT_SUPPORT2_TILED; + } + flags1 |= D3D11_FORMAT_SUPPORT_MIP | D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT; - + // Format can be read - if (imgFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) { + if (imgFeatures & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT) { flags1 |= D3D11_FORMAT_SUPPORT_TEXTURECUBE | D3D11_FORMAT_SUPPORT_SHADER_LOAD | D3D11_FORMAT_SUPPORT_SHADER_GATHER @@ -2133,7 +2115,7 @@ namespace dxvk { } // Format is a color format that can be used for rendering - if (imgFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) { + if (imgFeatures & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT) { flags1 |= D3D11_FORMAT_SUPPORT_RENDER_TARGET | D3D11_FORMAT_SUPPORT_MIP_AUTOGEN | D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT; @@ -2143,14 +2125,14 @@ namespace dxvk { } // Format supports blending when used for rendering - if (imgFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT) + if (imgFeatures & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT) flags1 |= D3D11_FORMAT_SUPPORT_BLENDABLE; // Format is a depth-stencil format that can be used for rendering - if (imgFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) + if (imgFeatures & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) flags1 |= D3D11_FORMAT_SUPPORT_DEPTH_STENCIL; - // FIXME implement properly. This would require a VkSurface. + // Report supported swap chain formats if (Format == DXGI_FORMAT_R8G8B8A8_UNORM || Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB || Format == DXGI_FORMAT_B8G8R8A8_UNORM @@ -2161,36 +2143,61 @@ namespace dxvk { flags1 |= D3D11_FORMAT_SUPPORT_DISPLAY; // Query multisample support for this format - VkImageFormatProperties imgFmtProperties; - - VkResult status = m_dxvkAdapter->imageFormatProperties(fmtMapping.Format, - VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, - (fmtProperties->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) - ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT - : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - 0, imgFmtProperties); - - if (status == VK_SUCCESS && imgFmtProperties.sampleCounts > VK_SAMPLE_COUNT_1_BIT) { + VkImageUsageFlags usage = (fmtProperties->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) + ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + + DxvkFormatQuery formatQuery = { }; + formatQuery.format = fmtMapping.Format; + formatQuery.type = VK_IMAGE_TYPE_2D; + formatQuery.tiling = VK_IMAGE_TILING_OPTIMAL; + formatQuery.usage = usage; + + auto limits = m_dxvkDevice->getFormatLimits(formatQuery); + + if (limits && limits->sampleCounts > VK_SAMPLE_COUNT_1_BIT) { flags1 |= D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET | D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE | D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD; } + + // Query whether the format is shareable + if ((fmtProperties->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_PLANE_0_BIT)) + && (m_dxvkDevice->features().khrExternalMemoryWin32)) { + constexpr VkExternalMemoryFeatureFlags featureMask + = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT + | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT; + + formatQuery.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT; + limits = m_dxvkDevice->getFormatLimits(formatQuery); + + if (limits && (limits->externalFeatures & featureMask)) + flags2 |= D3D11_FORMAT_SUPPORT2_SHAREABLE; + } } // Format can be used for storage images or storage texel buffers - if ((bufFeatures & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT) - && (imgFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) { + if ((bufFeatures & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT) + && (imgFeatures & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT) + && (imgFeatures & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT)) { flags1 |= D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW; flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE; - if (m_dxvkDevice->features().core.features.shaderStorageImageReadWithoutFormat - || Format == DXGI_FORMAT_R32_UINT - || Format == DXGI_FORMAT_R32_SINT - || Format == DXGI_FORMAT_R32_FLOAT) - flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD; + if (m_dxbcOptions.supportsTypedUavLoadR32) { + // If the R32 formats are supported without format declarations, + // we can optionally support additional formats for typed loads + if (imgFeatures & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) + flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD; + } else { + // Otherwise, we need to emit format declarations, so we can + // only support the basic set of R32 formats for typed loads + if (Format == DXGI_FORMAT_R32_FLOAT + || Format == DXGI_FORMAT_R32_UINT + || Format == DXGI_FORMAT_R32_SINT) + flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD; + } - if (Format == DXGI_FORMAT_R32_UINT - || Format == DXGI_FORMAT_R32_SINT) { + if (Format == DXGI_FORMAT_R32_UINT || Format == DXGI_FORMAT_R32_SINT) { flags2 |= D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD | D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS | D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE @@ -2215,20 +2222,22 @@ namespace dxvk { } - BOOL D3D11Device::GetImageTypeSupport(VkFormat Format, VkImageType Type) const { - VkImageFormatProperties props; - - VkResult status = m_dxvkAdapter->imageFormatProperties( - Format, Type, VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_SAMPLED_BIT, 0, props); - - if (status != VK_SUCCESS) { - status = m_dxvkAdapter->imageFormatProperties( - Format, Type, VK_IMAGE_TILING_LINEAR, - VK_IMAGE_USAGE_SAMPLED_BIT, 0, props); + BOOL D3D11Device::GetImageTypeSupport(VkFormat Format, VkImageType Type, VkImageCreateFlags Flags) const { + DxvkFormatQuery formatQuery = { }; + formatQuery.format = Format; + formatQuery.type = Type; + formatQuery.tiling = VK_IMAGE_TILING_OPTIMAL; + formatQuery.usage = VK_IMAGE_USAGE_SAMPLED_BIT; + formatQuery.flags = Flags; + + auto properties = m_dxvkDevice->getFormatLimits(formatQuery); + + if (!properties) { + formatQuery.tiling = VK_IMAGE_TILING_LINEAR; + properties = m_dxvkDevice->getFormatLimits(formatQuery); } - - return status == VK_SUCCESS; + + return properties.has_value(); } @@ -2268,6 +2277,7 @@ namespace dxvk { if (ppResource == nullptr) return S_FALSE; +#ifdef _WIN32 HANDLE ntHandle = IsKmtHandle ? openKmtHandle(hResource) : hResource; if (ntHandle == INVALID_HANDLE_VALUE) { @@ -2299,10 +2309,14 @@ namespace dxvk { d3d11Desc.CPUAccessFlags = metadata.CPUAccessFlags; d3d11Desc.MiscFlags = metadata.MiscFlags; d3d11Desc.TextureLayout = metadata.TextureLayout; + if ((d3d11Desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE) && !(d3d11Desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX))) { + Logger::warn("Fixing up wrong MiscFlags"); + d3d11Desc.MiscFlags |= D3D11_RESOURCE_MISC_SHARED; + } // Only 2D textures may be shared try { - const Com texture = new D3D11Texture2D(this, &d3d11Desc, hResource); + const Com texture = new D3D11Texture2D(this, &d3d11Desc, nullptr, hResource); texture->QueryInterface(ReturnedInterface, ppResource); return S_OK; } @@ -2310,6 +2324,10 @@ namespace dxvk { Logger::err(e.message()); return E_INVALIDARG; } +#else + Logger::warn("D3D11Device::OpenSharedResourceGeneric: Not supported on this platform."); + return E_INVALIDARG; +#endif } @@ -2318,36 +2336,16 @@ namespace dxvk { Void* pData, UINT RowPitch, UINT DepthPitch, - ID3D11Resource* pResource, + D3D11CommonTexture* pTexture, UINT Subresource, const D3D11_BOX* pBox) { - auto texture = GetCommonTexture(pResource); - - if (!texture) - return; - - // Validate texture state and skip invalid calls - if (texture->Desc()->Usage != D3D11_USAGE_DEFAULT - || texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_NONE - || texture->CountSubresources() <= Subresource - || texture->GetMapType(Subresource) == D3D11_MAP(~0u)) - return; - - // Retrieve image format information - VkFormat packedFormat = LookupPackedFormat( - texture->Desc()->Format, - texture->GetFormatMode()).Format; - - auto formatInfo = imageFormatInfo(packedFormat); - // Validate box against subresource dimensions - Rc image = texture->GetImage(); - - auto subresource = texture->GetSubresourceFromIndex( + auto formatInfo = lookupFormatInfo(pTexture->GetPackedFormat()); + auto subresource = pTexture->GetSubresourceFromIndex( formatInfo->aspectMask, Subresource); - + VkOffset3D offset = { 0, 0, 0 }; - VkExtent3D extent = image->mipLevelExtent(subresource.mipLevel); + VkExtent3D extent = pTexture->MipLevelExtent(subresource.mipLevel); if (pBox) { if (pBox->left >= pBox->right @@ -2371,88 +2369,55 @@ namespace dxvk { pBox->back - pBox->front }; } - // We can only operate on full blocks of compressed images - offset = util::computeBlockOffset(offset, formatInfo->blockSize); - extent = util::computeBlockCount(extent, formatInfo->blockSize); + // Copy image data, one plane at a time for multi-plane formats + Rc image = pTexture->GetImage(); + VkDeviceSize dataOffset = 0; - // Determine the memory layout of the image data - D3D11_MAPPED_SUBRESOURCE subresourceData = { }; + for (uint32_t i = 0; i < pTexture->GetPlaneCount(); i++) { + // Find current image aspects to process + VkImageAspectFlags aspect = formatInfo->aspectMask; - if (texture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) { - VkSubresourceLayout layout = image->querySubresourceLayout(subresource); - subresourceData.pData = image->mapPtr(layout.offset); - subresourceData.RowPitch = layout.rowPitch; - subresourceData.DepthPitch = layout.depthPitch; - } else { - subresourceData.pData = texture->GetMappedBuffer(Subresource)->mapPtr(0); - subresourceData.RowPitch = formatInfo->elementSize * extent.width; - subresourceData.DepthPitch = formatInfo->elementSize * extent.width * extent.height; + if (formatInfo->flags.test(DxvkFormatFlag::MultiPlane)) + aspect = vk::getPlaneAspect(i); + + // Compute data layout of the current subresource + D3D11_COMMON_TEXTURE_SUBRESOURCE_LAYOUT layout = pTexture->GetSubresourceLayout(aspect, Subresource); + + // Compute actual map pointer, accounting for the region offset + VkDeviceSize mapOffset = pTexture->ComputeMappedOffset(Subresource, i, offset); + + void* mapPtr = pTexture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER + ? pTexture->GetMappedBuffer(Subresource)->mapPtr(mapOffset) + : image->mapPtr(mapOffset); + + if constexpr (std::is_const::value) { + // WriteToSubresource + auto srcData = reinterpret_cast(pData) + dataOffset; + + util::packImageData(mapPtr, srcData, RowPitch, DepthPitch, + layout.RowPitch, layout.DepthPitch, image->info().type, + extent, 1, formatInfo, aspect); + } else { + // ReadFromSubresource + auto dstData = reinterpret_cast(pData) + dataOffset; + + util::packImageData(dstData, mapPtr, + layout.RowPitch, layout.DepthPitch, + RowPitch, DepthPitch, image->info().type, + extent, 1, formatInfo, aspect); + } + + // Advance linear data pointer by the size of the current aspect + dataOffset += util::computeImageDataSize( + pTexture->GetPackedFormat(), extent, aspect); } - if constexpr (std::is_const::value) { - // WriteToSubresource - auto src = reinterpret_cast(pData); - auto dst = reinterpret_cast< char*>(subresourceData.pData); - - for (uint32_t z = 0; z < extent.depth; z++) { - for (uint32_t y = 0; y < extent.height; y++) { - std::memcpy( - dst + (offset.z + z) * subresourceData.DepthPitch - + (offset.y + y) * subresourceData.RowPitch - + (offset.x) * formatInfo->elementSize, - src + z * DepthPitch - + y * RowPitch, - formatInfo->elementSize * extent.width); - } - } - } else { - // ReadFromSubresource - auto src = reinterpret_cast(subresourceData.pData); - auto dst = reinterpret_cast< char*>(pData); - - for (uint32_t z = 0; z < extent.depth; z++) { - for (uint32_t y = 0; y < extent.height; y++) { - std::memcpy( - dst + z * DepthPitch - + y * RowPitch, - src + (offset.z + z) * subresourceData.DepthPitch - + (offset.y + y) * subresourceData.RowPitch - + (offset.x) * formatInfo->elementSize, - formatInfo->elementSize * extent.width); - } - } - } + // Track dirty texture region if necessary + if constexpr (std::is_const::value) + pTexture->AddDirtyRegion(Subresource, offset, extent); } - D3D_FEATURE_LEVEL D3D11Device::GetMaxFeatureLevel(const Rc& pInstance) { - static const std::array, 9> s_featureLevels = {{ - { "12_1", D3D_FEATURE_LEVEL_12_1 }, - { "12_0", D3D_FEATURE_LEVEL_12_0 }, - { "11_1", D3D_FEATURE_LEVEL_11_1 }, - { "11_0", D3D_FEATURE_LEVEL_11_0 }, - { "10_1", D3D_FEATURE_LEVEL_10_1 }, - { "10_0", D3D_FEATURE_LEVEL_10_0 }, - { "9_3", D3D_FEATURE_LEVEL_9_3 }, - { "9_2", D3D_FEATURE_LEVEL_9_2 }, - { "9_1", D3D_FEATURE_LEVEL_9_1 }, - }}; - - const std::string maxLevel = pInstance->config() - .getOption("d3d11.maxFeatureLevel"); - - auto entry = std::find_if(s_featureLevels.begin(), s_featureLevels.end(), - [&] (const std::pair& pair) { - return pair.first == maxLevel; - }); - - return entry != s_featureLevels.end() - ? entry->second - : D3D_FEATURE_LEVEL_11_1; - } - - - D3D11DeviceExt::D3D11DeviceExt( D3D11DXGIDevice* pContainer, @@ -2482,7 +2447,6 @@ namespace dxvk { BOOL STDMETHODCALLTYPE D3D11DeviceExt::GetExtensionSupport( D3D11_VK_EXTENSION Extension) { const auto& deviceFeatures = m_device->GetDXVKDevice()->features(); - const auto& deviceExtensions = m_device->GetDXVKDevice()->extensions(); switch (Extension) { case D3D11_VK_EXT_BARRIER_CONTROL: @@ -2493,17 +2457,17 @@ namespace dxvk { case D3D11_VK_EXT_MULTI_DRAW_INDIRECT_COUNT: return deviceFeatures.core.features.multiDrawIndirect - && deviceExtensions.khrDrawIndirectCount; + && deviceFeatures.vk12.drawIndirectCount; case D3D11_VK_EXT_DEPTH_BOUNDS: return deviceFeatures.core.features.depthBounds; case D3D11_VK_NVX_IMAGE_VIEW_HANDLE: - return deviceExtensions.nvxImageViewHandle; + return deviceFeatures.nvxImageViewHandle; case D3D11_VK_NVX_BINARY_IMPORT: - return deviceExtensions.nvxBinaryImport - && deviceExtensions.khrBufferDeviceAddress; + return deviceFeatures.nvxBinaryImport + && deviceFeatures.vk12.bufferDeviceAddress; default: return false; @@ -2662,9 +2626,10 @@ namespace dxvk { const DxvkBufferSliceHandle bufSliceHandle = buffer->GetBuffer()->getSliceHandle(); VkBuffer vkBuffer = bufSliceHandle.handle; - VkBufferDeviceAddressInfoKHR bdaInfo = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR }; + VkBufferDeviceAddressInfo bdaInfo = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO }; bdaInfo.buffer = vkBuffer; - VkDeviceAddress bufAddr = dxvkDevice->vkd()->vkGetBufferDeviceAddressKHR(vkDevice, &bdaInfo); + + VkDeviceAddress bufAddr = dxvkDevice->vkd()->vkGetBufferDeviceAddress(vkDevice, &bdaInfo); *gpuVAStart = uint64_t(bufAddr) + bufSliceHandle.offset; *gpuVASize = bufSliceHandle.length; } @@ -3020,79 +2985,53 @@ namespace dxvk { - WineDXGISwapChainFactory::WineDXGISwapChainFactory( + DXGIVkSwapChainFactory::DXGIVkSwapChainFactory( D3D11DXGIDevice* pContainer, D3D11Device* pDevice) : m_container(pContainer), m_device(pDevice) { } - - - ULONG STDMETHODCALLTYPE WineDXGISwapChainFactory::AddRef() { + + + ULONG STDMETHODCALLTYPE DXGIVkSwapChainFactory::AddRef() { return m_device->AddRef(); } - - - ULONG STDMETHODCALLTYPE WineDXGISwapChainFactory::Release() { + + + ULONG STDMETHODCALLTYPE DXGIVkSwapChainFactory::Release() { return m_device->Release(); } - - - HRESULT STDMETHODCALLTYPE WineDXGISwapChainFactory::QueryInterface( + + + HRESULT STDMETHODCALLTYPE DXGIVkSwapChainFactory::QueryInterface( REFIID riid, void** ppvObject) { return m_device->QueryInterface(riid, ppvObject); } - - - HRESULT STDMETHODCALLTYPE WineDXGISwapChainFactory::CreateSwapChainForHwnd( - IDXGIFactory* pFactory, - HWND hWnd, - const DXGI_SWAP_CHAIN_DESC1* pDesc, - const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, - IDXGIOutput* pRestrictToOutput, - IDXGISwapChain1** ppSwapChain) { + + + HRESULT STDMETHODCALLTYPE DXGIVkSwapChainFactory::CreateSwapChain( + IDXGIVkSurfaceFactory* pSurfaceFactory, + const DXGI_SWAP_CHAIN_DESC1* pDesc, + IDXGIVkSwapChain** ppSwapChain) { InitReturnPtr(ppSwapChain); - - if (!ppSwapChain || !pDesc || !hWnd) - return DXGI_ERROR_INVALID_CALL; - - // Make sure the back buffer size is not zero - DXGI_SWAP_CHAIN_DESC1 desc = *pDesc; - - GetWindowClientSize(hWnd, - desc.Width ? nullptr : &desc.Width, - desc.Height ? nullptr : &desc.Height); - - // If necessary, set up a default set of - // fullscreen parameters for the swap chain - DXGI_SWAP_CHAIN_FULLSCREEN_DESC fsDesc; - - if (pFullscreenDesc) { - fsDesc = *pFullscreenDesc; - } else { - fsDesc.RefreshRate = { 0, 0 }; - fsDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; - fsDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; - fsDesc.Windowed = TRUE; - } - + try { - // Create presenter for the device + auto vki = m_device->GetDXVKDevice()->adapter()->vki(); + Com presenter = new D3D11SwapChain( - m_container, m_device, hWnd, &desc); + m_container, m_device, pSurfaceFactory, pDesc); - // Create the actual swap chain - *ppSwapChain = ref(new DxgiSwapChain( - pFactory, presenter.ptr(), hWnd, &desc, &fsDesc)); + *ppSwapChain = presenter.ref(); return S_OK; } catch (const DxvkError& e) { Logger::err(e.message()); - return E_INVALIDARG; + return E_FAIL; } } - - + + + DXGIDXVKDevice::DXGIDXVKDevice(D3D11DXGIDevice* pContainer) : m_container(pContainer), m_apiVersion(11) { @@ -3132,26 +3071,30 @@ namespace dxvk { D3D11DXGIDevice::D3D11DXGIDevice( IDXGIAdapter* pAdapter, - const Rc& pDxvkInstance, - const Rc& pDxvkAdapter, + ID3D12Device* pD3D12Device, + ID3D12CommandQueue* pD3D12Queue, + Rc pDxvkInstance, + Rc pDxvkAdapter, + Rc pDxvkDevice, D3D_FEATURE_LEVEL FeatureLevel, UINT FeatureFlags) : m_dxgiAdapter (pAdapter), m_dxvkInstance (pDxvkInstance), m_dxvkAdapter (pDxvkAdapter), - m_dxvkDevice (CreateDevice(FeatureLevel)), + m_dxvkDevice (pDxvkDevice), m_d3d11Device (this, FeatureLevel, FeatureFlags), m_d3d11DeviceExt(this, &m_d3d11Device), m_d3d11Interop (this, &m_d3d11Device), m_d3d11Video (this, &m_d3d11Device), + m_d3d11on12 (this, &m_d3d11Device, pD3D12Device, pD3D12Queue), m_metaDevice (this), - m_wineFactory (this, &m_d3d11Device) { + m_dxvkFactory (this, &m_d3d11Device) { } D3D11DXGIDevice::~D3D11DXGIDevice() { - + } @@ -3205,8 +3148,8 @@ namespace dxvk { return S_OK; } - if (riid == __uuidof(IWineDXGISwapChainFactory)) { - *ppvObject = ref(&m_wineFactory); + if (riid == __uuidof(IDXGIVkSwapChainFactory)) { + *ppvObject = ref(&m_dxvkFactory); return S_OK; } @@ -3215,6 +3158,13 @@ namespace dxvk { return S_OK; } + if (m_d3d11on12.Is11on12Device()) { + if (riid == __uuidof(ID3D11On12Device)) { + *ppvObject = ref(&m_d3d11on12); + return S_OK; + } + } + if (riid == __uuidof(ID3D10Multithread)) { Com context; m_d3d11Device.GetImmediateContext(&context); @@ -3228,8 +3178,11 @@ namespace dxvk { if (riid == GUID{0xd56e2a4c,0x5127,0x8437,{0x65,0x8a,0x98,0xc5,0xbb,0x78,0x94,0x98}}) return E_NOINTERFACE; - Logger::warn("D3D11DXGIDevice::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(IDXGIDXVKDevice), riid)) { + Logger::warn("D3D11DXGIDevice::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -3475,10 +3428,4 @@ namespace dxvk { return m_dxvkDevice; } - - Rc D3D11DXGIDevice::CreateDevice(D3D_FEATURE_LEVEL FeatureLevel) { - DxvkDeviceFeatures deviceFeatures = D3D11Device::GetDeviceFeatures(m_dxvkAdapter, FeatureLevel); - return m_dxvkAdapter->createDevice(m_dxvkInstance, deviceFeatures); - } - } diff --git a/src/d3d11/d3d11_device.h b/src/d3d11/d3d11_device.h index 7643f8f4..7a44b5ad 100644 --- a/src/d3d11/d3d11_device.h +++ b/src/d3d11/d3d11_device.h @@ -16,9 +16,11 @@ #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" @@ -31,7 +33,6 @@ namespace dxvk { class D3D11CommonShader; class D3D11CommonTexture; class D3D11Counter; - class D3D11DeviceContext; class D3D11DXGIDevice; class D3D11ImmediateContext; class D3D11Predicate; @@ -260,7 +261,7 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE CreateFence( UINT64 InitialValue, D3D11_FENCE_FLAG Flags, - REFIID ReturnedInterface, + REFIID riid, void** ppFence); void STDMETHODCALLTYPE ReadFromSubresource( @@ -420,19 +421,23 @@ namespace dxvk { D3D10Device* GetD3D10Interface() const { return m_d3d10Device; } - - static bool CheckFeatureLevelSupport( - const Rc& instance, - const Rc& adapter, - D3D_FEATURE_LEVEL featureLevel); + + D3D11ImmediateContext* GetContext() const { + return m_context.ptr(); + } + + bool Is11on12Device() const; + + static D3D_FEATURE_LEVEL GetMaxFeatureLevel( + const Rc& Instance, + const Rc& Adapter); static DxvkDeviceFeatures GetDeviceFeatures( - const Rc& adapter, - D3D_FEATURE_LEVEL featureLevel); + const Rc& Adapter); private: - IDXGIObject* m_container; + D3D11DXGIDevice* m_container; D3D_FEATURE_LEVEL m_featureLevel; UINT m_featureFlags; @@ -455,7 +460,10 @@ namespace dxvk { D3D11StateObjectSet m_rsStateObjects; D3D11StateObjectSet m_samplerObjects; D3D11ShaderModuleSet m_shaderModules; - + + D3D_FEATURE_LEVEL m_maxFeatureLevel; + D3D11DeviceFeatures m_deviceFeatures; + HRESULT CreateShaderModule( D3D11CommonShader* pShaderModule, DxvkShaderKey ShaderKey, @@ -465,13 +473,14 @@ 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 HRESULT OpenSharedResourceGeneric( @@ -488,13 +497,10 @@ namespace dxvk { Void* pData, UINT RowPitch, UINT DepthPitch, - ID3D11Resource* pResource, + D3D11CommonTexture* pTexture, UINT Subresource, const D3D11_BOX* pBox); - static D3D_FEATURE_LEVEL GetMaxFeatureLevel( - const Rc& pInstance); - }; @@ -692,39 +698,36 @@ namespace dxvk { /** - * \brief DXGI swap chain factory + * \brief DXVK swap chain factory */ - class WineDXGISwapChainFactory : public IWineDXGISwapChainFactory { - + class DXGIVkSwapChainFactory : public IDXGIVkSwapChainFactory { + public: - - WineDXGISwapChainFactory( + + DXGIVkSwapChainFactory( D3D11DXGIDevice* pContainer, D3D11Device* pDevice); - + ULONG STDMETHODCALLTYPE AddRef(); - + ULONG STDMETHODCALLTYPE Release(); - + HRESULT STDMETHODCALLTYPE QueryInterface( REFIID riid, void** ppvObject); - - HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd( - IDXGIFactory* pFactory, - HWND hWnd, - const DXGI_SWAP_CHAIN_DESC1* pDesc, - const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, - IDXGIOutput* pRestrictToOutput, - IDXGISwapChain1** ppSwapChain); - + + 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 @@ -768,8 +771,11 @@ namespace dxvk { D3D11DXGIDevice( IDXGIAdapter* pAdapter, - const Rc& pDxvkInstance, - const Rc& pDxvkAdapter, + ID3D12Device* pD3D12Device, + ID3D12CommandQueue* pD3D12Queue, + Rc pDxvkInstance, + Rc pDxvkAdapter, + Rc pDxvkDevice, D3D_FEATURE_LEVEL FeatureLevel, UINT FeatureFlags); @@ -838,6 +844,10 @@ namespace dxvk { Rc STDMETHODCALLTYPE GetDXVKDevice(); + BOOL Is11on12Device() const { + return m_d3d11on12.Is11on12Device(); + } + private: Com m_dxgiAdapter; @@ -850,14 +860,13 @@ namespace dxvk { D3D11DeviceExt m_d3d11DeviceExt; D3D11VkInterop m_d3d11Interop; D3D11VideoDevice m_d3d11Video; + D3D11on12Device m_d3d11on12; DXGIDXVKDevice m_metaDevice; - WineDXGISwapChainFactory m_wineFactory; + DXGIVkSwapChainFactory m_dxvkFactory; uint32_t m_frameLatency = DefaultFrameLatency; - Rc CreateDevice(D3D_FEATURE_LEVEL FeatureLevel); - }; } diff --git a/src/d3d11/d3d11_features.cpp b/src/d3d11/d3d11_features.cpp new file mode 100644 index 00000000..f206e517 --- /dev/null +++ b/src/d3d11/d3d11_features.cpp @@ -0,0 +1,399 @@ +#include + +#include "d3d11_features.h" + +namespace dxvk { + + D3D11DeviceFeatures::D3D11DeviceFeatures() { + + } + + + D3D11DeviceFeatures::D3D11DeviceFeatures( + const Rc& Instance, + const Rc& Adapter, + 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 = 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 here so that we do not actually have + // to re-implement the UpdateSubresource bug from the D3D11 runtime, see MSDN: + // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476486(v=vs.85).aspx) + m_threading.DriverConcurrentCreates = TRUE; + m_threading.DriverCommandLists = TRUE; + } + + + 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& Instance, + const Rc& Adapter) { + D3D11DeviceFeatures features(Instance, Adapter, 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& Adapter, + D3D_FEATURE_LEVEL FeatureLevel) { + static std::atomic 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 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& Adapter, + D3D_FEATURE_LEVEL FeatureLevel) { + static const std::array 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& 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; + } + +} diff --git a/src/d3d11/d3d11_features.h b/src/d3d11/d3d11_features.h new file mode 100644 index 00000000..9bdd7c31 --- /dev/null +++ b/src/d3d11/d3d11_features.h @@ -0,0 +1,124 @@ +#pragma once + +#include "d3d11_include.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& Instance, + const Rc& Adapter, + 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& Instance, + const Rc& 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 + static HRESULT GetTypedFeatureData(UINT Size, void* pDstData, const T* pSrcData) { + if (Size != sizeof(T)) + return E_INVALIDARG; + + *(reinterpret_cast(pDstData)) = *pSrcData; + return S_OK; + } + + D3D11_CONSERVATIVE_RASTERIZATION_TIER DetermineConservativeRasterizationTier( + D3D_FEATURE_LEVEL FeatureLevel); + + D3D11_SHARED_RESOURCE_TIER DetermineSharedResourceTier( + const Rc& Adapter, + D3D_FEATURE_LEVEL FeatureLevel); + + D3D11_TILED_RESOURCES_TIER DetermineTiledResourcesTier( + D3D_FEATURE_LEVEL FeatureLevel); + + BOOL DetermineUavExtendedTypedLoadSupport( + const Rc& Adapter, + D3D_FEATURE_LEVEL FeatureLevel); + + BOOL CheckFormatSharingSupport( + const Rc& Adapter, + VkFormat Format, + VkExternalMemoryHandleTypeFlagBits HandleType); + + D3D_FEATURE_LEVEL GetMaxFeatureLevel() const; + + }; + +} \ No newline at end of file diff --git a/src/d3d11/d3d11_fence.cpp b/src/d3d11/d3d11_fence.cpp new file mode 100644 index 00000000..3eeb6946 --- /dev/null +++ b/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(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(); + } + +} diff --git a/src/d3d11/d3d11_fence.h b/src/d3d11/d3d11_fence.h new file mode 100644 index 00000000..99d42a94 --- /dev/null +++ b/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 { + + 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 GetFence() const { + return m_fence; + } + + private: + + Rc m_fence; + D3D11_FENCE_FLAG m_flags; + + }; + +} diff --git a/src/d3d11/d3d11_gdi.cpp b/src/d3d11/d3d11_gdi.cpp index 0958886e..e9f7bf73 100644 --- a/src/d3d11/d3d11_gdi.cpp +++ b/src/d3d11/d3d11_gdi.cpp @@ -3,6 +3,7 @@ #include "d3d11_gdi.h" #include "../util/util_gdi.h" +#include "../util/util_win32_compat.h" namespace dxvk { @@ -149,11 +150,8 @@ namespace dxvk { HRESULT D3D11GDISurface::CreateReadbackResource() { auto tex = GetCommonTexture(m_resource); - Com device; - Com context; - + Com device; m_resource->GetDevice(&device); - device->GetImmediateContext(&context); D3D11_RESOURCE_DIMENSION dim = { }; m_resource->GetType(&dim); diff --git a/src/d3d11/d3d11_include.h b/src/d3d11/d3d11_include.h index 1598088a..ef6b135e 100644 --- a/src/d3d11/d3d11_include.h +++ b/src/d3d11/d3d11_include.h @@ -3,44 +3,3 @@ #include "../dxgi/dxgi_include.h" #include - -// This is not defined in the mingw headers -#ifndef D3D11_1_UAV_SLOT_COUNT -#define D3D11_1_UAV_SLOT_COUNT 64 -#endif - -#ifndef D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL -#define D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL 0xFFFFFFFF -#endif - -#ifndef D3D11_KEEP_UNORDERED_ACCESS_VIEWS -#define D3D11_KEEP_UNORDERED_ACCESS_VIEWS 0xFFFFFFFF -#endif - -#define D3D11_DXVK_USE_REMAINING_LAYERS 0xFFFFFFFF -#define D3D11_DXVK_USE_REMAINING_LEVELS 0xFFFFFFFF - -// Most of these were copied from d3d11.h -// For some strange reason, we cannot use the structures -// directly, although others from the same header work. -// Some structures are missing from the mingw headers. -#ifndef _MSC_VER -#if !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 9 -typedef enum D3D11_FORMAT_SUPPORT2 { - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x1, - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x2, - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x4, - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x8, - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x10, - D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x20, - D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x40, - D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x80, - D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x100, - D3D11_FORMAT_SUPPORT2_TILED = 0x200, - D3D11_FORMAT_SUPPORT2_SHAREABLE = 0x400, - D3D11_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x4000 -} D3D11_FORMAT_SUPPORT2; -#define D3D11_RESOURCE_MISC_TILE_POOL (0x20000) -#define D3D11_RESOURCE_MISC_TILED (0x40000) -#endif // !defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 9 -#endif // _MSC_VER diff --git a/src/d3d11/d3d11_initializer.cpp b/src/d3d11/d3d11_initializer.cpp index 863c453e..105485fa 100644 --- a/src/d3d11/d3d11_initializer.cpp +++ b/src/d3d11/d3d11_initializer.cpp @@ -9,7 +9,7 @@ namespace dxvk { D3D11Device* pParent) : m_parent(pParent), m_device(pParent->GetDXVKDevice()), - m_context(m_device->createContext()) { + m_context(m_device->createContext(DxvkContextType::Supplementary)) { m_context->beginRecording( m_device->createCommandList()); } @@ -30,37 +30,47 @@ namespace dxvk { void D3D11Initializer::InitBuffer( D3D11Buffer* pBuffer, const D3D11_SUBRESOURCE_DATA* pInitialData) { - VkMemoryPropertyFlags memFlags = pBuffer->GetBuffer()->memFlags(); + if (!(pBuffer->Desc()->MiscFlags & D3D11_RESOURCE_MISC_TILED)) { + VkMemoryPropertyFlags memFlags = pBuffer->GetBuffer()->memFlags(); - (memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) - ? InitHostVisibleBuffer(pBuffer, pInitialData) - : InitDeviceLocalBuffer(pBuffer, pInitialData); + (memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) + ? InitHostVisibleBuffer(pBuffer, pInitialData) + : InitDeviceLocalBuffer(pBuffer, pInitialData); + } } void D3D11Initializer::InitTexture( D3D11CommonTexture* pTexture, const D3D11_SUBRESOURCE_DATA* pInitialData) { - (pTexture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) - ? InitHostVisibleTexture(pTexture, pInitialData) - : InitDeviceLocalTexture(pTexture, pInitialData); + if (pTexture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_TILED) + InitTiledTexture(pTexture); + else if (pTexture->GetMapMode() == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) + InitHostVisibleTexture(pTexture, pInitialData); + else + InitDeviceLocalTexture(pTexture, pInitialData); + + SyncKeyedMutex(pTexture->GetInterface()); } void D3D11Initializer::InitUavCounter( D3D11UnorderedAccessView* pUav) { - auto counterBuffer = pUav->GetCounterSlice(); + auto counterView = pUav->GetCounterView(); - if (!counterBuffer.defined()) + if (counterView == nullptr) return; + auto counterSlice = counterView->slice(); + std::lock_guard lock(m_mutex); m_transferCommands += 1; const uint32_t zero = 0; m_context->updateBuffer( - counterBuffer.buffer(), - 0, sizeof(zero), &zero); + counterSlice.buffer(), + counterSlice.offset(), + sizeof(zero), &zero); FlushImplicit(); } @@ -123,7 +133,7 @@ namespace dxvk { auto desc = pTexture->Desc(); VkFormat packedFormat = m_parent->LookupPackedFormat(desc->Format, pTexture->GetFormatMode()).Format; - auto formatInfo = imageFormatInfo(packedFormat); + auto formatInfo = lookupFormatInfo(packedFormat); if (pInitialData != nullptr && pInitialData->pSysMem != nullptr) { // pInitialData is an array that stores an entry for @@ -253,6 +263,15 @@ namespace dxvk { } + void D3D11Initializer::InitTiledTexture( + D3D11CommonTexture* pTexture) { + m_context->initSparseImage(pTexture->GetImage()); + + m_transferCommands += 1; + FlushImplicit(); + } + + void D3D11Initializer::FlushImplicit() { if (m_transferCommands > MaxTransferCommands || m_transferMemory > MaxTransferMemory) @@ -261,10 +280,20 @@ namespace dxvk { void D3D11Initializer::FlushInternal() { - m_context->flushCommandList(); + m_context->flushCommandList(nullptr); m_transferCommands = 0; m_transferMemory = 0; } + + void D3D11Initializer::SyncKeyedMutex(ID3D11Resource *pResource) { + Com keyedMutex; + if (pResource->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast(&keyedMutex)) != S_OK) + return; + + keyedMutex->AcquireSync(0, 0); + keyedMutex->ReleaseSync(0); + } + } \ No newline at end of file diff --git a/src/d3d11/d3d11_initializer.h b/src/d3d11/d3d11_initializer.h index 8c96babd..1cd94d80 100644 --- a/src/d3d11/d3d11_initializer.h +++ b/src/d3d11/d3d11_initializer.h @@ -64,10 +64,15 @@ namespace dxvk { void InitHostVisibleTexture( D3D11CommonTexture* pTexture, const D3D11_SUBRESOURCE_DATA* pInitialData); - + + void InitTiledTexture( + D3D11CommonTexture* pTexture); + void FlushImplicit(); void FlushInternal(); + void SyncKeyedMutex(ID3D11Resource *pResource); + }; } \ No newline at end of file diff --git a/src/d3d11/d3d11_input_layout.cpp b/src/d3d11/d3d11_input_layout.cpp index abf3d125..3b42e0a4 100644 --- a/src/d3d11/d3d11_input_layout.cpp +++ b/src/d3d11/d3d11_input_layout.cpp @@ -46,13 +46,16 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11InputLayout::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11InputLayout), riid)) { + Logger::warn("D3D11InputLayout::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } - void D3D11InputLayout::BindToContext(const Rc& ctx) { + void D3D11InputLayout::BindToContext(DxvkContext* ctx) { ctx->setInputLayout( m_attributes.size(), m_attributes.data(), diff --git a/src/d3d11/d3d11_input_layout.h b/src/d3d11/d3d11_input_layout.h index 8e472e2e..e761c647 100644 --- a/src/d3d11/d3d11_input_layout.h +++ b/src/d3d11/d3d11_input_layout.h @@ -25,8 +25,7 @@ namespace dxvk { REFIID riid, void** ppvObject) final; - void BindToContext( - const Rc& ctx); + void BindToContext(DxvkContext* ctx); bool Compare( const D3D11InputLayout* pOther) const; diff --git a/src/d3d11/d3d11_interfaces.h b/src/d3d11/d3d11_interfaces.h index 3b0629bb..587cde13 100644 --- a/src/d3d11/d3d11_interfaces.h +++ b/src/d3d11/d3d11_interfaces.h @@ -28,6 +28,26 @@ enum D3D11_VK_BARRIER_CONTROL : uint32_t { }; +/** + * \brief Extended shader interface + */ +MIDL_INTERFACE("bb8a4fb9-3935-4762-b44b-35189a26414a") +ID3D11VkExtShader : public IUnknown { + /** + * \brief Retrieves SPIR-V code from a shader object + * + * \param [in,out] pCodeSize Shader code size, in bytes. If + * \ref pCode is \c nullptr, this will return the total + * code size, otherwise the number of bytes written. + * \param [out] pCode SPIR-V shader code + * \returns \c S_OK, or \c S_FALSE if the buffer was too small + */ + virtual HRESULT STDMETHODCALLTYPE GetSpirvCode( + SIZE_T* pCodeSize, + void* pCode) = 0; +}; + + /** * \brief Extended D3D11 device * @@ -164,11 +184,13 @@ ID3D11VkExtContext1 : public ID3D11VkExtContext { #ifdef _MSC_VER +struct __declspec(uuid("bb8a4fb9-3935-4762-b44b-35189a26414a")) ID3D11VkExtShader; struct __declspec(uuid("8a6e3c42-f74c-45b7-8265-a231b677ca17")) ID3D11VkExtDevice; struct __declspec(uuid("cfcf64ef-9586-46d0-bca4-97cf2ca61b06")) ID3D11VkExtDevice1; struct __declspec(uuid("fd0bca13-5cb6-4c3a-987e-4750de2ca791")) ID3D11VkExtContext; struct __declspec(uuid("874b09b2-ae0b-41d8-8476-5f3b7a0e879d")) ID3D11VkExtContext1; #else +__CRT_UUID_DECL(ID3D11VkExtShader, 0xbb8a4fb9,0x3935,0x4762,0xb4,0x4b,0x35,0x18,0x9a,0x26,0x41,0x4a); __CRT_UUID_DECL(ID3D11VkExtDevice, 0x8a6e3c42,0xf74c,0x45b7,0x82,0x65,0xa2,0x31,0xb6,0x77,0xca,0x17); __CRT_UUID_DECL(ID3D11VkExtDevice1, 0xcfcf64ef,0x9586,0x46d0,0xbc,0xa4,0x97,0xcf,0x2c,0xa6,0x1b,0x06); __CRT_UUID_DECL(ID3D11VkExtContext, 0xfd0bca13,0x5cb6,0x4c3a,0x98,0x7e,0x47,0x50,0xde,0x2c,0xa7,0x91); diff --git a/src/d3d11/d3d11_interop.cpp b/src/d3d11/d3d11_interop.cpp index 8fa50288..04fef383 100644 --- a/src/d3d11/d3d11_interop.cpp +++ b/src/d3d11/d3d11_interop.cpp @@ -75,21 +75,15 @@ namespace dxvk { const VkImageSubresourceRange* pSubresources, VkImageLayout OldLayout, VkImageLayout NewLayout) { - Com deviceContext = nullptr; - m_device->GetImmediateContext(&deviceContext); - - auto immediateContext = static_cast(deviceContext.ptr()); - + auto immediateContext = m_device->GetContext(); + immediateContext->TransitionSurfaceLayout( pSurface, pSubresources, OldLayout, NewLayout); } void STDMETHODCALLTYPE D3D11VkInterop::FlushRenderingCommands() { - Com deviceContext = nullptr; - m_device->GetImmediateContext(&deviceContext); - - auto immediateContext = static_cast(deviceContext.ptr()); + auto immediateContext = m_device->GetContext(); immediateContext->Flush(); immediateContext->SynchronizeCsThread(DxvkCsThread::SynchronizeAll); } diff --git a/src/d3d11/d3d11_main.cpp b/src/d3d11/d3d11_main.cpp index d80d5dec..4bcbec05 100644 --- a/src/d3d11/d3d11_main.cpp +++ b/src/d3d11/d3d11_main.cpp @@ -15,7 +15,7 @@ namespace dxvk { extern "C" { using namespace dxvk; - DLLEXPORT HRESULT __stdcall D3D11CoreCreateDevice( + HRESULT D3D11InternalCreateDevice( IDXGIFactory* pFactory, IDXGIAdapter* pAdapter, UINT Flags, @@ -34,7 +34,7 @@ extern "C" { dxvkAdapter = dxgiVkAdapter->GetDXVKAdapter(); dxvkInstance = dxgiVkAdapter->GetDXVKInstance(); } else { - Logger::warn("D3D11CoreCreateDevice: Adapter is not a DXVK adapter"); + Logger::warn("D3D11InternalCreateDevice: Adapter is not a DXVK adapter"); DXGI_ADAPTER_DESC desc; pAdapter->GetDesc(&desc); @@ -59,40 +59,49 @@ extern "C" { D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1, }; - if (pFeatureLevels == nullptr || FeatureLevels == 0) { + if (!pFeatureLevels || !FeatureLevels) { pFeatureLevels = defaultFeatureLevels.data(); FeatureLevels = defaultFeatureLevels.size(); } // Find the highest feature level supported by the device. // This works because the feature level array is ordered. - UINT flId; + D3D_FEATURE_LEVEL maxFeatureLevel = D3D11Device::GetMaxFeatureLevel(dxvkInstance, dxvkAdapter); + D3D_FEATURE_LEVEL minFeatureLevel = D3D_FEATURE_LEVEL(); + D3D_FEATURE_LEVEL devFeatureLevel = D3D_FEATURE_LEVEL(); - for (flId = 0 ; flId < FeatureLevels; flId++) { - Logger::info(str::format("D3D11CoreCreateDevice: Probing ", pFeatureLevels[flId])); - - if (D3D11Device::CheckFeatureLevelSupport(dxvkInstance, dxvkAdapter, pFeatureLevels[flId])) + Logger::info(str::format("D3D11InternalCreateDevice: Maximum supported feature level: ", maxFeatureLevel)); + + for (uint32_t flId = 0 ; flId < FeatureLevels; flId++) { + minFeatureLevel = pFeatureLevels[flId]; + + if (minFeatureLevel <= maxFeatureLevel) { + devFeatureLevel = minFeatureLevel; break; + } } - - if (flId == FeatureLevels) { - Logger::err("D3D11CoreCreateDevice: Requested feature level not supported"); + + if (!devFeatureLevel) { + Logger::err(str::format("D3D11InternalCreateDevice: Minimum required feature level ", minFeatureLevel, " not supported")); return E_INVALIDARG; } - - // Try to create the device with the given parameters. - const D3D_FEATURE_LEVEL fl = pFeatureLevels[flId]; - + try { - Logger::info(str::format("D3D11CoreCreateDevice: Using feature level ", fl)); + Logger::info(str::format("D3D11InternalCreateDevice: Using feature level ", devFeatureLevel)); + + DxvkDeviceFeatures deviceFeatures = D3D11Device::GetDeviceFeatures(dxvkAdapter); + Rc dxvkDevice = dxvkAdapter->createDevice(dxvkInstance, deviceFeatures); + Com device = new D3D11DXGIDevice( - pAdapter, dxvkInstance, dxvkAdapter, fl, Flags); - + pAdapter, nullptr, nullptr, + dxvkInstance, dxvkAdapter, dxvkDevice, + devFeatureLevel, Flags); + return device->QueryInterface( __uuidof(ID3D11Device), reinterpret_cast(ppDevice)); } catch (const DxvkError& e) { - Logger::err("D3D11CoreCreateDevice: Failed to create D3D11 device"); + Logger::err("D3D11InternalCreateDevice: Failed to create D3D11 device"); return E_FAIL; } } @@ -164,7 +173,7 @@ extern "C" { } // Create the actual device - hr = D3D11CoreCreateDevice( + hr = D3D11InternalCreateDevice( dxgiFactory.ptr(), dxgiAdapter.ptr(), Flags, pFeatureLevels, FeatureLevels, &device); @@ -203,6 +212,25 @@ extern "C" { } + DLLEXPORT HRESULT __stdcall D3D11CoreCreateDevice( + IDXGIFactory* pFactory, + IDXGIAdapter* pAdapter, + D3D_DRIVER_TYPE DriverType, + HMODULE Software, + UINT Flags, + const D3D_FEATURE_LEVEL* pFeatureLevels, + UINT FeatureLevels, + UINT SDKVersion, + ID3D11Device** ppDevice, + D3D_FEATURE_LEVEL* pFeatureLevel) { + return D3D11InternalCreateDeviceAndSwapChain( + pAdapter, DriverType, Software, Flags, + pFeatureLevels, FeatureLevels, SDKVersion, + nullptr, nullptr, + ppDevice, pFeatureLevel, nullptr); + } + + DLLEXPORT HRESULT __stdcall D3D11CreateDevice( IDXGIAdapter* pAdapter, D3D_DRIVER_TYPE DriverType, @@ -254,12 +282,169 @@ extern "C" { ID3D11Device** ppDevice, ID3D11DeviceContext** ppImmediateContext, D3D_FEATURE_LEVEL* pChosenFeatureLevel) { - static bool s_errorShown = false; + InitReturnPtr(ppDevice); + InitReturnPtr(ppImmediateContext); - if (!std::exchange(s_errorShown, true)) - Logger::err("D3D11On12CreateDevice: Not implemented"); + if (pChosenFeatureLevel) + *pChosenFeatureLevel = D3D_FEATURE_LEVEL(0); - return E_NOTIMPL; + if (!pDevice) + return E_INVALIDARG; + + // Figure out D3D12 objects + Com d3d12Device; + Com d3d12Queue; + + if (FAILED(pDevice->QueryInterface(__uuidof(ID3D12Device), reinterpret_cast(&d3d12Device)))) { + Logger::err("D3D11On12CreateDevice: Device is not a valid D3D12 device"); + return E_INVALIDARG; + } + + if (NodeMask & (NodeMask - 1)) { + Logger::err("D3D11On12CreateDevice: Invalid node mask"); + return E_INVALIDARG; + } + + if (!NumQueues || !ppCommandQueues || !ppCommandQueues[0]) { + Logger::err("D3D11On12CreateDevice: No command queue specified"); + return E_INVALIDARG; + } + + if (NumQueues > 1) { + // Not sure what to do with more than one graphics queue + Logger::warn("D3D11On12CreateDevice: Only one queue supported"); + } + + if (FAILED(ppCommandQueues[0]->QueryInterface(__uuidof(ID3D12CommandQueue), reinterpret_cast(&d3d12Queue)))) { + Logger::err("D3D11On12CreateDevice: Queue is not a valid D3D12 command queue"); + return E_INVALIDARG; + } + + // Determine feature level for the D3D11 device + std::array defaultFeatureLevels = {{ + D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_11_1, + D3D_FEATURE_LEVEL_12_0, D3D_FEATURE_LEVEL_12_1, + }}; + + D3D12_FEATURE_DATA_FEATURE_LEVELS featureLevel = { }; + + if (!FeatureLevels || !pFeatureLevels) { + featureLevel.NumFeatureLevels = defaultFeatureLevels.size(); + featureLevel.pFeatureLevelsRequested = defaultFeatureLevels.data(); + } else { + featureLevel.NumFeatureLevels = FeatureLevels; + featureLevel.pFeatureLevelsRequested = pFeatureLevels; + } + + HRESULT hr = d3d12Device->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &featureLevel, sizeof(featureLevel)); + + if (FAILED(hr) || !featureLevel.MaxSupportedFeatureLevel) { + Logger::err(str::format("D3D11On12CreateDevice: Minimum required feature level not supported")); + return hr; + } + + Logger::info(str::format("D3D11On12CreateDevice: Chosen feature level: ", featureLevel.MaxSupportedFeatureLevel)); + + Com interopDevice; + + if (FAILED(d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast(&interopDevice)))) { + Logger::err("D3D11On12CreateDevice: Device not a vkd3d-proton device."); + return E_INVALIDARG; + } + + Com dxgiAdapter; + + if (FAILED(interopDevice->GetDXGIAdapter(IID_PPV_ARGS(&dxgiAdapter)))) { + Logger::err("D3D11On12CreateDevice: Failed to query DXGI adapter."); + return E_INVALIDARG; + } + + try { + // Initialize DXVK instance + DxvkInstanceImportInfo instanceInfo = { }; + DxvkDeviceImportInfo deviceInfo = { }; + VkPhysicalDevice vulkanAdapter = VK_NULL_HANDLE; + + interopDevice->GetVulkanHandles(&instanceInfo.instance, &vulkanAdapter, &deviceInfo.device); + + uint32_t instanceExtensionCount = 0; + interopDevice->GetInstanceExtensions(&instanceExtensionCount, nullptr); + + std::vector instanceExtensions(instanceExtensionCount); + interopDevice->GetInstanceExtensions(&instanceExtensionCount, instanceExtensions.data()); + + instanceInfo.extensionCount = instanceExtensions.size(); + instanceInfo.extensionNames = instanceExtensions.data(); + + Rc dxvkInstance = new DxvkInstance(instanceInfo); + + // Find adapter by physical device handle + Rc dxvkAdapter; + + for (uint32_t i = 0; i < dxvkInstance->adapterCount(); i++) { + Rc curr = dxvkInstance->enumAdapters(i); + + if (curr->handle() == vulkanAdapter) + dxvkAdapter = std::move(curr); + } + + if (dxvkAdapter == nullptr) { + Logger::err("D3D11On12CreateDevice: No matching adapter found"); + return E_INVALIDARG; + } + + interopDevice->GetVulkanQueueInfo(d3d12Queue.ptr(), &deviceInfo.queue, &deviceInfo.queueFamily); + interopDevice->GetDeviceFeatures(&deviceInfo.features); + + uint32_t deviceExtensionCount = 0; + interopDevice->GetDeviceExtensions(&deviceExtensionCount, nullptr); + + std::vector deviceExtensions(deviceExtensionCount); + interopDevice->GetDeviceExtensions(&deviceExtensionCount, deviceExtensions.data()); + + deviceInfo.extensionCount = deviceExtensions.size(); + deviceInfo.extensionNames = deviceExtensions.data(); + + deviceInfo.queueCallback = [ + cDevice = interopDevice, + cQueue = d3d12Queue + ] (bool doLock) { + HRESULT hr = doLock + ? cDevice->LockCommandQueue(cQueue.ptr()) + : cDevice->UnlockCommandQueue(cQueue.ptr()); + + if (FAILED(hr)) + Logger::err(str::format("Failed to lock vkd3d-proton device queue: ", hr)); + }; + + Rc dxvkDevice = dxvkAdapter->importDevice(dxvkInstance, deviceInfo); + + // Create and return the actual D3D11 device + Com device = new D3D11DXGIDevice( + dxgiAdapter.ptr(), d3d12Device.ptr(), d3d12Queue.ptr(), + dxvkInstance, dxvkAdapter, dxvkDevice, + featureLevel.MaxSupportedFeatureLevel, Flags); + + Com d3d11Device; + device->QueryInterface(__uuidof(ID3D11Device), reinterpret_cast(&d3d11Device)); + + if (ppDevice) + *ppDevice = d3d11Device.ref(); + + if (ppImmediateContext) + d3d11Device->GetImmediateContext(ppImmediateContext); + + if (pChosenFeatureLevel) + *pChosenFeatureLevel = d3d11Device->GetFeatureLevel(); + + if (!ppDevice && !ppImmediateContext) + return S_FALSE; + + return S_OK; + } catch (const DxvkError& e) { + Logger::err("D3D11On12CreateDevice: Failed to create D3D11 device"); + return E_FAIL; + } } } \ No newline at end of file diff --git a/src/d3d11/d3d11_on_12.cpp b/src/d3d11/d3d11_on_12.cpp new file mode 100644 index 00000000..7393021c --- /dev/null +++ b/src/d3d11/d3d11_on_12.cpp @@ -0,0 +1,150 @@ +#include "d3d11_context_imm.h" +#include "d3d11_device.h" +#include "d3d11_on_12.h" + +namespace dxvk { + + D3D11on12Device::D3D11on12Device( + D3D11DXGIDevice* pContainer, + D3D11Device* pDevice, + ID3D12Device* pD3D12Device, + ID3D12CommandQueue* pD3D12Queue) + : m_container (pContainer), + m_device (pDevice), + m_d3d12Device (pD3D12Device), + m_d3d12Queue (pD3D12Queue) { + + } + + + D3D11on12Device::~D3D11on12Device() { + + } + + + ULONG STDMETHODCALLTYPE D3D11on12Device::AddRef() { + return m_container->AddRef(); + } + + + ULONG STDMETHODCALLTYPE D3D11on12Device::Release() { + return m_container->Release(); + } + + + HRESULT STDMETHODCALLTYPE D3D11on12Device::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_container->QueryInterface(riid, ppvObject); + } + + + HRESULT STDMETHODCALLTYPE D3D11on12Device::CreateWrappedResource( + IUnknown* pResource12, + const D3D11_RESOURCE_FLAGS* pResourceFlags, + D3D12_RESOURCE_STATES InputState, + D3D12_RESOURCE_STATES OutputState, + REFIID riid, + void** ppResource11) { + Com interopDevice; + m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast(&interopDevice)); + + D3D11_ON_12_RESOURCE_INFO info = { }; + info.InputState = InputState; + info.OutputState = OutputState; + info.IsWrappedResource = TRUE; + + // 11on12 technically allows importing D3D12 heaps as tile pools, + // but we don't support importing sparse resources at this time. + if (FAILED(pResource12->QueryInterface(__uuidof(ID3D12Resource), reinterpret_cast(&info.Resource)))) { + Logger::err("D3D11on12Device::CreateWrappedResource: Resource not a valid D3D12 resource"); + return E_INVALIDARG; + } + + // Query Vulkan resource handle and buffer offset as necessary + if (FAILED(interopDevice->GetVulkanResourceInfo(info.Resource.ptr(), &info.VulkanHandle, &info.VulkanOffset))) { + Logger::err("D3D11on12Device::CreateWrappedResource: Failed to retrieve Vulkan resource info"); + return E_INVALIDARG; + } + + Com resource; + D3D12_RESOURCE_DESC desc = info.Resource->GetDesc(); + + if (desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) { + D3D11_BUFFER_DESC bufferDesc; + + if (FAILED(D3D11Buffer::GetDescFromD3D12(info.Resource.ptr(), pResourceFlags, &bufferDesc))) + return E_INVALIDARG; + + resource = new D3D11Buffer(m_device, &bufferDesc, &info); + } else { + D3D11_COMMON_TEXTURE_DESC textureDesc; + + if (FAILED(D3D11CommonTexture::GetDescFromD3D12(info.Resource.ptr(), pResourceFlags, &textureDesc))) + return E_INVALIDARG; + + switch (desc.Dimension) { + case D3D12_RESOURCE_DIMENSION_TEXTURE1D: + resource = new D3D11Texture1D(m_device, &textureDesc, &info); + break; + + case D3D12_RESOURCE_DIMENSION_TEXTURE2D: + resource = new D3D11Texture2D(m_device, &textureDesc, &info, nullptr); + break; + + case D3D12_RESOURCE_DIMENSION_TEXTURE3D: + resource = new D3D11Texture3D(m_device, &textureDesc, &info); + break; + + default: + Logger::err("D3D11on12Device::CreateWrappedResource: Unhandled resource dimension"); + return E_INVALIDARG; + } + } + + return resource->QueryInterface(riid, ppResource11); + } + + + void STDMETHODCALLTYPE D3D11on12Device::ReleaseWrappedResources( + ID3D11Resource* const* ppResources, + UINT ResourceCount) { + Com interopDevice; + m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast(&interopDevice)); + + for (uint32_t i = 0; i < ResourceCount; i++) { + D3D11_ON_12_RESOURCE_INFO info; + + if (FAILED(GetResource11on12Info(ppResources[i], &info)) || !info.IsWrappedResource) { + Logger::warn("D3D11on12Device::ReleaseWrappedResources: Resource not a wrapped resource, skipping"); + continue; + } + + VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED; + interopDevice->GetVulkanImageLayout(info.Resource.ptr(), info.OutputState, &layout); + m_device->GetContext()->Release11on12Resource(ppResources[i], layout); + } + } + + + void STDMETHODCALLTYPE D3D11on12Device::AcquireWrappedResources( + ID3D11Resource* const* ppResources, + UINT ResourceCount) { + Com interopDevice; + m_d3d12Device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice), reinterpret_cast(&interopDevice)); + + for (uint32_t i = 0; i < ResourceCount; i++) { + D3D11_ON_12_RESOURCE_INFO info; + + if (FAILED(GetResource11on12Info(ppResources[i], &info)) || !info.IsWrappedResource) { + Logger::warn("D3D11on12Device::AcquireWrappedResources: Resource not a wrapped resource, skipping"); + continue; + } + + VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED; + interopDevice->GetVulkanImageLayout(info.Resource.ptr(), info.InputState, &layout); + m_device->GetContext()->Acquire11on12Resource(ppResources[i], layout); + } + } + +} diff --git a/src/d3d11/d3d11_on_12.h b/src/d3d11/d3d11_on_12.h new file mode 100644 index 00000000..9620662b --- /dev/null +++ b/src/d3d11/d3d11_on_12.h @@ -0,0 +1,75 @@ +#pragma once + +#include "d3d11_on_12_interfaces.h" + +#include "../util/log/log.h" + +namespace dxvk { + + class D3D11Device; + class D3D11DXGIDevice; + + /** + * \brief Resource info for 11on12 resources + */ + struct D3D11_ON_12_RESOURCE_INFO { + Com Resource; + UINT64 VulkanHandle = 0; + UINT64 VulkanOffset = 0; + BOOL IsWrappedResource = FALSE; + D3D12_RESOURCE_STATES InputState = D3D12_RESOURCE_STATE_COMMON; + D3D12_RESOURCE_STATES OutputState = D3D12_RESOURCE_STATE_COMMON; + }; + + + class D3D11on12Device : public ID3D11On12Device { + + public: + + D3D11on12Device( + D3D11DXGIDevice* pContainer, + D3D11Device* pDevice, + ID3D12Device* pD3D12Device, + ID3D12CommandQueue* pD3D12Queue); + + ~D3D11on12Device(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + HRESULT STDMETHODCALLTYPE CreateWrappedResource( + IUnknown* pResource12, + const D3D11_RESOURCE_FLAGS* pResourceFlags, + D3D12_RESOURCE_STATES InputState, + D3D12_RESOURCE_STATES OutputState, + REFIID riid, + void** ppResource11); + + void STDMETHODCALLTYPE ReleaseWrappedResources( + ID3D11Resource* const* ppResources, + UINT ResourceCount); + + void STDMETHODCALLTYPE AcquireWrappedResources( + ID3D11Resource* const* ppResources, + UINT ResourceCount); + + bool Is11on12Device() const { + return m_d3d12Device != nullptr; + } + + private: + + D3D11DXGIDevice* m_container; + D3D11Device* m_device; + + Com m_d3d12Device; + Com m_d3d12Queue; + + }; + +} diff --git a/src/d3d11/d3d11_on_12_interfaces.h b/src/d3d11/d3d11_on_12_interfaces.h new file mode 100644 index 00000000..2ec22e0a --- /dev/null +++ b/src/d3d11/d3d11_on_12_interfaces.h @@ -0,0 +1,56 @@ +#pragma once + +#include "../vulkan/vulkan_loader.h" + +#include + +MIDL_INTERFACE("39da4e09-bd1c-4198-9fae-86bbe3be41fd") +ID3D12DXVKInteropDevice : public IUnknown { + virtual HRESULT STDMETHODCALLTYPE GetDXGIAdapter( + REFIID iid, + void** ppvObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInstanceExtensions( + UINT* pExtensionCount, + const char** ppExtensions) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceExtensions( + UINT* pExtensionCount, + const char** ppExtensions) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceFeatures( + const VkPhysicalDeviceFeatures2** ppFeatures) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVulkanHandles( + VkInstance* pVkInstance, + VkPhysicalDevice* pVkPhysicalDevice, + VkDevice* pVkDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVulkanQueueInfo( + ID3D12CommandQueue* pCommandQueue, + VkQueue* pVkQueue, + UINT32* pVkQueueFamily) = 0; + + virtual void STDMETHODCALLTYPE GetVulkanImageLayout( + ID3D12Resource* pResource, + D3D12_RESOURCE_STATES State, + VkImageLayout* pVkLayout) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVulkanResourceInfo( + ID3D12Resource* pResource, + UINT64* pVkHandle, + UINT64* pBufferOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockCommandQueue( + ID3D12CommandQueue* pCommandQueue) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockCommandQueue( + ID3D12CommandQueue* pCommandQueue) = 0; + +}; + +#ifdef _MSC_VER +struct __declspec(uuid("39da4e09-bd1c-4198-9fae-86bbe3be41fd")) ID3D12DXVKInteropDevice; +#else +__CRT_UUID_DECL(ID3D12DXVKInteropDevice, 0x39da4e09, 0xbd1c, 0x4198, 0x9f,0xae, 0x86,0xbb,0xe3,0xbe,0x41,0xfd) +#endif diff --git a/src/d3d11/d3d11_options.cpp b/src/d3d11/d3d11_options.cpp index e78c5198..b1833fd0 100644 --- a/src/d3d11/d3d11_options.cpp +++ b/src/d3d11/d3d11_options.cpp @@ -1,29 +1,40 @@ -#include +#include "../util/util_math.h" #include "d3d11_options.h" namespace dxvk { - D3D11Options::D3D11Options(const Config& config, const Rc& device) { - const DxvkDeviceInfo& devInfo = device->properties(); + static bool IsAPITracingDXGI() { +#ifdef _WIN32 + return !!::GetModuleHandle("dxgitrace.dll"); +#else + return false; +#endif + } + D3D11Options::D3D11Options(const Config& config, const Rc& device) { this->dcSingleUseMode = config.getOption("d3d11.dcSingleUseMode", true); - this->enableRtOutputNanFixup = config.getOption("d3d11.enableRtOutputNanFixup", false); this->zeroInitWorkgroupMemory = config.getOption("d3d11.zeroInitWorkgroupMemory", false); - this->forceTgsmBarriers = config.getOption("d3d11.forceTgsmBarriers", false); + this->forceVolatileTgsmAccess = config.getOption("d3d11.forceVolatileTgsmAccess", false); this->relaxedBarriers = config.getOption("d3d11.relaxedBarriers", false); this->ignoreGraphicsBarriers = config.getOption("d3d11.ignoreGraphicsBarriers", false); this->maxTessFactor = config.getOption("d3d11.maxTessFactor", 0); this->samplerAnisotropy = config.getOption("d3d11.samplerAnisotropy", -1); + this->samplerLodBias = config.getOption("d3d11.samplerLodBias", 0.0f); + this->clampNegativeLodBias = config.getOption("d3d11.clampNegativeLodBias", false); this->invariantPosition = config.getOption("d3d11.invariantPosition", true); this->floatControls = config.getOption("d3d11.floatControls", true); + this->forceSampleRateShading = config.getOption("d3d11.forceSampleRateShading", false); this->disableMsaa = config.getOption("d3d11.disableMsaa", false); + this->enableContextLock = config.getOption("d3d11.enableContextLock", false); this->deferSurfaceCreation = config.getOption("dxgi.deferSurfaceCreation", false); this->numBackBuffers = config.getOption("dxgi.numBackBuffers", 0); this->maxFrameLatency = config.getOption("dxgi.maxFrameLatency", 0); this->maxFrameRate = config.getOption("dxgi.maxFrameRate", 0); this->syncInterval = config.getOption("dxgi.syncInterval", -1); - this->tearFree = config.getOption("dxgi.tearFree", Tristate::Auto); + + // Clamp LOD bias so that people don't abuse this in unintended ways + this->samplerLodBias = dxvk::fclamp(this->samplerLodBias, -2.0f, 1.0f); int32_t maxImplicitDiscardSize = config.getOption("d3d11.maxImplicitDiscardSize", 256); this->maxImplicitDiscardSize = maxImplicitDiscardSize >= 0 @@ -35,12 +46,9 @@ namespace dxvk { ? VkDeviceSize(maxDynamicImageBufferSize) << 10 : VkDeviceSize(~0ull); - this->constantBufferRangeCheck = config.getOption("d3d11.constantBufferRangeCheck", false) - && DxvkGpuVendor(devInfo.core.properties.vendorID) != DxvkGpuVendor::Amd; - auto cachedDynamicResources = config.getOption("d3d11.cachedDynamicResources", std::string()); - if (::GetModuleHandle("dxgitrace.dll")) { + if (IsAPITracingDXGI()) { // apitrace reads back all mapped resources on the CPU, so // allocating everything in cached memory is necessary to // achieve acceptable performance @@ -59,6 +67,9 @@ namespace dxvk { } } } + + // Shader dump path is only available via an environment variable + this->shaderDumpPath = env::getEnvVar("DXVK_SHADER_DUMP_PATH"); } } \ No newline at end of file diff --git a/src/d3d11/d3d11_options.h b/src/d3d11/d3d11_options.h index 99353b30..d7e08008 100644 --- a/src/d3d11/d3d11_options.h +++ b/src/d3d11/d3d11_options.h @@ -20,27 +20,18 @@ namespace dxvk { /// than once. bool dcSingleUseMode; - /// Enables workaround to replace NaN render target - /// outputs with zero - bool enableRtOutputNanFixup; - - /// Enables out-of-bounds access check for constant - /// buffers. Workaround for a few broken games that - /// access random data inside their shaders. - bool constantBufferRangeCheck; - /// Zero-initialize workgroup memory /// /// Workargound for games that don't initialize /// TGSM in compute shaders before reading it. bool zeroInitWorkgroupMemory; - /// Force thread-group shared memory barriers + /// Force thread-group shared memory accesses to be volatile /// /// Workaround for compute shaders that read and /// write from the same shared memory location /// without explicit synchronization. - bool forceTgsmBarriers; + bool forceVolatileTgsmAccess; /// Use relaxed memory barriers /// @@ -66,7 +57,15 @@ namespace dxvk { /// Enforces anisotropic filtering with the /// given anisotropy value for all samplers. int32_t samplerAnisotropy; - + + /// Mipmap LOD bias + /// + /// Enforces the given LOD bias for all samplers. + float samplerLodBias; + + /// Clamps negative LOD bias + bool clampNegativeLodBias; + /// Declare vertex positions in shaders as invariant bool invariantPosition; @@ -81,10 +80,6 @@ namespace dxvk { /// passed to IDXGISwapChain::Present. int32_t syncInterval; - /// Tear-free mode if vsync is disabled - /// Tearing mode if vsync is enabled - Tristate tearFree; - /// Override maximum frame latency if the app specifies /// a higher value. May help with frame timing issues. int32_t maxFrameLatency; @@ -103,6 +98,11 @@ namespace dxvk { /// for a single window that may interfere with each other. bool deferSurfaceCreation; + /// Enables sample rate shading by interpolating fragment shader + /// inputs at the sample location rather than pixel center, + /// unless otherwise specified by the application. + bool forceSampleRateShading; + /// Forces the sample count of all textures to be 1, and /// performs the required shader and resolve fixups. bool disableMsaa; @@ -111,6 +111,14 @@ namespace dxvk { /// in cached system memory. Enabled automatically when recording /// an api trace. uint32_t cachedDynamicResources; + + /// Always lock immediate context on every API call. May be + /// useful for debugging purposes or when applications have + /// race conditions. + bool enableContextLock; + + /// Shader dump path + std::string shaderDumpPath; }; } \ No newline at end of file diff --git a/src/d3d11/d3d11_query.cpp b/src/d3d11/d3d11_query.cpp index b7145739..6629cd56 100644 --- a/src/d3d11/d3d11_query.cpp +++ b/src/d3d11/d3d11_query.cpp @@ -120,8 +120,11 @@ namespace dxvk { } } - Logger::warn("D3D11Query: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11Query), riid)) { + Logger::warn("D3D11Query: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_rasterizer.cpp b/src/d3d11/d3d11_rasterizer.cpp index 6d70847e..0b347a9b 100644 --- a/src/d3d11/d3d11_rasterizer.cpp +++ b/src/d3d11/d3d11_rasterizer.cpp @@ -37,13 +37,23 @@ namespace dxvk { m_state.depthClipEnable = desc.DepthClipEnable; m_state.conservativeMode = DecodeConservativeRasterizationMode(desc.ConservativeRaster); m_state.sampleCount = VkSampleCountFlags(desc.ForcedSampleCount); + m_state.flatShading = VK_FALSE; + m_state.lineMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT; m_depthBias.depthBiasConstant = float(desc.DepthBias); m_depthBias.depthBiasSlope = desc.SlopeScaledDepthBias; m_depthBias.depthBiasClamp = desc.DepthBiasClamp; - if (desc.AntialiasedLineEnable) - Logger::err("D3D11RasterizerState: Antialiased lines not supported"); + // Set up line rasterization mode + const auto& features = device->GetDXVKDevice()->features(); + + if (desc.MultisampleEnable) { + if (features.extLineRasterization.rectangularLines) + m_state.lineMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT; + } else if (desc.AntialiasedLineEnable) { + if (features.extLineRasterization.smoothLines) + m_state.lineMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT; + } } @@ -73,8 +83,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11RasterizerState::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11RasterizerState), riid)) { + Logger::warn("D3D11RasterizerState::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -113,7 +126,7 @@ namespace dxvk { } - void D3D11RasterizerState::BindToContext(const Rc& ctx) { + void D3D11RasterizerState::BindToContext(DxvkContext* ctx) { ctx->setRasterizerState(m_state); if (m_state.depthBiasEnable) diff --git a/src/d3d11/d3d11_rasterizer.h b/src/d3d11/d3d11_rasterizer.h index 7b542f2c..b72e0299 100644 --- a/src/d3d11/d3d11_rasterizer.h +++ b/src/d3d11/d3d11_rasterizer.h @@ -38,8 +38,7 @@ namespace dxvk { return &m_desc; } - void BindToContext( - const Rc& ctx); + void BindToContext(DxvkContext* ctx); D3D10RasterizerState* GetD3D10Iface() { return &m_d3d10; diff --git a/src/d3d11/d3d11_resource.cpp b/src/d3d11/d3d11_resource.cpp index ab8aabe4..92b2d658 100644 --- a/src/d3d11/d3d11_resource.cpp +++ b/src/d3d11/d3d11_resource.cpp @@ -1,14 +1,128 @@ #include "d3d11_buffer.h" #include "d3d11_texture.h" #include "d3d11_resource.h" +#include "d3d11_context_imm.h" +#include "d3d11_device.h" #include "../util/util_shared_res.h" namespace dxvk { + D3D11DXGIKeyedMutex::D3D11DXGIKeyedMutex( + ID3D11Resource* pResource) + : m_resource(pResource) { + Com device; + m_resource->GetDevice(&device); + m_device = static_cast(device.ptr()); + + m_supported = m_device->GetDXVKDevice()->features().khrWin32KeyedMutex + && m_device->GetDXVKDevice()->vkd()->wine_vkAcquireKeyedMutex != nullptr + && m_device->GetDXVKDevice()->vkd()->wine_vkReleaseKeyedMutex != nullptr; + } + + + D3D11DXGIKeyedMutex::~D3D11DXGIKeyedMutex() { + + } + + + ULONG STDMETHODCALLTYPE D3D11DXGIKeyedMutex::AddRef() { + return m_resource->AddRef(); + } + + + ULONG STDMETHODCALLTYPE D3D11DXGIKeyedMutex::Release() { + return m_resource->Release(); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_resource->QueryInterface(riid, ppvObject); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetPrivateData( + REFGUID Name, + UINT* pDataSize, + void* pData) { + return m_resource->GetPrivateData(Name, pDataSize, pData); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::SetPrivateData( + REFGUID Name, + UINT DataSize, + const void* pData) { + return m_resource->SetPrivateData(Name, DataSize, pData); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::SetPrivateDataInterface( + REFGUID Name, + const IUnknown* pUnknown) { + return m_resource->SetPrivateDataInterface(Name, pUnknown); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetParent( + REFIID riid, + void** ppParent) { + return GetDevice(riid, ppParent); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::GetDevice( + REFIID riid, + void** ppDevice) { + Com device; + m_resource->GetDevice(&device); + return device->QueryInterface(riid, ppDevice); + } + + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::AcquireSync( + UINT64 Key, + DWORD dwMilliseconds) { + if (!m_supported) { + if (!m_warned) { + m_warned = true; + Logger::err("D3D11DXGIKeyedMutex::AcquireSync: Not supported"); + } + return S_OK; + } + + D3D11CommonTexture* texture = GetCommonTexture(m_resource); + Rc dxvkDevice = m_device->GetDXVKDevice(); + + VkResult vr = dxvkDevice->vkd()->wine_vkAcquireKeyedMutex(dxvkDevice->handle(), texture->GetImage()->memory().memory(), Key, dwMilliseconds); + switch (vr) { + case VK_SUCCESS: return S_OK; + case VK_TIMEOUT: return WAIT_TIMEOUT; + default: return DXGI_ERROR_INVALID_CALL; + } + } + + HRESULT STDMETHODCALLTYPE D3D11DXGIKeyedMutex::ReleaseSync( + UINT64 Key) { + if (!m_supported) + return S_OK; + + D3D11CommonTexture* texture = GetCommonTexture(m_resource); + Rc dxvkDevice = m_device->GetDXVKDevice(); + + m_device->GetContext()->WaitForResource(texture->GetImage(), DxvkCsThread::SynchronizeAll, D3D11_MAP_READ_WRITE, 0); + + return dxvkDevice->vkd()->wine_vkReleaseKeyedMutex(dxvkDevice->handle(), texture->GetImage()->memory().memory(), Key) == VK_SUCCESS + ? S_OK + : DXGI_ERROR_INVALID_CALL; + } + D3D11DXGIResource::D3D11DXGIResource( ID3D11Resource* pResource) - : m_resource(pResource) { + : m_resource(pResource), + m_keyedMutex(pResource) { } @@ -84,9 +198,15 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D11DXGIResource::GetSharedHandle( HANDLE* pSharedHandle) { auto texture = GetCommonTexture(m_resource); - if (texture == nullptr || pSharedHandle == nullptr || !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED)) + if (texture == nullptr || pSharedHandle == nullptr || + (texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE)) return E_INVALIDARG; + if (!(texture->Desc()->MiscFlags & (D3D11_RESOURCE_MISC_SHARED | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX))) { + *pSharedHandle = NULL; + return S_OK; + } + HANDLE kmtHandle = texture->GetImage()->sharedHandle(); if (kmtHandle == INVALID_HANDLE_VALUE) @@ -143,8 +263,9 @@ namespace dxvk { LPCWSTR lpName, HANDLE* pHandle) { auto texture = GetCommonTexture(m_resource); + if (pHandle) *pHandle = nullptr; if (texture == nullptr || pHandle == nullptr || - !(texture->Desc()->MiscFlags & (D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX | D3D11_RESOURCE_MISC_SHARED_NTHANDLE))) + !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE)) return E_INVALIDARG; if (lpName) @@ -155,9 +276,6 @@ namespace dxvk { if (handle == INVALID_HANDLE_VALUE) return E_INVALIDARG; - if (texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED) - handle = openKmtHandle( handle ); - *pHandle = handle; return S_OK; } @@ -172,6 +290,36 @@ namespace dxvk { } + HRESULT D3D11DXGIResource::GetKeyedMutex( + void **ppvObject) { + auto texture = GetCommonTexture(m_resource); + if (texture == nullptr || !(texture->Desc()->MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX)) + return E_NOINTERFACE; + *ppvObject = ref(&m_keyedMutex); + return S_OK; + } + + + HRESULT GetResource11on12Info( + ID3D11Resource* pResource, + D3D11_ON_12_RESOURCE_INFO* p11on12Info) { + auto buffer = GetCommonBuffer (pResource); + auto texture = GetCommonTexture(pResource); + + if (buffer != nullptr) + *p11on12Info = buffer->Get11on12Info(); + else if (texture != nullptr) + *p11on12Info = texture->Get11on12Info(); + else + return E_INVALIDARG; + + if (p11on12Info->Resource == nullptr) + return E_INVALIDARG; + + return S_OK; + } + + HRESULT GetCommonResourceDesc( ID3D11Resource* pResource, D3D11_COMMON_RESOURCE_DESC* pDesc) { @@ -209,6 +357,17 @@ namespace dxvk { } + Rc GetPagedResource( + ID3D11Resource* pResource) { + auto texture = GetCommonTexture(pResource); + + if (texture) + return texture->GetImage(); + + return static_cast(pResource)->GetBuffer(); + } + + BOOL CheckResourceViewCompatibility( ID3D11Resource* pResource, UINT BindFlags, diff --git a/src/d3d11/d3d11_resource.h b/src/d3d11/d3d11_resource.h index 0fd29f48..8dc73220 100644 --- a/src/d3d11/d3d11_resource.h +++ b/src/d3d11/d3d11_resource.h @@ -22,6 +22,64 @@ namespace dxvk { }; + /** + * \brief IDXGIKeyedMutex implementation + */ + class D3D11DXGIKeyedMutex : public IDXGIKeyedMutex { + + public: + + D3D11DXGIKeyedMutex( + ID3D11Resource* pResource); + + ~D3D11DXGIKeyedMutex(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + HRESULT STDMETHODCALLTYPE GetPrivateData( + REFGUID Name, + UINT* pDataSize, + void* pData); + + HRESULT STDMETHODCALLTYPE SetPrivateData( + REFGUID Name, + UINT DataSize, + const void* pData); + + HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( + REFGUID Name, + const IUnknown* pUnknown); + + HRESULT STDMETHODCALLTYPE GetParent( + REFIID riid, + void** ppParent); + + HRESULT STDMETHODCALLTYPE GetDevice( + REFIID riid, + void** ppDevice); + + HRESULT STDMETHODCALLTYPE AcquireSync( + UINT64 Key, + DWORD dwMilliseconds); + + HRESULT STDMETHODCALLTYPE ReleaseSync( + UINT64 Key); + + private: + + ID3D11Resource* m_resource; + D3D11Device* m_device; + bool m_warned = false; + bool m_supported = false; + }; + + /** * \brief IDXGIResource implementation for D3D11 resources */ @@ -86,13 +144,27 @@ namespace dxvk { UINT index, IDXGISurface2** ppSurface); + HRESULT GetKeyedMutex(void **ppvObject); + private: ID3D11Resource* m_resource; + D3D11DXGIKeyedMutex m_keyedMutex; }; + /** + * \brief Queries D3D11on12 resource info + * + * \param [in] pResource The resource to query + * \param [out] p11on12Info 11on12 info + * \returns \c S_OK on success, or \c E_INVALIDARG + */ + HRESULT GetResource11on12Info( + ID3D11Resource* pResource, + D3D11_ON_12_RESOURCE_INFO* p11on12Info); + /** * \brief Queries common resource description * @@ -103,7 +175,7 @@ namespace dxvk { HRESULT GetCommonResourceDesc( ID3D11Resource* pResource, D3D11_COMMON_RESOURCE_DESC* pDesc); - + /** * \brief Checks whether a format can be used to view a resource * @@ -121,7 +193,16 @@ namespace dxvk { UINT BindFlags, DXGI_FORMAT Format, UINT Plane); - + + /** + * \brief Queries paged resource from resource pointer + * + * \param [in] resource The resource + * \returns Paged resource object + */ + Rc GetPagedResource( + ID3D11Resource* pResource); + /** * \brief Increments private reference count of a resource * @@ -252,4 +333,4 @@ namespace dxvk { }; -} \ No newline at end of file +} diff --git a/src/d3d11/d3d11_sampler.cpp b/src/d3d11/d3d11_sampler.cpp index c8a54af5..15ff92ab 100644 --- a/src/d3d11/d3d11_sampler.cpp +++ b/src/d3d11/d3d11_sampler.cpp @@ -31,18 +31,29 @@ namespace dxvk { info.addressModeV = DecodeAddressMode(desc.AddressV); info.addressModeW = DecodeAddressMode(desc.AddressW); - info.compareToDepth = (filterBits & 0x80) ? VK_TRUE : VK_FALSE; + info.compareToDepth = (filterBits & 0x180) == 0x80 ? VK_TRUE : VK_FALSE; info.compareOp = DecodeCompareOp(desc.ComparisonFunc); - + + info.reductionMode = DecodeReductionMode(filterBits); + for (uint32_t i = 0; i < 4; i++) info.borderColor.float32[i] = desc.BorderColor[i]; info.usePixelCoord = VK_FALSE; // Not supported in D3D11 + info.nonSeamless = VK_FALSE; // Make sure to use a valid anisotropy value if (desc.MaxAnisotropy < 1) info.maxAnisotropy = 1.0f; if (desc.MaxAnisotropy > 16) info.maxAnisotropy = 16.0f; + // Enforce LOD bias specified in the device options + if (info.minFilter == VK_FILTER_LINEAR && info.magFilter == VK_FILTER_LINEAR) { + info.mipmapLodBias += device->GetOptions()->samplerLodBias; + + if (device->GetOptions()->clampNegativeLodBias) + info.mipmapLodBias = std::max(info.mipmapLodBias, 0.0f); + } + // Enforce anisotropy specified in the device options int32_t samplerAnisotropyOption = device->GetOptions()->samplerAnisotropy; @@ -50,7 +61,7 @@ namespace dxvk { info.useAnisotropy = samplerAnisotropyOption > 0; info.maxAnisotropy = float(samplerAnisotropyOption); } - + m_sampler = device->GetDXVKDevice()->createSampler(info); } @@ -79,8 +90,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11SamplerState::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11SamplerState), riid)) { + Logger::warn("D3D11SamplerState::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -93,21 +107,20 @@ namespace dxvk { HRESULT D3D11SamplerState::NormalizeDesc(D3D11_SAMPLER_DESC* pDesc) { const uint32_t filterBits = uint32_t(pDesc->Filter); - if (filterBits & 0xFFFFFF2A) { + if (filterBits & 0xFFFFFE2A) { Logger::err(str::format( "D3D11SamplerState: Unhandled filter: ", filterBits)); return E_INVALIDARG; } - if (pDesc->MaxAnisotropy < 0 - || pDesc->MaxAnisotropy > 16) { + if (pDesc->MaxAnisotropy > 16) { return E_INVALIDARG; } else if ((filterBits & 0x40) == 0 /* not anisotropic */) { // Reset anisotropy if it is not used pDesc->MaxAnisotropy = 0; } - if (filterBits & 0x80 /* compare-to-depth */) { + if ((filterBits & 0x180) == 0x80 /* compare-to-depth */) { if (!ValidateComparisonFunc(pDesc->ComparisonFunc)) return E_INVALIDARG; } else { diff --git a/src/d3d11/d3d11_shader.cpp b/src/d3d11/d3d11_shader.cpp index 800bdea8..3753c075 100644 --- a/src/d3d11/d3d11_shader.cpp +++ b/src/d3d11/d3d11_shader.cpp @@ -20,24 +20,29 @@ namespace dxvk { reinterpret_cast(pShaderBytecode), BytecodeLength); - DxbcModule module(reader); - // If requested by the user, dump both the raw DXBC // shader and the compiled SPIR-V module to a file. - const std::string dumpPath = env::getEnvVar("DXVK_SHADER_DUMP_PATH"); + const std::string& dumpPath = pDevice->GetOptions()->shaderDumpPath; if (dumpPath.size() != 0) { - reader.store(std::ofstream(str::tows(str::format(dumpPath, "/", name, ".dxbc").c_str()).c_str(), + reader.store(std::ofstream(str::topath(str::format(dumpPath, "/", name, ".dxbc").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc)); } - + + // Error out if the shader is invalid + DxbcModule module(reader); + auto programInfo = module.programInfo(); + + if (!programInfo) + throw DxvkError("Invalid shader binary."); + // Decide whether we need to create a pass-through // geometry shader for vertex shader stream output bool passthroughShader = pDxbcModuleInfo->xfb != nullptr - && (module.programInfo().type() == DxbcProgramType::VertexShader - || module.programInfo().type() == DxbcProgramType::DomainShader); + && (programInfo->type() == DxbcProgramType::VertexShader + || programInfo->type() == DxbcProgramType::DomainShader); - if (module.programInfo().shaderStage() != pShaderKey->type() && !passthroughShader) + if (programInfo->shaderStage() != pShaderKey->type() && !passthroughShader) throw DxvkError("Mismatching shader type."); m_shader = passthroughShader @@ -47,7 +52,7 @@ namespace dxvk { if (dumpPath.size() != 0) { std::ofstream dumpStream( - str::tows(str::format(dumpPath, "/", name, ".spv").c_str()).c_str(), + str::topath(str::format(dumpPath, "/", name, ".spv").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc); m_shader->dump(dumpStream); @@ -125,4 +130,60 @@ namespace dxvk { return S_OK; } + + D3D11ExtShader::D3D11ExtShader( + ID3D11DeviceChild* pParent, + D3D11CommonShader* pShader) + : m_parent(pParent), m_shader(pShader) { + + } + + + D3D11ExtShader::~D3D11ExtShader() { + + } + + + ULONG STDMETHODCALLTYPE D3D11ExtShader::AddRef() { + return m_parent->AddRef(); + } + + + ULONG STDMETHODCALLTYPE D3D11ExtShader::Release() { + return m_parent->Release(); + } + + + HRESULT STDMETHODCALLTYPE D3D11ExtShader::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_parent->QueryInterface(riid, ppvObject); + } + + + HRESULT STDMETHODCALLTYPE D3D11ExtShader::GetSpirvCode( + SIZE_T* pCodeSize, + void* pCode) { + auto shader = m_shader->GetShader(); + auto code = shader->getRawCode(); + + HRESULT hr = S_OK; + + if (pCode) { + size_t size = code.size(); + + if (size > *pCodeSize) { + size = *pCodeSize; + hr = S_FALSE; + } + + std::memcpy(pCode, code.data(), size); + *pCodeSize = size; + return hr; + } else { + *pCodeSize = code.size(); + return hr; + } + } + } diff --git a/src/d3d11/d3d11_shader.h b/src/d3d11/d3d11_shader.h index 3ab16854..44a3bcb9 100644 --- a/src/d3d11/d3d11_shader.h +++ b/src/d3d11/d3d11_shader.h @@ -43,8 +43,10 @@ namespace dxvk { return m_shader; } - Rc GetIcb() const { - return m_buffer; + DxvkBufferSlice GetIcb() const { + return m_buffer != nullptr + ? DxvkBufferSlice(m_buffer) + : DxvkBufferSlice(); } std::string GetName() const { @@ -57,8 +59,41 @@ namespace dxvk { Rc m_buffer; }; - - + + + /** + * \brief Extended shader interface + */ + class D3D11ExtShader : public ID3D11VkExtShader { + + public: + + D3D11ExtShader( + ID3D11DeviceChild* pParent, + D3D11CommonShader* pShader); + + ~D3D11ExtShader(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + HRESULT STDMETHODCALLTYPE GetSpirvCode( + SIZE_T* pCodeSize, + void* pCode); + + private: + + ID3D11DeviceChild* m_parent; + D3D11CommonShader* m_shader; + + }; + + /** * \brief Common shader interface * @@ -73,7 +108,7 @@ namespace dxvk { D3D11Shader(D3D11Device* device, const D3D11CommonShader& shader) : D3D11DeviceChild(device), - m_shader(shader), m_d3d10(this) { } + m_shader(shader), m_d3d10(this), m_shaderExt(this, &m_shader) { } ~D3D11Shader() { } @@ -93,8 +128,17 @@ namespace dxvk { *ppvObject = ref(&m_d3d10); return S_OK; } - - Logger::warn("D3D11Shader::QueryInterface: Unknown interface query"); + + if (riid == __uuidof(ID3D11VkExtShader)) { + *ppvObject = ref(&m_shaderExt); + return S_OK; + } + + if (logQueryInterfaceError(__uuidof(D3D11Interface), riid)) { + Logger::warn("D3D11Shader::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -110,6 +154,7 @@ namespace dxvk { D3D11CommonShader m_shader; D3D10ShaderClass m_d3d10; + D3D11ExtShader m_shaderExt; }; diff --git a/src/d3d11/d3d11_state_object.cpp b/src/d3d11/d3d11_state_object.cpp index 33cc8a33..3a8f2d84 100644 --- a/src/d3d11/d3d11_state_object.cpp +++ b/src/d3d11/d3d11_state_object.cpp @@ -29,8 +29,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11DeviceContextState::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3DDeviceContextState), riid)) { + Logger::warn("D3D11DeviceContextState::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_swapchain.cpp b/src/d3d11/d3d11_swapchain.cpp index 56c51a7b..0e823f41 100644 --- a/src/d3d11/d3d11_swapchain.cpp +++ b/src/d3d11/d3d11_swapchain.cpp @@ -2,6 +2,8 @@ #include "d3d11_device.h" #include "d3d11_swapchain.h" +#include "../util/util_win32_compat.h" + namespace dxvk { static uint16_t MapGammaControlPoint(float x) { @@ -10,31 +12,76 @@ namespace dxvk { return uint16_t(65535.0f * x); } + static VkColorSpaceKHR ConvertColorSpace(DXGI_COLOR_SPACE_TYPE colorspace) { + switch (colorspace) { + case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709: return VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + case DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020: return VK_COLOR_SPACE_HDR10_ST2084_EXT; + case DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709: return VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT; + default: + Logger::warn(str::format("DXGI: ConvertColorSpace: Unknown colorspace ", colorspace)); + return VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + } + + static VkXYColorEXT ConvertXYColor(const UINT16 (&dxgiColor)[2]) { + return VkXYColorEXT{ float(dxgiColor[0]) / 50000.0f, float(dxgiColor[1]) / 50000.0f }; + } + + static float ConvertMaxLuminance(UINT dxgiLuminance) { + return float(dxgiLuminance); + } + + static float ConvertMinLuminance(UINT dxgiLuminance) { + return float(dxgiLuminance) * 0.0001f; + } + + static float ConvertLevel(UINT16 dxgiLevel) { + return float(dxgiLevel); + } + + static VkHdrMetadataEXT ConvertHDRMetadata(const DXGI_HDR_METADATA_HDR10& dxgiMetadata) { + VkHdrMetadataEXT vkMetadata = { VK_STRUCTURE_TYPE_HDR_METADATA_EXT }; + vkMetadata.displayPrimaryRed = ConvertXYColor(dxgiMetadata.RedPrimary); + vkMetadata.displayPrimaryGreen = ConvertXYColor(dxgiMetadata.GreenPrimary); + vkMetadata.displayPrimaryBlue = ConvertXYColor(dxgiMetadata.BluePrimary); + vkMetadata.whitePoint = ConvertXYColor(dxgiMetadata.WhitePoint); + vkMetadata.maxLuminance = ConvertMaxLuminance(dxgiMetadata.MaxMasteringLuminance); + vkMetadata.minLuminance = ConvertMinLuminance(dxgiMetadata.MinMasteringLuminance); + vkMetadata.maxContentLightLevel = ConvertLevel(dxgiMetadata.MaxContentLightLevel); + vkMetadata.maxFrameAverageLightLevel = ConvertLevel(dxgiMetadata.MaxFrameAverageLightLevel); + return vkMetadata; + } + D3D11SwapChain::D3D11SwapChain( D3D11DXGIDevice* pContainer, D3D11Device* pDevice, - HWND hWnd, + IDXGIVkSurfaceFactory* pSurfaceFactory, const DXGI_SWAP_CHAIN_DESC1* pDesc) : m_dxgiDevice(pContainer), - m_parent (pDevice), - m_window (hWnd), - m_desc (*pDesc), - m_device (pDevice->GetDXVKDevice()), - m_context (m_device->createContext()), + m_parent(pDevice), + m_surfaceFactory(pSurfaceFactory), + m_desc(*pDesc), + m_device(pDevice->GetDXVKDevice()), + m_context(m_device->createContext(DxvkContextType::Supplementary)), m_frameLatencyCap(pDevice->GetOptions()->maxFrameLatency) { CreateFrameLatencyEvent(); - - if (!pDevice->GetOptions()->deferSurfaceCreation) - CreatePresenter(); - + CreatePresenter(); CreateBackBuffer(); CreateBlitter(); CreateHud(); + + if (!pDevice->GetOptions()->deferSurfaceCreation) + RecreateSwapChain(); } D3D11SwapChain::~D3D11SwapChain() { + // Avoids hanging when in this state, see comment + // in DxvkDevice::~DxvkDevice. + if (this_thread::isInModuleDetachment()) + return; + m_device->waitForSubmission(&m_presentStatus); m_device->waitForIdle(); @@ -51,12 +98,17 @@ namespace dxvk { InitReturnPtr(ppvObject); if (riid == __uuidof(IUnknown) - || riid == __uuidof(IDXGIVkSwapChain)) { + || riid == __uuidof(IDXGIVkSwapChain) + || riid == __uuidof(IDXGIVkSwapChain1)) { *ppvObject = ref(this); return S_OK; } - Logger::warn("D3D11SwapChain::QueryInterface: Unknown interface query"); + if (logQueryInterfaceError(__uuidof(IDXGIVkSwapChain), riid)) { + Logger::warn("D3D11SwapChain::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -108,13 +160,23 @@ namespace dxvk { HANDLE STDMETHODCALLTYPE D3D11SwapChain::GetFrameLatencyEvent() { - return m_frameLatencyEvent; + HANDLE result = nullptr; + HANDLE processHandle = GetCurrentProcess(); + + if (!DuplicateHandle(processHandle, m_frameLatencyEvent, + processHandle, &result, 0, FALSE, DUPLICATE_SAME_ACCESS)) { + Logger::err("DxgiSwapChain::GetFrameLatencyWaitableObject: DuplicateHandle failed"); + return nullptr; + } + + return result; } HRESULT STDMETHODCALLTYPE D3D11SwapChain::ChangeProperties( - const DXGI_SWAP_CHAIN_DESC1* pDesc) { - + const DXGI_SWAP_CHAIN_DESC1* pDesc, + const UINT* pNodeMasks, + IUnknown* const* ppPresentQueues) { m_dirty |= m_desc.Format != pDesc->Format || m_desc.Width != pDesc->Width || m_desc.Height != pDesc->Height @@ -197,20 +259,13 @@ namespace dxvk { if (options->syncInterval >= 0) SyncInterval = options->syncInterval; - if (!(PresentFlags & DXGI_PRESENT_TEST)) { - bool vsync = SyncInterval != 0; - - m_dirty |= vsync != m_vsync; - m_vsync = vsync; - } - - if (m_presenter == nullptr) - CreatePresenter(); + if (!(PresentFlags & DXGI_PRESENT_TEST)) + m_dirty |= m_presenter->setSyncInterval(SyncInterval) != VK_SUCCESS; HRESULT hr = S_OK; if (!m_presenter->hasSwapChain()) { - RecreateSwapChain(m_vsync); + RecreateSwapChain(); m_dirty = false; } @@ -220,76 +275,118 @@ namespace dxvk { if (m_device->getDeviceStatus() != VK_SUCCESS) hr = DXGI_ERROR_DEVICE_RESET; - if ((PresentFlags & DXGI_PRESENT_TEST) || hr != S_OK) + if (PresentFlags & DXGI_PRESENT_TEST) return hr; + if (hr != S_OK) { + SyncFrameLatency(); + return hr; + } + if (std::exchange(m_dirty, false)) - RecreateSwapChain(m_vsync); - + RecreateSwapChain(); + try { - PresentImage(SyncInterval); + hr = PresentImage(SyncInterval); } catch (const DxvkError& e) { Logger::err(e.message()); hr = E_FAIL; } + // Ensure to synchronize and release the frame latency semaphore + // even if presentation failed with STATUS_OCCLUDED, or otherwise + // applications using the semaphore may deadlock. This works because + // we do not increment the frame ID in those situations. + SyncFrameLatency(); return hr; } - void STDMETHODCALLTYPE D3D11SwapChain::NotifyModeChange( - BOOL Windowed, - const DXGI_MODE_DESC* pDisplayMode) { - if (Windowed || !pDisplayMode) { - // Display modes aren't meaningful in windowed mode - m_displayRefreshRate = 0.0; - } else { - DXGI_RATIONAL rate = pDisplayMode->RefreshRate; - m_displayRefreshRate = double(rate.Numerator) / double(rate.Denominator); + UINT STDMETHODCALLTYPE D3D11SwapChain::CheckColorSpaceSupport( + DXGI_COLOR_SPACE_TYPE ColorSpace) { + UINT supportFlags = 0; + + const VkColorSpaceKHR vkColorSpace = ConvertColorSpace(ColorSpace); + if (m_presenter->supportsColorSpace(vkColorSpace)) + supportFlags |= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT; + + return supportFlags; + } + + + HRESULT STDMETHODCALLTYPE D3D11SwapChain::SetColorSpace( + DXGI_COLOR_SPACE_TYPE ColorSpace) { + if (!(CheckColorSpaceSupport(ColorSpace) & DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT)) + return E_INVALIDARG; + + const VkColorSpaceKHR vkColorSpace = ConvertColorSpace(ColorSpace); + m_dirty |= vkColorSpace != m_colorspace; + m_colorspace = vkColorSpace; + + return S_OK; + } + + + HRESULT STDMETHODCALLTYPE D3D11SwapChain::SetHDRMetaData( + const DXGI_VK_HDR_METADATA* pMetaData) { + // For some reason this call always seems to succeed on Windows + if (pMetaData->Type == DXGI_HDR_METADATA_TYPE_HDR10) { + m_hdrMetadata = ConvertHDRMetadata(pMetaData->HDR10); + m_dirtyHdrMetadata = true; } - if (m_presenter != nullptr) - m_presenter->setFrameRateLimiterRefreshRate(m_displayRefreshRate); + return S_OK; + } + + + void STDMETHODCALLTYPE D3D11SwapChain::GetLastPresentCount( + UINT64* pLastPresentCount) { + *pLastPresentCount = UINT64(m_frameId - DXGI_MAX_SWAP_CHAIN_BUFFERS); + } + + + void STDMETHODCALLTYPE D3D11SwapChain::GetFrameStatistics( + DXGI_VK_FRAME_STATISTICS* pFrameStatistics) { + std::lock_guard lock(m_frameStatisticsLock); + *pFrameStatistics = m_frameStatistics; } HRESULT D3D11SwapChain::PresentImage(UINT SyncInterval) { - Com deviceContext = nullptr; - m_parent->GetImmediateContext(&deviceContext); - // Flush pending rendering commands before - auto immediateContext = static_cast(deviceContext.ptr()); + auto immediateContext = m_parent->GetContext(); + immediateContext->EndFrame(); immediateContext->Flush(); - // Bump our frame id. - ++m_frameId; - for (uint32_t i = 0; i < SyncInterval || i < 1; i++) { SynchronizePresent(); if (!m_presenter->hasSwapChain()) - return DXGI_STATUS_OCCLUDED; + return i ? S_OK : DXGI_STATUS_OCCLUDED; // Presentation semaphores and WSI swap chain image - vk::PresenterInfo info = m_presenter->info(); - vk::PresenterSync sync; + PresenterInfo info = m_presenter->info(); + PresenterSync sync; uint32_t imageIndex = 0; VkResult status = m_presenter->acquireNextImage(sync, imageIndex); while (status != VK_SUCCESS && status != VK_SUBOPTIMAL_KHR) { - RecreateSwapChain(m_vsync); + RecreateSwapChain(); if (!m_presenter->hasSwapChain()) - return DXGI_STATUS_OCCLUDED; + return i ? S_OK : DXGI_STATUS_OCCLUDED; info = m_presenter->info(); status = m_presenter->acquireNextImage(sync, imageIndex); } - // Resolve back buffer if it is multisampled. We - // only have to do it only for the first frame. + if (m_hdrMetadata && m_dirtyHdrMetadata) { + m_presenter->setHdrMetadata(*m_hdrMetadata); + m_dirtyHdrMetadata = false; + } + m_context->beginRecording( m_device->createCommandList()); @@ -300,40 +397,45 @@ namespace dxvk { if (m_hud != nullptr) m_hud->render(m_context, info.format, info.imageExtent); - if (i + 1 >= SyncInterval) - m_context->signal(m_frameLatencySignal, m_frameId); - SubmitPresent(immediateContext, sync, i); } - SyncFrameLatency(); return S_OK; } void D3D11SwapChain::SubmitPresent( D3D11ImmediateContext* pContext, - const vk::PresenterSync& Sync, - uint32_t FrameId) { + const PresenterSync& Sync, + uint32_t Repeat) { auto lock = pContext->LockContext(); + // Bump frame ID as necessary + if (!Repeat) + m_frameId += 1; + // Present from CS thread so that we don't // have to synchronize with it first. m_presentStatus.result = VK_NOT_READY; pContext->EmitCs([this, - cFrameId = FrameId, + cRepeat = Repeat, cSync = Sync, cHud = m_hud, + cPresentMode = m_presenter->info().presentMode, + cFrameId = m_frameId, cCommandList = m_context->endRecording() ] (DxvkContext* ctx) { - m_device->submitCommandList(cCommandList, - cSync.acquire, cSync.present); + cCommandList->setWsiSemaphores(cSync); + m_device->submitCommandList(cCommandList, nullptr); - if (cHud != nullptr && !cFrameId) + if (cHud != nullptr && !cRepeat) cHud->update(); - m_device->presentImage(m_presenter, &m_presentStatus); + uint64_t frameId = cRepeat ? 0 : cFrameId; + + m_device->presentImage(m_presenter, + cPresentMode, frameId, &m_presentStatus); }); pContext->FlushCsChunk(); @@ -345,26 +447,39 @@ namespace dxvk { VkResult status = m_device->waitForSubmission(&m_presentStatus); if (status != VK_SUCCESS) - RecreateSwapChain(m_vsync); + RecreateSwapChain(); } - void D3D11SwapChain::RecreateSwapChain(BOOL Vsync) { + void D3D11SwapChain::RecreateSwapChain() { // Ensure that we can safely destroy the swap chain m_device->waitForSubmission(&m_presentStatus); m_device->waitForIdle(); m_presentStatus.result = VK_SUCCESS; + m_dirtyHdrMetadata = true; - vk::PresenterDesc presenterDesc; + PresenterDesc presenterDesc; presenterDesc.imageExtent = { m_desc.Width, m_desc.Height }; presenterDesc.imageCount = PickImageCount(m_desc.BufferCount + 1); presenterDesc.numFormats = PickFormats(m_desc.Format, presenterDesc.formats); - presenterDesc.numPresentModes = PickPresentModes(Vsync, presenterDesc.presentModes); presenterDesc.fullScreenExclusive = PickFullscreenMode(); - if (m_presenter->recreateSwapChain(presenterDesc) != VK_SUCCESS) - throw DxvkError("D3D11SwapChain: Failed to recreate swap chain"); + VkResult vr = m_presenter->recreateSwapChain(presenterDesc); + + if (vr == VK_ERROR_SURFACE_LOST_KHR) { + vr = m_presenter->recreateSurface([this] (VkSurfaceKHR* surface) { + return CreateSurface(surface); + }); + + if (vr) + throw DxvkError(str::format("D3D11SwapChain: Failed to recreate surface: ", vr)); + + vr = m_presenter->recreateSwapChain(presenterDesc); + } + + if (vr) + throw DxvkError(str::format("D3D11SwapChain: Failed to recreate swap chain: ", vr)); CreateRenderTargetViews(); } @@ -379,36 +494,28 @@ namespace dxvk { void D3D11SwapChain::CreatePresenter() { - DxvkDeviceQueue graphicsQueue = m_device->queues().graphics; - - vk::PresenterDevice presenterDevice; - presenterDevice.queueFamily = graphicsQueue.queueFamily; - presenterDevice.queue = graphicsQueue.queueHandle; - presenterDevice.adapter = m_device->adapter()->handle(); - presenterDevice.features.fullScreenExclusive = m_device->extensions().extFullScreenExclusive; - - vk::PresenterDesc presenterDesc; + PresenterDesc presenterDesc; presenterDesc.imageExtent = { m_desc.Width, m_desc.Height }; presenterDesc.imageCount = PickImageCount(m_desc.BufferCount + 1); presenterDesc.numFormats = PickFormats(m_desc.Format, presenterDesc.formats); - presenterDesc.numPresentModes = PickPresentModes(false, presenterDesc.presentModes); presenterDesc.fullScreenExclusive = PickFullscreenMode(); - m_presenter = new vk::Presenter(m_window, - m_device->adapter()->vki(), - m_device->vkd(), - presenterDevice, - presenterDesc); - + m_presenter = new Presenter(m_device, m_frameLatencySignal, presenterDesc); m_presenter->setFrameRateLimit(m_parent->GetOptions()->maxFrameRate); - m_presenter->setFrameRateLimiterRefreshRate(m_displayRefreshRate); + } - CreateRenderTargetViews(); + + VkResult D3D11SwapChain::CreateSurface(VkSurfaceKHR* pSurface) { + Rc adapter = m_device->adapter(); + + return m_surfaceFactory->CreateSurface( + adapter->vki()->instance(), + adapter->handle(), pSurface); } void D3D11SwapChain::CreateRenderTargetViews() { - vk::PresenterInfo info = m_presenter->info(); + PresenterInfo info = m_presenter->info(); m_imageViews.clear(); m_imageViews.resize(info.imageCount); @@ -442,7 +549,8 @@ namespace dxvk { VkImage imageHandle = m_presenter->getImage(i).image; Rc image = new DxvkImage( - m_device.ptr(), imageInfo, imageHandle); + m_device.ptr(), imageInfo, imageHandle, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); m_imageViews[i] = new DxvkImageView( m_device->vkd(), image, viewInfo); @@ -523,8 +631,7 @@ namespace dxvk { m_device->submitCommandList( m_context->endRecording(), - VK_NULL_HANDLE, - VK_NULL_HANDLE); + nullptr); } @@ -550,16 +657,25 @@ namespace dxvk { // Wait for the sync event so that we respect the maximum frame latency m_frameLatencySignal->wait(m_frameId - GetActualFrameLatency()); - if (m_frameLatencyEvent) { - m_frameLatencySignal->setCallback(m_frameId, [cFrameLatencyEvent = m_frameLatencyEvent] () { + m_frameLatencySignal->setCallback(m_frameId, [this, + cFrameId = m_frameId, + cFrameLatencyEvent = m_frameLatencyEvent + ] () { + if (cFrameLatencyEvent) ReleaseSemaphore(cFrameLatencyEvent, 1, nullptr); - }); - } + + std::lock_guard lock(m_frameStatisticsLock); + m_frameStatistics.PresentCount = cFrameId - DXGI_MAX_SWAP_CHAIN_BUFFERS; + m_frameStatistics.PresentQPCTime = dxvk::high_resolution_clock::get_counter(); + }); } uint32_t D3D11SwapChain::GetActualFrameLatency() { - uint32_t maxFrameLatency = m_frameLatency; + // DXGI does not seem to implicitly synchronize waitable swap chains, + // so in that case we should just respect the user config. For regular + // swap chains, pick the latency from the DXGI device. + uint32_t maxFrameLatency = DXGI_MAX_SWAP_CHAIN_BUFFERS; if (!(m_desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)) m_dxgiDevice->GetMaximumFrameLatency(&maxFrameLatency); @@ -567,7 +683,7 @@ namespace dxvk { if (m_frameLatencyCap) maxFrameLatency = std::min(maxFrameLatency, m_frameLatencyCap); - maxFrameLatency = std::min(maxFrameLatency, m_desc.BufferCount + 1); + maxFrameLatency = std::min(maxFrameLatency, m_desc.BufferCount); return maxFrameLatency; } @@ -584,23 +700,23 @@ namespace dxvk { case DXGI_FORMAT_R8G8B8A8_UNORM: case DXGI_FORMAT_B8G8R8A8_UNORM: { - pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; - pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; + pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_UNORM, m_colorspace }; + pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_UNORM, m_colorspace }; } break; case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: { - pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; - pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; + pDstFormats[n++] = { VK_FORMAT_R8G8B8A8_SRGB, m_colorspace }; + pDstFormats[n++] = { VK_FORMAT_B8G8R8A8_SRGB, m_colorspace }; } break; case DXGI_FORMAT_R10G10B10A2_UNORM: { - pDstFormats[n++] = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; - pDstFormats[n++] = { VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; + pDstFormats[n++] = { VK_FORMAT_A2B10G10R10_UNORM_PACK32, m_colorspace }; + pDstFormats[n++] = { VK_FORMAT_A2R10G10B10_UNORM_PACK32, m_colorspace }; } break; case DXGI_FORMAT_R16G16B16A16_FLOAT: { - pDstFormats[n++] = { VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }; + pDstFormats[n++] = { VK_FORMAT_R16G16B16A16_SFLOAT, m_colorspace }; } break; } @@ -608,25 +724,6 @@ namespace dxvk { } - uint32_t D3D11SwapChain::PickPresentModes( - BOOL Vsync, - VkPresentModeKHR* pDstModes) { - uint32_t n = 0; - - if (Vsync) { - if (m_parent->GetOptions()->tearFree == Tristate::False) - pDstModes[n++] = VK_PRESENT_MODE_FIFO_RELAXED_KHR; - pDstModes[n++] = VK_PRESENT_MODE_FIFO_KHR; - } else { - if (m_parent->GetOptions()->tearFree != Tristate::True) - pDstModes[n++] = VK_PRESENT_MODE_IMMEDIATE_KHR; - pDstModes[n++] = VK_PRESENT_MODE_MAILBOX_KHR; - } - - return n; - } - - uint32_t D3D11SwapChain::PickImageCount( UINT Preferred) { int32_t option = m_parent->GetOptions()->numBackBuffers; diff --git a/src/d3d11/d3d11_swapchain.h b/src/d3d11/d3d11_swapchain.h index f4debea1..00073d76 100644 --- a/src/d3d11/d3d11_swapchain.h +++ b/src/d3d11/d3d11_swapchain.h @@ -13,14 +13,14 @@ namespace dxvk { class D3D11Device; class D3D11DXGIDevice; - class D3D11SwapChain : public ComObject { + class D3D11SwapChain : public ComObject { constexpr static uint32_t DefaultFrameLatency = 1; public: D3D11SwapChain( D3D11DXGIDevice* pContainer, D3D11Device* pDevice, - HWND hWnd, + IDXGIVkSurfaceFactory* pSurfaceFactory, const DXGI_SWAP_CHAIN_DESC1* pDesc); ~D3D11SwapChain(); @@ -52,7 +52,9 @@ namespace dxvk { HANDLE STDMETHODCALLTYPE GetFrameLatencyEvent(); HRESULT STDMETHODCALLTYPE ChangeProperties( - const DXGI_SWAP_CHAIN_DESC1* pDesc); + const DXGI_SWAP_CHAIN_DESC1* pDesc, + const UINT* pNodeMasks, + IUnknown* const* ppPresentQueues); HRESULT STDMETHODCALLTYPE SetPresentRegion( const RECT* pRegion); @@ -69,9 +71,20 @@ namespace dxvk { UINT PresentFlags, const DXGI_PRESENT_PARAMETERS* pPresentParameters); - void STDMETHODCALLTYPE NotifyModeChange( - BOOL Windowed, - const DXGI_MODE_DESC* pDisplayMode); + UINT STDMETHODCALLTYPE CheckColorSpaceSupport( + DXGI_COLOR_SPACE_TYPE ColorSpace); + + HRESULT STDMETHODCALLTYPE SetColorSpace( + DXGI_COLOR_SPACE_TYPE ColorSpace); + + HRESULT STDMETHODCALLTYPE SetHDRMetaData( + const DXGI_VK_HDR_METADATA* pMetaData); + + void STDMETHODCALLTYPE GetLastPresentCount( + UINT64* pLastPresentCount); + + void STDMETHODCALLTYPE GetFrameStatistics( + DXGI_VK_FRAME_STATISTICS* pFrameStatistics); private: @@ -83,14 +96,14 @@ namespace dxvk { Com m_dxgiDevice; D3D11Device* m_parent; - HWND m_window; + Com m_surfaceFactory; DXGI_SWAP_CHAIN_DESC1 m_desc; Rc m_device; Rc m_context; - Rc m_presenter; + Rc m_presenter; Rc m_swapImage; Rc m_swapImageView; @@ -110,26 +123,32 @@ namespace dxvk { Rc m_frameLatencySignal; bool m_dirty = true; - bool m_vsync = true; - double m_displayRefreshRate = 0.0; + VkColorSpaceKHR m_colorspace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + + std::optional m_hdrMetadata; + bool m_dirtyHdrMetadata = true; + + dxvk::mutex m_frameStatisticsLock; + DXGI_VK_FRAME_STATISTICS m_frameStatistics = { }; HRESULT PresentImage(UINT SyncInterval); void SubmitPresent( D3D11ImmediateContext* pContext, - const vk::PresenterSync& Sync, - uint32_t FrameId); + const PresenterSync& Sync, + uint32_t Repeat); void SynchronizePresent(); - void RecreateSwapChain( - BOOL Vsync); + void RecreateSwapChain(); void CreateFrameLatencyEvent(); void CreatePresenter(); + VkResult CreateSurface(VkSurfaceKHR* pSurface); + void CreateRenderTargetViews(); void CreateBackBuffer(); @@ -148,10 +167,6 @@ namespace dxvk { DXGI_FORMAT Format, VkSurfaceFormatKHR* pDstFormats); - uint32_t PickPresentModes( - BOOL Vsync, - VkPresentModeKHR* pDstModes); - uint32_t PickImageCount( UINT Preferred); diff --git a/src/d3d11/d3d11_texture.cpp b/src/d3d11/d3d11_texture.cpp index 08b6351d..7a8c6043 100644 --- a/src/d3d11/d3d11_texture.cpp +++ b/src/d3d11/d3d11_texture.cpp @@ -3,6 +3,7 @@ #include "d3d11_texture.h" #include "../util/util_shared_res.h" +#include "../util/util_win32_compat.h" namespace dxvk { @@ -10,11 +11,13 @@ namespace dxvk { ID3D11Resource* pInterface, D3D11Device* pDevice, const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info, D3D11_RESOURCE_DIMENSION Dimension, DXGI_USAGE DxgiUsage, VkImage vkImage, HANDLE hSharedHandle) - : m_interface(pInterface), m_device(pDevice), m_dimension(Dimension), m_desc(*pDesc), m_dxgiUsage(DxgiUsage) { + : m_interface(pInterface), m_device(pDevice), m_dimension(Dimension), m_desc(*pDesc), + m_11on12(p11on12Info ? *p11on12Info : D3D11_ON_12_RESOURCE_INFO()), m_dxgiUsage(DxgiUsage) { DXGI_VK_FORMAT_MODE formatMode = GetFormatMode(); DXGI_VK_FORMAT_INFO formatInfo = m_device->LookupFormat(m_desc.Format, formatMode); DXGI_VK_FORMAT_FAMILY formatFamily = m_device->LookupFamily(m_desc.Format, formatMode); @@ -45,13 +48,22 @@ namespace dxvk { if (hSharedHandle == nullptr) hSharedHandle = INVALID_HANDLE_VALUE; - if (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_NTHANDLE)) { + const auto sharingFlags = D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_NTHANDLE|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX; + + if (m_desc.MiscFlags & sharingFlags) { + if (pDevice->GetFeatureLevel() < D3D_FEATURE_LEVEL_10_0 || + (m_desc.MiscFlags & (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX)) == (D3D11_RESOURCE_MISC_SHARED|D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) || + (m_desc.MiscFlags & sharingFlags) == D3D11_RESOURCE_MISC_SHARED_NTHANDLE) + throw DxvkError(str::format("D3D11: Cannot create shared texture:", + "\n MiscFlags: ", m_desc.MiscFlags, + "\n FeatureLevel: ", pDevice->GetFeatureLevel())); + if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) Logger::warn("D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX: not supported."); imageInfo.shared = true; imageInfo.sharing.mode = hSharedHandle == INVALID_HANDLE_VALUE ? DxvkSharedHandleMode::Export : DxvkSharedHandleMode::Import; - imageInfo.sharing.type = m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE + imageInfo.sharing.type = (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE) ? VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT : VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT; imageInfo.sharing.handle = hSharedHandle; @@ -70,7 +82,7 @@ namespace dxvk { // The image must be marked as mutable if it can be reinterpreted // by a view with a different format. Depth-stencil formats cannot // be reinterpreted in Vulkan, so we'll ignore those. - auto formatProperties = imageFormatInfo(formatInfo.Format); + auto formatProperties = lookupFormatInfo(formatInfo.Format); bool isMutable = formatFamily.FormatCount > 1; bool isMultiPlane = (formatProperties->aspectMask & VK_IMAGE_ASPECT_PLANE_0_BIT) != 0; @@ -135,10 +147,16 @@ namespace dxvk { if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) imageInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; + if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_TILED) { + imageInfo.flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT + | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; + } + if (Dimension == D3D11_RESOURCE_DIMENSION_TEXTURE3D && (m_desc.BindFlags & D3D11_BIND_RENDER_TARGET)) imageInfo.flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; - + // Swap chain back buffers need to be shader readable if (DxgiUsage & DXGI_USAGE_BACK_BUFFER) { imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; @@ -161,6 +179,14 @@ namespace dxvk { if (m_mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) { imageInfo.tiling = VK_IMAGE_TILING_LINEAR; imageInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED; + + if (pDesc->Usage != D3D11_USAGE_DYNAMIC) { + imageInfo.stages |= VK_PIPELINE_STAGE_HOST_BIT; + imageInfo.access |= VK_ACCESS_HOST_READ_BIT; + + if (pDesc->CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) + imageInfo.access |= VK_ACCESS_HOST_WRITE_BIT; + } } // If necessary, create the mapped linear buffer @@ -213,10 +239,13 @@ namespace dxvk { if (m_mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT) memoryProperties = GetMemoryFlags(); - if (vkImage == VK_NULL_HANDLE) + if (m_11on12.Resource != nullptr) + vkImage = VkImage(m_11on12.VulkanHandle); + + if (!vkImage) m_image = m_device->GetDXVKDevice()->createImage(imageInfo, memoryProperties); else - m_image = m_device->GetDXVKDevice()->createImageFromVkImage(imageInfo, vkImage); + m_image = m_device->GetDXVKDevice()->importImage(imageInfo, vkImage, memoryProperties); if (imageInfo.sharing.mode == DxvkSharedHandleMode::Export) ExportImageInfo(); @@ -229,7 +258,7 @@ namespace dxvk { VkDeviceSize D3D11CommonTexture::ComputeMappedOffset(UINT Subresource, UINT Plane, VkOffset3D Offset) const { - auto packedFormatInfo = imageFormatInfo(m_packedFormat); + auto packedFormatInfo = lookupFormatInfo(m_packedFormat); VkImageAspectFlags aspectMask = packedFormatInfo->aspectMask; VkDeviceSize elementSize = packedFormatInfo->elementSize; @@ -281,7 +310,7 @@ namespace dxvk { case D3D11_COMMON_TEXTURE_MAP_MODE_NONE: case D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER: case D3D11_COMMON_TEXTURE_MAP_MODE_STAGING: { - auto packedFormatInfo = imageFormatInfo(m_packedFormat); + auto packedFormatInfo = lookupFormatInfo(m_packedFormat); VkImageAspectFlags aspects = packedFormatInfo->aspectMask; VkExtent3D mipExtent = MipLevelExtent(subresource.mipLevel); @@ -359,7 +388,7 @@ namespace dxvk { if (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) { // Check whether the given combination of image // view type and view format is actually supported - VkFormatFeatureFlags features = GetImageFormatFeatures(BindFlags); + VkFormatFeatureFlags2 features = GetImageFormatFeatures(BindFlags); if (!CheckFormatFeatureSupport(viewFormat.Format, features)) return false; @@ -379,8 +408,8 @@ namespace dxvk { // Otherwise, all bit-compatible formats can be used. if (imageInfo.viewFormatCount == 0 && planeCount == 1) { - auto baseFormatInfo = imageFormatInfo(baseFormat.Format); - auto viewFormatInfo = imageFormatInfo(viewFormat.Format); + auto baseFormatInfo = lookupFormatInfo(baseFormat.Format); + auto viewFormatInfo = lookupFormatInfo(viewFormat.Format); return baseFormatInfo->aspectMask == viewFormatInfo->aspectMask && baseFormatInfo->elementSize == viewFormatInfo->elementSize; @@ -414,10 +443,23 @@ namespace dxvk { != (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET)) return E_INVALIDARG; - // TILE_POOL is invalid, but we don't support TILED either - if (pDesc->MiscFlags & (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED)) + // TILE_POOL is invalid for textures + if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL) return E_INVALIDARG; + // Perform basic validation for tiled resources + if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILED) { + UINT invalidFlags = D3D11_RESOURCE_MISC_SHARED + | D3D11_RESOURCE_MISC_SHARED_NTHANDLE + | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX + | D3D11_RESOURCE_MISC_GDI_COMPATIBLE; + + if ((pDesc->MiscFlags & invalidFlags) + || (pDesc->Usage != D3D11_USAGE_DEFAULT) + || (pDesc->CPUAccessFlags)) + return E_INVALIDARG; + } + // Use the maximum possible mip level count if the supplied // mip level count is either unspecified (0) or invalid const uint32_t maxMipLevelCount = (pDesc->SampleDesc.Count <= 1) @@ -441,80 +483,131 @@ namespace dxvk { } + HRESULT D3D11CommonTexture::GetDescFromD3D12( + ID3D12Resource* pResource, + const D3D11_RESOURCE_FLAGS* pResourceFlags, + D3D11_COMMON_TEXTURE_DESC* pTextureDesc) { + D3D12_RESOURCE_DESC desc12 = pResource->GetDesc(); + + pTextureDesc->Width = desc12.Width; + pTextureDesc->Height = desc12.Height; + + if (desc12.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D) { + pTextureDesc->Depth = desc12.DepthOrArraySize; + pTextureDesc->ArraySize = 1; + } else { + pTextureDesc->Depth = 1; + pTextureDesc->ArraySize = desc12.DepthOrArraySize; + } + + pTextureDesc->MipLevels = desc12.MipLevels; + pTextureDesc->Format = desc12.Format; + pTextureDesc->SampleDesc = desc12.SampleDesc; + pTextureDesc->Usage = D3D11_USAGE_DEFAULT; + pTextureDesc->BindFlags = 0; + pTextureDesc->CPUAccessFlags = 0; + pTextureDesc->MiscFlags = 0; + + if (!(desc12.Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE)) + pTextureDesc->BindFlags |= D3D11_BIND_SHADER_RESOURCE; + + if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) + pTextureDesc->BindFlags |= D3D11_BIND_RENDER_TARGET; + + if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL) + pTextureDesc->BindFlags |= D3D11_BIND_DEPTH_STENCIL; + + if (desc12.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) + pTextureDesc->BindFlags |= D3D11_BIND_UNORDERED_ACCESS; + + if (pResourceFlags) { + pTextureDesc->BindFlags = pResourceFlags->BindFlags; + pTextureDesc->MiscFlags |= pResourceFlags->MiscFlags; + pTextureDesc->CPUAccessFlags = pResourceFlags->CPUAccessFlags; + } + + return S_OK; + } + + BOOL D3D11CommonTexture::CheckImageSupport( const DxvkImageCreateInfo* pImageInfo, VkImageTiling Tiling) const { - const Rc adapter = m_device->GetDXVKDevice()->adapter(); - - VkImageUsageFlags usage = pImageInfo->usage; + // D3D12 images always use optimal tiling + if (m_11on12.Resource != nullptr && Tiling != VK_IMAGE_TILING_OPTIMAL) + return FALSE; + + DxvkFormatQuery formatQuery = { }; + formatQuery.format = pImageInfo->format; + formatQuery.type = pImageInfo->type; + formatQuery.tiling = Tiling; + formatQuery.usage = pImageInfo->usage; + formatQuery.flags = pImageInfo->flags; if (pImageInfo->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT) - usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; + formatQuery.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT; - VkImageFormatProperties formatProps = { }; - VkResult status = adapter->imageFormatProperties( - pImageInfo->format, pImageInfo->type, Tiling, - usage, pImageInfo->flags, formatProps); + auto properties = m_device->GetDXVKDevice()->getFormatLimits(formatQuery); - if (status != VK_SUCCESS) + if (!properties) return FALSE; - - return (pImageInfo->extent.width <= formatProps.maxExtent.width) - && (pImageInfo->extent.height <= formatProps.maxExtent.height) - && (pImageInfo->extent.depth <= formatProps.maxExtent.depth) - && (pImageInfo->numLayers <= formatProps.maxArrayLayers) - && (pImageInfo->mipLevels <= formatProps.maxMipLevels) - && (pImageInfo->sampleCount & formatProps.sampleCounts); + + return (pImageInfo->extent.width <= properties->maxExtent.width) + && (pImageInfo->extent.height <= properties->maxExtent.height) + && (pImageInfo->extent.depth <= properties->maxExtent.depth) + && (pImageInfo->numLayers <= properties->maxArrayLayers) + && (pImageInfo->mipLevels <= properties->maxMipLevels) + && (pImageInfo->sampleCount & properties->sampleCounts); } BOOL D3D11CommonTexture::CheckFormatFeatureSupport( VkFormat Format, - VkFormatFeatureFlags Features) const { - VkFormatProperties properties = m_device->GetDXVKDevice()->adapter()->formatProperties(Format); + VkFormatFeatureFlags2 Features) const { + DxvkFormatFeatures support = m_device->GetDXVKDevice()->getFormatFeatures(Format); - return (properties.linearTilingFeatures & Features) == Features - || (properties.optimalTilingFeatures & Features) == Features; + return (support.linear & Features) == Features + || (support.optimal & Features) == Features; } VkImageUsageFlags D3D11CommonTexture::EnableMetaCopyUsage( VkFormat Format, VkImageTiling Tiling) const { - VkFormatFeatureFlags requestedFeatures = 0; + VkFormatFeatureFlags2 requestedFeatures = 0; if (Format == VK_FORMAT_D16_UNORM || Format == VK_FORMAT_D32_SFLOAT) { - requestedFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT - | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + requestedFeatures |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT + | VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT; } if (Format == VK_FORMAT_R16_UNORM || Format == VK_FORMAT_R32_SFLOAT) { - requestedFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT - | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + requestedFeatures |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT + | VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT; } if (Format == VK_FORMAT_D32_SFLOAT_S8_UINT || Format == VK_FORMAT_D24_UNORM_S8_UINT) - requestedFeatures |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + requestedFeatures |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT; - if (requestedFeatures == 0) + if (!requestedFeatures) return 0; // Enable usage flags for all supported and requested features - VkFormatProperties properties = m_device->GetDXVKDevice()->adapter()->formatProperties(Format); + DxvkFormatFeatures support = m_device->GetDXVKDevice()->getFormatFeatures(Format); requestedFeatures &= Tiling == VK_IMAGE_TILING_OPTIMAL - ? properties.optimalTilingFeatures - : properties.linearTilingFeatures; + ? support.optimal + : support.linear; VkImageUsageFlags requestedUsage = 0; - if (requestedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) + if (requestedFeatures & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT) requestedUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; - if (requestedFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) + if (requestedFeatures & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) requestedUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (requestedFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) + if (requestedFeatures & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT) requestedUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; return requestedUsage; @@ -530,7 +623,7 @@ namespace dxvk { const auto dsMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - auto formatInfo = imageFormatInfo(Format); + auto formatInfo = lookupFormatInfo(Format); return formatInfo->aspectMask == dsMask ? VK_IMAGE_USAGE_SAMPLED_BIT @@ -572,7 +665,7 @@ namespace dxvk { return D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER; // Multi-plane images have a special memory layout in D3D11 - if (imageFormatInfo(pImageInfo->format)->flags.test(DxvkFormatFlag::MultiPlane)) + if (lookupFormatInfo(pImageInfo->format)->flags.test(DxvkFormatFlag::MultiPlane)) return D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER; // If we can't use linear tiling for this image, we have to use a buffer @@ -582,10 +675,18 @@ namespace dxvk { // If supported and requested, create a linear image. Default images // can be used for resolves and other operations regardless of bind // flags, so we need to use a proper image for those. - if (m_desc.TextureLayout == D3D11_TEXTURE_LAYOUT_ROW_MAJOR - || m_desc.Usage == D3D11_USAGE_DEFAULT) + if (m_desc.TextureLayout == D3D11_TEXTURE_LAYOUT_ROW_MAJOR) return D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT; + // For default images, prefer direct mapping if the image is CPU readable + // since mapping for reads would have to stall otherwise. If the image is + // only writable, prefer a write-through buffer. + if (m_desc.Usage == D3D11_USAGE_DEFAULT) { + return (m_desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ) + ? D3D11_COMMON_TEXTURE_MAP_MODE_DIRECT + : D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER; + } + // The overhead of frequently uploading large dynamic images may outweigh // the benefit of linear tiling, so use a linear image in those cases. VkDeviceSize threshold = m_device->GetOptions()->maxDynamicImageBufferSize; @@ -604,10 +705,10 @@ namespace dxvk { void D3D11CommonTexture::ExportImageInfo() { HANDLE hSharedHandle; - if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED) - hSharedHandle = openKmtHandle( m_image->sharedHandle() ); - else + if (m_desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_NTHANDLE) hSharedHandle = m_image->sharedHandle(); + else + hSharedHandle = openKmtHandle( m_image->sharedHandle() ); DxvkSharedTextureMetadata metadata; @@ -644,7 +745,7 @@ namespace dxvk { D3D11CommonTexture::MappedBuffer D3D11CommonTexture::CreateMappedBuffer(UINT MipLevel) const { - const DxvkFormatInfo* formatInfo = imageFormatInfo( + const DxvkFormatInfo* formatInfo = lookupFormatInfo( m_device->LookupPackedFormat(m_desc.Format, GetFormatMode()).Format); DxvkBufferCreateInfo info; @@ -660,7 +761,17 @@ namespace dxvk { | VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT; - + + // We may read mapped buffers even if it is + // marked as CPU write-only on the D3D11 side. + if (m_desc.Usage != D3D11_USAGE_DYNAMIC) { + info.stages |= VK_PIPELINE_STAGE_HOST_BIT; + info.access |= VK_ACCESS_HOST_READ_BIT; + + if (m_desc.CPUAccessFlags & D3D11_CPU_ACCESS_WRITE) + info.access |= VK_ACCESS_HOST_WRITE_BIT; + } + VkMemoryPropertyFlags memType = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; @@ -982,9 +1093,10 @@ namespace dxvk { // D 3 D 1 1 T E X T U R E 1 D D3D11Texture1D::D3D11Texture1D( D3D11Device* pDevice, - const D3D11_COMMON_TEXTURE_DESC* pDesc) + const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info) : D3D11DeviceChild(pDevice), - m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE1D, 0, VK_NULL_HANDLE, nullptr), + m_texture (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE1D, 0, VK_NULL_HANDLE, nullptr), m_interop (this, &m_texture), m_surface (this, &m_texture), m_resource(this), @@ -1034,14 +1146,20 @@ namespace dxvk { *ppvObject = ref(&m_resource); return S_OK; } - + + if (riid == __uuidof(IDXGIKeyedMutex)) + return m_resource.GetKeyedMutex(ppvObject); + if (riid == __uuidof(IDXGIVkInteropSurface)) { *ppvObject = ref(&m_interop); return S_OK; } - Logger::warn("D3D11Texture1D::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D10Texture1D), riid)) { + Logger::warn("D3D11Texture1D::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -1081,9 +1199,10 @@ namespace dxvk { D3D11Texture2D::D3D11Texture2D( D3D11Device* pDevice, const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info, HANDLE hSharedHandle) : D3D11DeviceChild(pDevice), - m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, VK_NULL_HANDLE, hSharedHandle), + m_texture (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, VK_NULL_HANDLE, hSharedHandle), m_interop (this, &m_texture), m_surface (this, &m_texture), m_resource (this), @@ -1098,7 +1217,7 @@ namespace dxvk { DXGI_USAGE DxgiUsage, VkImage vkImage) : D3D11DeviceChild(pDevice), - m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, vkImage, nullptr), + m_texture (this, pDevice, pDesc, nullptr, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, vkImage, nullptr), m_interop (this, &m_texture), m_surface (this, &m_texture), m_resource (this), @@ -1114,7 +1233,7 @@ namespace dxvk { const D3D11_COMMON_TEXTURE_DESC* pDesc, DXGI_USAGE DxgiUsage) : D3D11DeviceChild(pDevice), - m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, VK_NULL_HANDLE, nullptr), + m_texture (this, pDevice, pDesc, nullptr, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DxgiUsage, VK_NULL_HANDLE, nullptr), m_interop (this, &m_texture), m_surface (this, &m_texture), m_resource (this), @@ -1130,27 +1249,24 @@ namespace dxvk { ULONG STDMETHODCALLTYPE D3D11Texture2D::AddRef() { - uint32_t refCount = m_refCount++; + uint32_t refCount = D3D11DeviceChild::AddRef(); - if (unlikely(!refCount)) { - if (m_swapChain) + if (unlikely(m_swapChain != nullptr)) { + if (refCount == 1) m_swapChain->AddRef(); - - AddRefPrivate(); } - return refCount + 1; + return refCount; } ULONG STDMETHODCALLTYPE D3D11Texture2D::Release() { - uint32_t refCount = --m_refCount; + IUnknown* swapChain = m_swapChain; + uint32_t refCount = D3D11DeviceChild::Release(); - if (unlikely(!refCount)) { - if (m_swapChain) - m_swapChain->Release(); - - ReleasePrivate(); + if (unlikely(swapChain != nullptr)) { + if (refCount == 0) + swapChain->Release(); } return refCount; @@ -1194,14 +1310,20 @@ namespace dxvk { *ppvObject = ref(&m_resource); return S_OK; } + + if (riid == __uuidof(IDXGIKeyedMutex)) + return m_resource.GetKeyedMutex(ppvObject); if (riid == __uuidof(IDXGIVkInteropSurface)) { *ppvObject = ref(&m_interop); return S_OK; } - Logger::warn("D3D11Texture2D::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D10Texture2D), riid)) { + Logger::warn("D3D11Texture2D::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -1257,9 +1379,10 @@ namespace dxvk { // D 3 D 1 1 T E X T U R E 3 D D3D11Texture3D::D3D11Texture3D( D3D11Device* pDevice, - const D3D11_COMMON_TEXTURE_DESC* pDesc) + const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info) : D3D11DeviceChild(pDevice), - m_texture (this, pDevice, pDesc, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, VK_NULL_HANDLE, nullptr), + m_texture (this, pDevice, pDesc, p11on12Info, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, VK_NULL_HANDLE, nullptr), m_interop (this, &m_texture), m_resource(this), m_d3d10 (this) { @@ -1301,14 +1424,20 @@ namespace dxvk { *ppvObject = ref(&m_resource); return S_OK; } - + + if (riid == __uuidof(IDXGIKeyedMutex)) + return m_resource.GetKeyedMutex(ppvObject); + if (riid == __uuidof(IDXGIVkInteropSurface)) { *ppvObject = ref(&m_interop); return S_OK; } - Logger::warn("D3D11Texture3D::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D10Texture3D), riid)) { + Logger::warn("D3D11Texture3D::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_texture.h b/src/d3d11/d3d11_texture.h index 2db2bc0c..3708d14f 100644 --- a/src/d3d11/d3d11_texture.h +++ b/src/d3d11/d3d11_texture.h @@ -7,6 +7,7 @@ #include "d3d11_device_child.h" #include "d3d11_interfaces.h" +#include "d3d11_on_12.h" #include "d3d11_resource.h" namespace dxvk { @@ -61,6 +62,15 @@ namespace dxvk { }; + /** + * \brief Region + */ + struct D3D11_COMMON_TEXTURE_REGION { + VkOffset3D Offset; + VkExtent3D Extent; + }; + + /** * \brief D3D11 common texture object * @@ -76,6 +86,7 @@ namespace dxvk { ID3D11Resource* pInterface, D3D11Device* pDevice, const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info, D3D11_RESOURCE_DIMENSION Dimension, DXGI_USAGE DxgiUsage, VkImage vkImage, @@ -256,7 +267,7 @@ namespace dxvk { // For buffer-mapped images we only need to track copies to // and from that buffer, so we can safely ignore bind flags if (m_mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER) - return true; + return m_desc.Usage != D3D11_USAGE_DEFAULT; // Otherwise we can only do accurate tracking if the // image cannot be used in the rendering pipeline. @@ -292,6 +303,72 @@ namespace dxvk { } } + /** + * \brief Adds a dirty region + * + * This region will be updated on Unmap. + * \param [in] Subresource Subresource index + * \param [in] Offset Region offset + * \param [in] Extent Region extent + */ + void AddDirtyRegion(UINT Subresource, VkOffset3D Offset, VkExtent3D Extent) { + D3D11_COMMON_TEXTURE_REGION region; + region.Offset = Offset; + region.Extent = Extent; + + if (Subresource < m_buffers.size()) + m_buffers[Subresource].dirtyRegions.push_back(region); + } + + /** + * \brief Clears dirty regions + * + * Removes all dirty regions from the given subresource. + * \param [in] Subresource Subresource index + */ + void ClearDirtyRegions(UINT Subresource) { + if (Subresource < m_buffers.size()) + m_buffers[Subresource].dirtyRegions.clear(); + } + + /** + * \brief Counts dirty regions + * + * \param [in] Subresource Subresource index + * \returns Dirty region count + */ + UINT GetDirtyRegionCount(UINT Subresource) { + return (Subresource < m_buffers.size()) + ? UINT(m_buffers[Subresource].dirtyRegions.size()) + : UINT(0); + } + + /** + * \brief Queries a dirty regions + * + * \param [in] Subresource Subresource index + * \param [in] Region Region index + * \returns Dirty region + */ + D3D11_COMMON_TEXTURE_REGION GetDirtyRegion(UINT Subresource, UINT Region) { + return m_buffers[Subresource].dirtyRegions[Region]; + } + + /** + * \brief Checks whether or not to track dirty regions + * + * If this returns true, then any functions that update the + * mapped staging buffer must also track dirty regions while + * the image is mapped. Otherwise, the entire image is dirty. + * \returns \c true if dirty regions must be tracked + */ + bool NeedsDirtyRegionTracking() const { + // Only set this for images where Map can't return a pointer + return m_mapMode == D3D11_COMMON_TEXTURE_MAP_MODE_BUFFER + && m_desc.Usage == D3D11_USAGE_DEFAULT + && m_desc.TextureLayout == D3D11_TEXTURE_LAYOUT_UNDEFINED; + } + /** * \brief Computes pixel offset into mapped buffer * @@ -360,6 +437,14 @@ namespace dxvk { DXGI_FORMAT Format, UINT Plane) const; + /** + * \brief Retrieves D3D11on12 resource info + * \returns 11on12 resource info + */ + D3D11_ON_12_RESOURCE_INFO Get11on12Info() const { + return m_11on12; + } + /** * \brief Normalizes and validates texture description * @@ -372,11 +457,26 @@ namespace dxvk { static HRESULT NormalizeTextureProperties( D3D11_COMMON_TEXTURE_DESC* pDesc); + /** + * \brief Initializes D3D11 texture description from D3D12 + * + * \param [in] pResource D3D12 resource + * \param [in] pResourceFlags D3D11 flag overrides + * \param [out] pTextureDesc D3D11 buffer description + * \returns \c S_OK if the parameters are valid + */ + static HRESULT GetDescFromD3D12( + ID3D12Resource* pResource, + const D3D11_RESOURCE_FLAGS* pResourceFlags, + D3D11_COMMON_TEXTURE_DESC* pTextureDesc); + private: struct MappedBuffer { Rc buffer; DxvkBufferSliceHandle slice; + + std::vector dirtyRegions; }; struct MappedInfo { @@ -388,6 +488,7 @@ namespace dxvk { D3D11Device* m_device; D3D11_RESOURCE_DIMENSION m_dimension; D3D11_COMMON_TEXTURE_DESC m_desc; + D3D11_ON_12_RESOURCE_INFO m_11on12; D3D11_COMMON_TEXTURE_MAP_MODE m_mapMode; DXGI_USAGE m_dxgiUsage; VkFormat m_packedFormat; @@ -405,7 +506,7 @@ namespace dxvk { BOOL CheckFormatFeatureSupport( VkFormat Format, - VkFormatFeatureFlags Features) const; + VkFormatFeatureFlags2 Features) const; VkImageUsageFlags EnableMetaCopyUsage( VkFormat Format, @@ -559,7 +660,8 @@ namespace dxvk { D3D11Texture1D( D3D11Device* pDevice, - const D3D11_COMMON_TEXTURE_DESC* pDesc); + const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info); ~D3D11Texture1D(); @@ -605,6 +707,7 @@ namespace dxvk { D3D11Texture2D( D3D11Device* pDevice, const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info, HANDLE hSharedHandle); D3D11Texture2D( @@ -670,7 +773,8 @@ namespace dxvk { D3D11Texture3D( D3D11Device* pDevice, - const D3D11_COMMON_TEXTURE_DESC* pDesc); + const D3D11_COMMON_TEXTURE_DESC* pDesc, + const D3D11_ON_12_RESOURCE_INFO* p11on12Info); ~D3D11Texture3D(); diff --git a/src/d3d11/d3d11_util.cpp b/src/d3d11/d3d11_util.cpp index d4448c54..f8208928 100644 --- a/src/d3d11/d3d11_util.cpp +++ b/src/d3d11/d3d11_util.cpp @@ -64,6 +64,19 @@ namespace dxvk { } + VkSamplerReductionMode DecodeReductionMode( + UINT Filter) { + switch (Filter & 0x180) { + default: + return VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE; + case 0x100: + return VK_SAMPLER_REDUCTION_MODE_MIN; + case 0x180: + return VK_SAMPLER_REDUCTION_MODE_MAX; + } + } + + VkConservativeRasterizationModeEXT DecodeConservativeRasterizationMode( D3D11_CONSERVATIVE_RASTERIZATION_MODE Mode) { switch (Mode) { @@ -78,42 +91,29 @@ namespace dxvk { } - VkShaderStageFlagBits GetShaderStage(DxbcProgramType ProgramType) { - switch (ProgramType) { - case DxbcProgramType::VertexShader: return VK_SHADER_STAGE_VERTEX_BIT; - case DxbcProgramType::HullShader: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; - case DxbcProgramType::DomainShader: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; - case DxbcProgramType::GeometryShader: return VK_SHADER_STAGE_GEOMETRY_BIT; - case DxbcProgramType::PixelShader: return VK_SHADER_STAGE_FRAGMENT_BIT; - case DxbcProgramType::ComputeShader: return VK_SHADER_STAGE_COMPUTE_BIT; - default: return VkShaderStageFlagBits(0); - } - } - - - VkFormatFeatureFlags GetBufferFormatFeatures(UINT BindFlags) { - VkFormatFeatureFlags features = 0; + VkFormatFeatureFlags2 GetBufferFormatFeatures(UINT BindFlags) { + VkFormatFeatureFlags2 features = 0; if (BindFlags & D3D11_BIND_SHADER_RESOURCE) - features |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT; + features |= VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT; if (BindFlags & D3D11_BIND_UNORDERED_ACCESS) - features |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT; + features |= VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT; return features; } - VkFormatFeatureFlags GetImageFormatFeatures(UINT BindFlags) { - VkFormatFeatureFlags features = 0; + VkFormatFeatureFlags2 GetImageFormatFeatures(UINT BindFlags) { + VkFormatFeatureFlags2 features = 0; if (BindFlags & D3D11_BIND_DEPTH_STENCIL) - features |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + features |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT; if (BindFlags & D3D11_BIND_RENDER_TARGET) - features |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + features |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT; if (BindFlags & D3D11_BIND_SHADER_RESOURCE) - features |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + features |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT; if (BindFlags & D3D11_BIND_UNORDERED_ACCESS) - features |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; + features |= VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT; return features; } @@ -138,4 +138,9 @@ namespace dxvk { } } + + BOOL IsMinMaxFilter(D3D11_FILTER Filter) { + return DecodeReductionMode(uint32_t(Filter)) != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE; + } + } \ No newline at end of file diff --git a/src/d3d11/d3d11_util.h b/src/d3d11/d3d11_util.h index 749dc8be..8720bbbb 100644 --- a/src/d3d11/d3d11_util.h +++ b/src/d3d11/d3d11_util.h @@ -21,26 +21,46 @@ namespace dxvk { HRESULT DecodeSampleCount( UINT Count, VkSampleCountFlagBits* pCount); - + VkSamplerAddressMode DecodeAddressMode( D3D11_TEXTURE_ADDRESS_MODE mode); - + VkCompareOp DecodeCompareOp( D3D11_COMPARISON_FUNC Mode); - + + VkSamplerReductionMode DecodeReductionMode( + UINT Filter); + VkConservativeRasterizationModeEXT DecodeConservativeRasterizationMode( D3D11_CONSERVATIVE_RASTERIZATION_MODE Mode); - VkShaderStageFlagBits GetShaderStage( - DxbcProgramType ProgramType); - - VkFormatFeatureFlags GetBufferFormatFeatures( + VkFormatFeatureFlags2 GetBufferFormatFeatures( UINT BindFlags); - VkFormatFeatureFlags GetImageFormatFeatures( + VkFormatFeatureFlags2 GetImageFormatFeatures( UINT BindFlags); VkFormat GetPackedDepthStencilFormat( DXGI_FORMAT Format); + BOOL IsMinMaxFilter(D3D11_FILTER Filter); + + /** + * \brief Translates D3D11 shader stage to corresponding Vulkan stage + * + * \param [in] ProgramType DXBC program type + * \returns Corresponding Vulkan shader stage + */ + constexpr VkShaderStageFlagBits GetShaderStage(DxbcProgramType ProgramType) { + switch (ProgramType) { + case DxbcProgramType::VertexShader: return VK_SHADER_STAGE_VERTEX_BIT; + case DxbcProgramType::HullShader: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; + case DxbcProgramType::DomainShader: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; + case DxbcProgramType::GeometryShader: return VK_SHADER_STAGE_GEOMETRY_BIT; + case DxbcProgramType::PixelShader: return VK_SHADER_STAGE_FRAGMENT_BIT; + case DxbcProgramType::ComputeShader: return VK_SHADER_STAGE_COMPUTE_BIT; + default: return VkShaderStageFlagBits(0); + } + } + } \ No newline at end of file diff --git a/src/d3d11/d3d11_video.cpp b/src/d3d11/d3d11_video.cpp index 9ad9c6a8..3851a498 100644 --- a/src/d3d11/d3d11_video.cpp +++ b/src/d3d11/d3d11_video.cpp @@ -1,6 +1,5 @@ #include -#include "d3d11_context.h" #include "d3d11_context_imm.h" #include "d3d11_video.h" @@ -33,8 +32,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11VideoProcessorEnumerator::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorEnumerator), riid)) { + Logger::warn("D3D11VideoProcessorEnumerator::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -49,23 +51,47 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat( DXGI_FORMAT Format, UINT* pFlags) { - Logger::err("D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat: Stub"); - return E_NOTIMPL; + Logger::err(str::format("D3D11VideoProcessorEnumerator::CheckVideoProcessorFormat: stub, format ", Format)); + + if (!pFlags) + return E_INVALIDARG; + + *pFlags = D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT | D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT; + return S_OK; } HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::GetVideoProcessorCaps( D3D11_VIDEO_PROCESSOR_CAPS* pCaps) { - Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorCaps: Stub"); - return E_NOTIMPL; + Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorCaps: semi-stub"); + + if (!pCaps) + return E_INVALIDARG; + + *pCaps = {}; + pCaps->RateConversionCapsCount = 1; + pCaps->MaxInputStreams = 52; + pCaps->MaxStreamStates = 52; + return S_OK; } HRESULT STDMETHODCALLTYPE D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps( UINT TypeIndex, D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps) { - Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps: Stub"); - return E_NOTIMPL; + Logger::err("D3D11VideoProcessorEnumerator::GetVideoProcessorRateConversionCaps: semi-stub"); + if (!pCaps || TypeIndex) + return E_INVALIDARG; + + *pCaps = {}; + if (m_desc.InputFrameFormat == D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE) { + pCaps->ProcessorCaps = D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION; + } else { + pCaps->ProcessorCaps = D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB; + pCaps->PastFrames = 1; + pCaps->FutureFrames = 1; + } + return S_OK; } @@ -113,8 +139,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11VideoProcessor::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessor), riid)) { + Logger::warn("D3D11VideoProcessor::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -159,7 +188,7 @@ namespace dxvk { DXGI_VK_FORMAT_INFO formatInfo = pDevice->LookupFormat(resourceDesc.Format, DXGI_VK_FORMAT_MODE_COLOR); DXGI_VK_FORMAT_FAMILY formatFamily = pDevice->LookupFamily(resourceDesc.Format, DXGI_VK_FORMAT_MODE_COLOR); - VkImageAspectFlags aspectMask = imageFormatInfo(formatInfo.Format)->aspectMask; + VkImageAspectFlags aspectMask = lookupFormatInfo(formatInfo.Format)->aspectMask; DxvkImageViewCreateInfo viewInfo; viewInfo.format = formatInfo.Format; @@ -175,7 +204,7 @@ namespace dxvk { viewInfo.numLayers = 1; break; - case D3D11_RTV_DIMENSION_UNKNOWN: + case D3D11_VPIV_DIMENSION_UNKNOWN: throw DxvkError("Invalid view dimension"); } @@ -224,8 +253,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11VideoProcessorInputView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorInputView), riid)) { + Logger::warn("D3D11VideoProcessorInputView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -257,7 +289,7 @@ namespace dxvk { DxvkImageViewCreateInfo viewInfo; viewInfo.format = formatInfo.Format; - viewInfo.aspect = imageFormatInfo(viewInfo.format)->aspectMask; + viewInfo.aspect = lookupFormatInfo(viewInfo.format)->aspectMask; viewInfo.swizzle = formatInfo.Swizzle; viewInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; @@ -278,7 +310,7 @@ namespace dxvk { viewInfo.numLayers = m_desc.Texture2DArray.ArraySize; break; - case D3D11_RTV_DIMENSION_UNKNOWN: + case D3D11_VPOV_DIMENSION_UNKNOWN: throw DxvkError("Invalid view dimension"); } @@ -303,8 +335,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11VideoProcessorOutputView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11VideoProcessorOutputView), riid)) { + Logger::warn("D3D11VideoProcessorOutputView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -325,54 +360,8 @@ namespace dxvk { D3D11VideoContext::D3D11VideoContext( D3D11ImmediateContext* pContext, const Rc& Device) - : m_ctx(pContext) { - SpirvCodeBuffer vsCode(d3d11_video_blit_vert); - SpirvCodeBuffer fsCode(d3d11_video_blit_frag); + : m_ctx(pContext), m_device(Device) { - const std::array fsResourceSlots = {{ - { 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC }, - { 1, VK_DESCRIPTOR_TYPE_SAMPLER }, - { 2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_IMAGE_VIEW_TYPE_2D }, - { 3, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_IMAGE_VIEW_TYPE_2D }, - }}; - - DxvkShaderCreateInfo vsInfo; - vsInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; - vsInfo.outputMask = 0x1; - m_vs = new DxvkShader(vsInfo, std::move(vsCode)); - - DxvkShaderCreateInfo fsInfo; - fsInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; - fsInfo.resourceSlotCount = fsResourceSlots.size(); - fsInfo.resourceSlots = fsResourceSlots.data(); - fsInfo.inputMask = 0x1; - fsInfo.outputMask = 0x1; - m_fs = new DxvkShader(fsInfo, std::move(fsCode)); - - DxvkSamplerCreateInfo samplerInfo; - samplerInfo.magFilter = VK_FILTER_LINEAR; - samplerInfo.minFilter = VK_FILTER_LINEAR; - samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; - samplerInfo.mipmapLodBias = 0.0f; - samplerInfo.mipmapLodMin = 0.0f; - samplerInfo.mipmapLodMax = 0.0f; - samplerInfo.useAnisotropy = VK_FALSE; - samplerInfo.maxAnisotropy = 1.0f; - samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; - samplerInfo.compareToDepth = VK_FALSE; - samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS; - samplerInfo.borderColor = VkClearColorValue(); - samplerInfo.usePixelCoord = VK_FALSE; - m_sampler = Device->createSampler(samplerInfo); - - DxvkBufferCreateInfo bufferInfo; - bufferInfo.size = sizeof(UboData); - bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; - bufferInfo.stages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; - bufferInfo.access = VK_ACCESS_UNIFORM_READ_BIT; - m_ubo = Device->createBuffer(bufferInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); } @@ -602,7 +591,9 @@ namespace dxvk { D3D11_VIDEO_PROCESSOR_OUTPUT_RATE Rate, BOOL Repeat, const DXGI_RATIONAL* CustomRate) { - Logger::err("D3D11VideoContext::VideoProcessorSetStreamOutputRate: Stub"); + Logger::err(str::format("D3D11VideoContext::VideoProcessorSetStreamOutputRate: Stub, Rate ", Rate)); + if (CustomRate) + Logger::err(str::format("CustomRate ", CustomRate->Numerator, "/", CustomRate->Denominator)); } @@ -1047,7 +1038,7 @@ namespace dxvk { continue; if (!hasStreamsEnabled) { - m_ctx->ResetState(); + m_ctx->ResetCommandListState(); BindOutputView(pOutputView); hasStreamsEnabled = true; } @@ -1055,8 +1046,10 @@ namespace dxvk { BlitStream(streamState, &pStreams[i]); } - if (hasStreamsEnabled) - m_ctx->RestoreState(); + if (hasStreamsEnabled) { + UnbindResources(); + m_ctx->RestoreCommandListState(); + } return S_OK; } @@ -1196,10 +1189,7 @@ namespace dxvk { rt.color[0].view = cView; rt.color[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - ctx->bindRenderTargets(rt); - ctx->bindShader(VK_SHADER_STAGE_VERTEX_BIT, m_vs); - ctx->bindShader(VK_SHADER_STAGE_FRAGMENT_BIT, m_fs); - ctx->bindResourceBuffer(0, DxvkBufferSlice(m_ubo)); + ctx->bindRenderTargets(std::move(rt), 0u); DxvkInputAssemblyState iaState; iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; @@ -1216,6 +1206,8 @@ namespace dxvk { void D3D11VideoContext::BlitStream( const D3D11VideoProcessorStreamState* pStreamState, const D3D11_VIDEO_PROCESSOR_STREAM* pStream) { + CreateResources(); + if (pStream->PastFrames || pStream->FutureFrames) Logger::err("D3D11VideoContext: Ignoring non-zero PastFrames and FutureFrames"); @@ -1278,6 +1270,7 @@ namespace dxvk { uboData.coordMatrix[1][1] = 1.0f; uboData.yMin = 0.0f; uboData.yMax = 1.0f; + uboData.isPlanar = cViews[1] != nullptr; if (cIsYCbCr) ApplyYCbCrMatrix(uboData.colorMatrix, cStreamState.colorSpace.YCbCr_Matrix); @@ -1292,12 +1285,103 @@ namespace dxvk { ctx->invalidateBuffer(m_ubo, uboSlice); ctx->setViewports(1, &viewport, &scissor); - ctx->bindResourceSampler(1, m_sampler); + + ctx->bindShader(Rc(m_vs)); + ctx->bindShader(Rc(m_fs)); + + ctx->bindUniformBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice(m_ubo)); + ctx->bindResourceSampler(VK_SHADER_STAGE_FRAGMENT_BIT, 1, Rc(m_sampler)); for (uint32_t i = 0; i < cViews.size(); i++) - ctx->bindResourceView(2 + i, cViews[i], nullptr); + ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 2 + i, Rc(cViews[i])); ctx->draw(3, 1, 0, 0); + + ctx->bindResourceSampler(VK_SHADER_STAGE_FRAGMENT_BIT, 1, nullptr); + + for (uint32_t i = 0; i < cViews.size(); i++) + ctx->bindResourceImageView(VK_SHADER_STAGE_FRAGMENT_BIT, 2 + i, nullptr); + }); + } + + + void D3D11VideoContext::CreateUniformBuffer() { + DxvkBufferCreateInfo bufferInfo; + bufferInfo.size = sizeof(UboData); + bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + bufferInfo.stages = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + bufferInfo.access = VK_ACCESS_UNIFORM_READ_BIT; + m_ubo = m_device->createBuffer(bufferInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + } + + + void D3D11VideoContext::CreateSampler() { + DxvkSamplerCreateInfo samplerInfo; + samplerInfo.magFilter = VK_FILTER_LINEAR; + samplerInfo.minFilter = VK_FILTER_LINEAR; + samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST; + samplerInfo.mipmapLodBias = 0.0f; + samplerInfo.mipmapLodMin = 0.0f; + samplerInfo.mipmapLodMax = 0.0f; + samplerInfo.useAnisotropy = VK_FALSE; + samplerInfo.maxAnisotropy = 1.0f; + samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; + samplerInfo.compareToDepth = VK_FALSE; + samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS; + samplerInfo.reductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE; + samplerInfo.borderColor = VkClearColorValue(); + samplerInfo.usePixelCoord = VK_FALSE; + samplerInfo.nonSeamless = VK_FALSE; + m_sampler = m_device->createSampler(samplerInfo); + } + + + void D3D11VideoContext::CreateShaders() { + SpirvCodeBuffer vsCode(d3d11_video_blit_vert); + SpirvCodeBuffer fsCode(d3d11_video_blit_frag); + + const std::array fsBindings = {{ + { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, VK_IMAGE_VIEW_TYPE_MAX_ENUM, VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_UNIFORM_READ_BIT, VK_TRUE }, + { VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_IMAGE_VIEW_TYPE_MAX_ENUM, VK_SHADER_STAGE_FRAGMENT_BIT, 0 }, + { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 2, VK_IMAGE_VIEW_TYPE_2D, VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT }, + { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 3, VK_IMAGE_VIEW_TYPE_2D, VK_SHADER_STAGE_FRAGMENT_BIT, VK_ACCESS_SHADER_READ_BIT }, + }}; + + DxvkShaderCreateInfo vsInfo; + vsInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; + vsInfo.outputMask = 0x1; + m_vs = new DxvkShader(vsInfo, std::move(vsCode)); + + DxvkShaderCreateInfo fsInfo; + fsInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; + fsInfo.bindingCount = fsBindings.size(); + fsInfo.bindings = fsBindings.data(); + fsInfo.inputMask = 0x1; + fsInfo.outputMask = 0x1; + m_fs = new DxvkShader(fsInfo, std::move(fsCode)); + } + + + void D3D11VideoContext::CreateResources() { + if (std::exchange(m_resourcesCreated, true)) + return; + + CreateSampler(); + CreateUniformBuffer(); + CreateShaders(); + } + + + void D3D11VideoContext::UnbindResources() { + m_ctx->EmitCs([] (DxvkContext* ctx) { + ctx->bindRenderTargets(DxvkRenderTargets(), 0u); + + ctx->bindShader(nullptr); + ctx->bindShader(nullptr); + + ctx->bindUniformBuffer(VK_SHADER_STAGE_FRAGMENT_BIT, 0, DxvkBufferSlice()); }); } diff --git a/src/d3d11/d3d11_video.h b/src/d3d11/d3d11_video.h index 85979eb8..30288a58 100644 --- a/src/d3d11/d3d11_video.h +++ b/src/d3d11/d3d11_video.h @@ -134,11 +134,11 @@ namespace dxvk { void STDMETHODCALLTYPE GetDesc( D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc); - const bool IsYCbCr() const { + bool IsYCbCr() const { return m_isYCbCr; } - const bool NeedsCopy() const { + bool NeedsCopy() const { return m_copy != nullptr; } @@ -585,17 +585,21 @@ namespace dxvk { float colorMatrix[3][4]; float coordMatrix[3][2]; float yMin, yMax; + VkBool32 isPlanar; }; - D3D11ImmediateContext* m_ctx; + D3D11ImmediateContext* m_ctx; - Rc m_sampler; - Rc m_vs; - Rc m_fs; - Rc m_ubo; + Rc m_device; + Rc m_vs; + Rc m_fs; + Rc m_sampler; + Rc m_ubo; VkExtent2D m_dstExtent = { 0u, 0u }; + bool m_resourcesCreated = false; + void ApplyColorMatrix(float pDst[3][4], const float pSrc[3][4]); void ApplyYCbCrMatrix(float pColorMatrix[3][4], bool UseBt709); @@ -607,6 +611,16 @@ namespace dxvk { const D3D11VideoProcessorStreamState* pStreamState, const D3D11_VIDEO_PROCESSOR_STREAM* pStream); + void CreateUniformBuffer(); + + void CreateSampler(); + + void CreateShaders(); + + void CreateResources(); + + void UnbindResources(); + }; } diff --git a/src/d3d11/d3d11_view_dsv.cpp b/src/d3d11/d3d11_view_dsv.cpp index f0520c64..c444d864 100644 --- a/src/d3d11/d3d11_view_dsv.cpp +++ b/src/d3d11/d3d11_view_dsv.cpp @@ -19,7 +19,7 @@ namespace dxvk { DxvkImageViewCreateInfo viewInfo; viewInfo.format = pDevice->LookupFormat(pDesc->Format, DXGI_VK_FORMAT_MODE_DEPTH).Format; - viewInfo.aspect = imageFormatInfo(viewInfo.format)->aspectMask; + viewInfo.aspect = lookupFormatInfo(viewInfo.format)->aspectMask; viewInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; switch (pDesc->ViewDimension) { @@ -126,12 +126,15 @@ namespace dxvk { if (riid == __uuidof(ID3D10DeviceChild) || riid == __uuidof(ID3D10View) || riid == __uuidof(ID3D10DepthStencilView)) { - *ppvObject = ref(this); + *ppvObject = ref(&m_d3d10); return S_OK; } - Logger::warn("D3D11DepthStencilView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11DepthStencilView), riid)) { + Logger::warn("D3D11DepthStencilView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_view_dsv.h b/src/d3d11/d3d11_view_dsv.h index 41b6fcb1..de1958fc 100644 --- a/src/d3d11/d3d11_view_dsv.h +++ b/src/d3d11/d3d11_view_dsv.h @@ -66,6 +66,10 @@ namespace dxvk { } } + UINT GetSampleCount() const { + return UINT(m_view->imageInfo().sampleCount); + } + VkImageAspectFlags GetWritableAspectMask() const { VkImageAspectFlags mask = m_view->formatInfo()->aspectMask; if (m_desc.Flags & D3D11_DSV_READ_ONLY_DEPTH) mask &= ~VK_IMAGE_ASPECT_DEPTH_BIT; @@ -73,6 +77,10 @@ namespace dxvk { return mask; } + DXGI_FORMAT GetViewFormat() const { + return m_desc.Format; + } + D3D10DepthStencilView* GetD3D10Iface() { return &m_d3d10; } diff --git a/src/d3d11/d3d11_view_rtv.cpp b/src/d3d11/d3d11_view_rtv.cpp index 86460502..f8b58f90 100644 --- a/src/d3d11/d3d11_view_rtv.cpp +++ b/src/d3d11/d3d11_view_rtv.cpp @@ -24,7 +24,7 @@ namespace dxvk { DxvkImageViewCreateInfo viewInfo; viewInfo.format = formatInfo.Format; - viewInfo.aspect = imageFormatInfo(viewInfo.format)->aspectMask; + viewInfo.aspect = lookupFormatInfo(viewInfo.format)->aspectMask; viewInfo.swizzle = formatInfo.Swizzle; viewInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; @@ -137,12 +137,15 @@ namespace dxvk { if (riid == __uuidof(ID3D10DeviceChild) || riid == __uuidof(ID3D10View) || riid == __uuidof(ID3D10RenderTargetView)) { - *ppvObject = ref(this); + *ppvObject = ref(&m_d3d10); return S_OK; } - Logger::warn("D3D11RenderTargetView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11RenderTargetView), riid)) { + Logger::warn("D3D11RenderTargetView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_view_rtv.h b/src/d3d11/d3d11_view_rtv.h index 080146ec..0be9ff7a 100644 --- a/src/d3d11/d3d11_view_rtv.h +++ b/src/d3d11/d3d11_view_rtv.h @@ -57,6 +57,10 @@ namespace dxvk { : VK_IMAGE_LAYOUT_GENERAL; } + UINT GetSampleCount() const { + return UINT(m_view->imageInfo().sampleCount); + } + D3D10RenderTargetView* GetD3D10Iface() { return &m_d3d10; } diff --git a/src/d3d11/d3d11_view_srv.cpp b/src/d3d11/d3d11_view_srv.cpp index 1c3d4d8d..065e6005 100644 --- a/src/d3d11/d3d11_view_srv.cpp +++ b/src/d3d11/d3d11_view_srv.cpp @@ -58,7 +58,7 @@ namespace dxvk { } else { viewInfo.format = pDevice->LookupFormat(pDesc->Format, DXGI_VK_FORMAT_MODE_COLOR).Format; - const DxvkFormatInfo* formatInfo = imageFormatInfo(viewInfo.format); + const DxvkFormatInfo* formatInfo = lookupFormatInfo(viewInfo.format); viewInfo.rangeOffset = formatInfo->elementSize * bufInfo.FirstElement; viewInfo.rangeLength = formatInfo->elementSize * bufInfo.NumElements; } @@ -205,12 +205,15 @@ namespace dxvk { || riid == __uuidof(ID3D10View) || riid == __uuidof(ID3D10ShaderResourceView) || riid == __uuidof(ID3D10ShaderResourceView1)) { - *ppvObject = ref(this); + *ppvObject = ref(&m_d3d10); return S_OK; } - Logger::warn("D3D11ShaderResourceView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11ShaderResourceView), riid)) { + Logger::warn("D3D11ShaderResourceView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d11/d3d11_view_uav.cpp b/src/d3d11/d3d11_view_uav.cpp index 54f826e7..94faf88d 100644 --- a/src/d3d11/d3d11_view_uav.cpp +++ b/src/d3d11/d3d11_view_uav.cpp @@ -38,13 +38,13 @@ namespace dxvk { } else { viewInfo.format = pDevice->LookupFormat(pDesc->Format, DXGI_VK_FORMAT_MODE_COLOR).Format; - const DxvkFormatInfo* formatInfo = imageFormatInfo(viewInfo.format); + const DxvkFormatInfo* formatInfo = lookupFormatInfo(viewInfo.format); viewInfo.rangeOffset = formatInfo->elementSize * pDesc->Buffer.FirstElement; viewInfo.rangeLength = formatInfo->elementSize * pDesc->Buffer.NumElements; } if (pDesc->Buffer.Flags & (D3D11_BUFFER_UAV_FLAG_APPEND | D3D11_BUFFER_UAV_FLAG_COUNTER)) - m_counterBuffer = CreateCounterBuffer(); + m_counterView = CreateCounterBufferView(); // Populate view info struct m_info.Buffer.Offset = viewInfo.rangeOffset; @@ -59,9 +59,11 @@ namespace dxvk { DxvkImageViewCreateInfo viewInfo; viewInfo.format = formatInfo.Format; viewInfo.aspect = formatInfo.Aspect; - viewInfo.swizzle = formatInfo.Swizzle; viewInfo.usage = VK_IMAGE_USAGE_STORAGE_BIT; - + + if (!util::isIdentityMapping(formatInfo.Swizzle)) + Logger::warn(str::format("UAV format ", pDesc->Format, " has non-identity swizzle, but UAV swizzles are not supported")); + switch (pDesc->ViewDimension) { case D3D11_UAV_DIMENSION_TEXTURE1D: viewInfo.type = VK_IMAGE_VIEW_TYPE_1D; @@ -145,8 +147,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D11UnorderedAccessView::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(ID3D11UnorderedAccessView), riid)) { + Logger::warn("D3D11UnorderedAccessView::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -427,7 +432,7 @@ namespace dxvk { } - Rc D3D11UnorderedAccessView::CreateCounterBuffer() { + Rc D3D11UnorderedAccessView::CreateCounterBufferView() { Rc device = m_parent->GetDXVKDevice(); DxvkBufferCreateInfo info; @@ -441,7 +446,15 @@ namespace dxvk { | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT; - return device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + + Rc buffer = device->createBuffer(info, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + + DxvkBufferViewCreateInfo viewInfo; + viewInfo.format = VK_FORMAT_UNDEFINED; + viewInfo.rangeOffset = 0; + viewInfo.rangeLength = sizeof(uint32_t); + + return device->createBufferView(buffer, viewInfo); } } diff --git a/src/d3d11/d3d11_view_uav.h b/src/d3d11/d3d11_view_uav.h index 3076fe09..c86eba5f 100644 --- a/src/d3d11/d3d11_view_uav.h +++ b/src/d3d11/d3d11_view_uav.h @@ -57,10 +57,8 @@ namespace dxvk { return m_imageView; } - DxvkBufferSlice GetCounterSlice() const { - return m_counterBuffer != nullptr - ? DxvkBufferSlice(m_counterBuffer) - : DxvkBufferSlice(); + Rc GetCounterView() const { + return m_counterView; } static HRESULT GetDescFromResource( @@ -85,9 +83,9 @@ namespace dxvk { D3D11_VK_VIEW_INFO m_info; Rc m_bufferView; Rc m_imageView; - Rc m_counterBuffer; + Rc m_counterView; - Rc CreateCounterBuffer(); + Rc CreateCounterBufferView(); }; diff --git a/src/d3d11/meson.build b/src/d3d11/meson.build index ad35acd8..9b51e6ea 100644 --- a/src/d3d11/meson.build +++ b/src/d3d11/meson.build @@ -2,8 +2,6 @@ d3d11_res = wrc_generator.process('version.rc') dxgi_common_src = [ '../dxgi/dxgi_format.cpp', - '../dxgi/dxgi_monitor.cpp', - '../dxgi/dxgi_swapchain.cpp', ] d3d10_src = [ @@ -37,11 +35,14 @@ d3d11_src = [ 'd3d11_depth_stencil.cpp', 'd3d11_device.cpp', 'd3d11_enums.cpp', + 'd3d11_features.cpp', + 'd3d11_fence.cpp', 'd3d11_gdi.cpp', 'd3d11_initializer.cpp', 'd3d11_input_layout.cpp', 'd3d11_interop.cpp', 'd3d11_main.cpp', + 'd3d11_on_12.cpp', 'd3d11_options.cpp', 'd3d11_query.cpp', 'd3d11_rasterizer.cpp', @@ -65,13 +66,26 @@ d3d11_shaders = files([ 'shaders/d3d11_video_blit_vert.vert', ]) +d3d11_ld_args = [] +d3d11_link_depends = [] + +if platform == 'windows' + d3d11_dxgi_dep = lib_dxgi +else + d3d11_ld_args += [ '-Wl,--version-script', join_paths(meson.current_source_dir(), 'd3d11.sym') ] + d3d11_link_depends += files('d3d11.sym') + d3d11_dxgi_dep = dxgi_dep +endif + d3d11_dll = shared_library('d3d11'+dll_ext, dxgi_common_src + d3d11_src + d3d10_src, glsl_generator.process(d3d11_shaders), d3d11_res, - name_prefix : '', - dependencies : [ lib_dxgi, dxbc_dep, dxvk_dep ], + name_prefix : dxvk_name_prefix, + dependencies : [ d3d11_dxgi_dep, dxbc_dep, dxvk_dep ], include_directories : dxvk_include_path, install : true, vs_module_defs : 'd3d11'+def_spec_ext, + link_args : d3d11_ld_args, + link_depends : [ d3d11_link_depends ], ) d3d11_dep = declare_dependency( diff --git a/src/d3d11/shaders/d3d11_video_blit_frag.frag b/src/d3d11/shaders/d3d11_video_blit_frag.frag index d659176c..ff54aeda 100644 --- a/src/d3d11/shaders/d3d11_video_blit_frag.frag +++ b/src/d3d11/shaders/d3d11_video_blit_frag.frag @@ -1,7 +1,5 @@ #version 450 -layout(constant_id = 3) const bool c_planar = true; - // Can't use matrix types here since even a two-row // matrix will be padded to 16 bytes per column for // absolutely no reason @@ -15,6 +13,7 @@ uniform ubo_t { vec2 coord_matrix_c3; float y_min; float y_max; + bool is_planar; }; layout(location = 0) in vec2 i_texcoord; @@ -37,7 +36,7 @@ void main() { // Fetch source image color vec4 color = vec4(0.0f, 0.0f, 0.0f, 1.0f); - if (c_planar) { + if (is_planar) { color.g = texture(sampler2D(s_inputY, s_sampler), coord).r; color.rb = texture(sampler2D(s_inputCbCr, s_sampler), coord).gr; color.g = clamp((color.g - y_min) / (y_max - y_min), 0.0f, 1.0f); diff --git a/src/d3d9/d3d9.def b/src/d3d9/d3d9.def index 50e2eb08..96ae240f 100644 --- a/src/d3d9/d3d9.def +++ b/src/d3d9/d3d9.def @@ -18,8 +18,13 @@ EXPORTS Direct3D9EnableMaximizedWindowedModeShim @36 - Direct3DCreate9 @ 37 - Direct3DCreate9Ex @ 38 + Direct3DCreate9 @37 + Direct3DCreate9Ex @38 - DXVK_RegisterAnnotation @ 28257 NONAME - DXVK_UnRegisterAnnotation @ 28258 NONAME + DXVK_RegisterAnnotation @28257 NONAME + DXVK_UnRegisterAnnotation @28258 NONAME + + Direct3D9ForceHybridEnumeration @16 NONAME PRIVATE + + Direct3DCreate9On12 @20 + Direct3DCreate9On12Ex @21 diff --git a/src/d3d9/d3d9.sym b/src/d3d9/d3d9.sym new file mode 100644 index 00000000..bbfaee0a --- /dev/null +++ b/src/d3d9/d3d9.sym @@ -0,0 +1,26 @@ +{ + global: + Direct3DCreate9; + Direct3DCreate9Ex; + D3DPERF_BeginEvent; + D3DPERF_EndEvent; + D3DPERF_SetMarker; + D3DPERF_SetRegion; + D3DPERF_QueryRepeatFrame; + D3DPERF_SetOptions; + D3DPERF_GetStatus; + DebugSetMute; + DebugSetLevel; + PSGPError; + PSGPSampleTexture; + Direct3DShaderValidatorCreate9; + Direct3D9EnableMaximizedWindowedModeShim; + DXVK_RegisterAnnotation; + DXVK_UnRegisterAnnotation; + Direct3D9ForceHybridEnumeration; + Direct3DCreate9On12; + Direct3DCreate9On12Ex; + + local: + *; +}; diff --git a/src/d3d9/d3d9_adapter.cpp b/src/d3d9/d3d9_adapter.cpp index d86da523..44b631a4 100644 --- a/src/d3d9/d3d9_adapter.cpp +++ b/src/d3d9/d3d9_adapter.cpp @@ -8,6 +8,9 @@ #include "../util/util_bit.h" #include "../util/util_luid.h" #include "../util/util_ratio.h" +#include "../util/util_string.h" + +#include "../wsi/wsi_monitor.h" #include @@ -59,15 +62,15 @@ namespace dxvk { const auto& props = m_adapter->deviceProperties(); - DISPLAY_DEVICEA device = { }; - device.cb = sizeof(device); - - if (!::EnumDisplayDevicesA(nullptr, m_displayIndex, &device, 0)) { - Logger::err("D3D9Adapter::GetAdapterIdentifier: Failed to query display info"); + WCHAR wideDisplayName[32] = { }; + if (!wsi::getDisplayName(wsi::getDefaultMonitor(), wideDisplayName)) { + Logger::err("D3D9Adapter::GetAdapterIdentifier: Failed to query monitor info"); return D3DERR_INVALIDCALL; } - GUID guid = bit::cast(m_adapter->devicePropertiesExt().coreDeviceId.deviceUUID); + std::string displayName = str::fromws(wideDisplayName); + + GUID guid = bit::cast(m_adapter->devicePropertiesExt().vk11.deviceUUID); uint32_t vendorId = options.customVendorId == -1 ? props.vendorID : uint32_t(options.customVendorId); uint32_t deviceId = options.customDeviceId == -1 ? props.deviceID : uint32_t(options.customDeviceId); @@ -75,7 +78,7 @@ namespace dxvk { const char* driver = GetDriverDLL(DxvkGpuVendor(vendorId)); copyToStringArray(pIdentifier->Description, desc); - copyToStringArray(pIdentifier->DeviceName, device.DeviceName); // The GDI device name. Not the actual device name. + copyToStringArray(pIdentifier->DeviceName, displayName.c_str()); // The GDI device name. Not the actual device name. copyToStringArray(pIdentifier->Driver, driver); // This is the driver's dll. pIdentifier->DeviceIdentifier = guid; @@ -183,7 +186,8 @@ namespace dxvk { if (MultiSampleType != D3DMULTISAMPLE_NONE && (SurfaceFormat == D3D9Format::D32_LOCKABLE || SurfaceFormat == D3D9Format::D32F_LOCKABLE - || SurfaceFormat == D3D9Format::D16_LOCKABLE)) + || SurfaceFormat == D3D9Format::D16_LOCKABLE + || SurfaceFormat == D3D9Format::INTZ)) return D3DERR_NOTAVAILABLE; uint32_t sampleCount = std::max(MultiSampleType, 1u); @@ -195,9 +199,8 @@ namespace dxvk { // Therefore... VkSampleCountFlags sampleFlags = VkSampleCountFlags(sampleCount); - auto availableFlags = !IsDepthFormat(SurfaceFormat) - ? m_adapter->deviceProperties().limits.framebufferColorSampleCounts - : m_adapter->deviceProperties().limits.framebufferDepthSampleCounts; + auto availableFlags = m_adapter->deviceProperties().limits.framebufferColorSampleCounts + & m_adapter->deviceProperties().limits.framebufferDepthSampleCounts; if (!(availableFlags & sampleFlags)) return D3DERR_NOTAVAILABLE; @@ -236,7 +239,8 @@ namespace dxvk { D3DDEVTYPE DeviceType, D3D9Format SourceFormat, D3D9Format TargetFormat) { - bool sourceSupported = IsSupportedBackBufferFormat(D3D9Format::Unknown, SourceFormat, TRUE); + bool sourceSupported = SourceFormat != D3D9Format::Unknown + && IsSupportedBackBufferFormat(SourceFormat); bool targetSupported = TargetFormat == D3D9Format::X1R5G5B5 || TargetFormat == D3D9Format::A1R5G5B5 || TargetFormat == D3D9Format::R5G6B5 @@ -525,7 +529,7 @@ namespace dxvk { // Max Vertex Blend Matrices pCaps->MaxVertexBlendMatrices = 4; // Max Vertex Blend Matrix Index - pCaps->MaxVertexBlendMatrixIndex = 8; + pCaps->MaxVertexBlendMatrixIndex = 0; // Max Point Size pCaps->MaxPointSize = 256.0f; // Max Primitive Count @@ -621,7 +625,7 @@ namespace dxvk { HMONITOR D3D9Adapter::GetMonitor() { - return GetDefaultMonitor(); + return wsi::getDefaultMonitor(); } @@ -680,20 +684,14 @@ namespace dxvk { if (pRotation != nullptr) *pRotation = D3DDISPLAYROTATION_IDENTITY; - DEVMODEW devMode = DEVMODEW(); - devMode.dmSize = sizeof(devMode); + wsi::WsiMode mode = { }; - if (!GetMonitorDisplayMode(GetDefaultMonitor(), ENUM_CURRENT_SETTINGS, &devMode)) { + if (!wsi::getCurrentDisplayMode(wsi::getDefaultMonitor(), &mode)) { Logger::err("D3D9Adapter::GetAdapterDisplayModeEx: Failed to enum display settings"); return D3DERR_INVALIDCALL; } - pMode->Size = sizeof(D3DDISPLAYMODEEX); - pMode->Width = devMode.dmPelsWidth; - pMode->Height = devMode.dmPelsHeight; - pMode->RefreshRate = devMode.dmDisplayFrequency; - pMode->Format = D3DFMT_X8R8G8B8; - pMode->ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE; + *pMode = ConvertDisplayMode(mode); return D3D_OK; } @@ -702,10 +700,10 @@ namespace dxvk { if (pLUID == nullptr) return D3DERR_INVALIDCALL; - auto& deviceId = m_adapter->devicePropertiesExt().coreDeviceId; + auto& vk11 = m_adapter->devicePropertiesExt().vk11; - if (deviceId.deviceLUIDValid) - *pLUID = bit::cast(deviceId.deviceLUID); + if (vk11.deviceLUIDValid) + *pLUID = bit::cast(vk11.deviceLUID); else *pLUID = dxvk::GetAdapterLUID(m_ordinal); @@ -717,32 +715,32 @@ namespace dxvk { VkFormat Format, DWORD Usage, D3DRESOURCETYPE RType) { - VkFormatFeatureFlags checkFlags = 0; + VkFormatFeatureFlags2 checkFlags = 0; if (RType != D3DRTYPE_SURFACE) - checkFlags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + checkFlags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT; if (Usage & D3DUSAGE_RENDERTARGET) { - checkFlags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + checkFlags |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT; if (Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) - checkFlags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; + checkFlags |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT; } if (Usage & D3DUSAGE_DEPTHSTENCIL) - checkFlags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + checkFlags |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT; else - checkFlags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + checkFlags |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT; - VkFormatFeatureFlags checkFlagsMipGen = checkFlags; + VkFormatFeatureFlags2 checkFlagsMipGen = checkFlags; if (Usage & D3DUSAGE_AUTOGENMIPMAP) { - checkFlagsMipGen |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - checkFlagsMipGen |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + checkFlagsMipGen |= VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT; + checkFlagsMipGen |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT; } - VkFormatProperties fmtSupport = m_adapter->formatProperties(Format); - VkFormatFeatureFlags imgFeatures = fmtSupport.optimalTilingFeatures | fmtSupport.linearTilingFeatures; + DxvkFormatFeatures fmtSupport = m_adapter->getFormatFeatures(Format); + VkFormatFeatureFlags2 imgFeatures = fmtSupport.optimal | fmtSupport.linear; if ((imgFeatures & checkFlags) != checkFlags) return D3DERR_NOTAVAILABLE; @@ -768,32 +766,27 @@ namespace dxvk { // Walk over all modes that the display supports and // return those that match the requested format etc. - DEVMODEW devMode = { }; - devMode.dmSize = sizeof(DEVMODEW); + wsi::WsiMode devMode = { }; uint32_t modeIndex = 0; const auto forcedRatio = Ratio(options.forceAspectRatio); - while (GetMonitorDisplayMode(GetDefaultMonitor(), modeIndex++, &devMode)) { + while (wsi::getDisplayMode(wsi::getDefaultMonitor(), modeIndex++, &devMode)) { // Skip interlaced modes altogether - if (devMode.dmDisplayFlags & DM_INTERLACED) + if (devMode.interlaced) continue; // Skip modes with incompatible formats - if (devMode.dmBitsPerPel != GetMonitorFormatBpp(Format)) + if (devMode.bitsPerPixel != GetMonitorFormatBpp(Format)) continue; - if (!forcedRatio.undefined() && Ratio(devMode.dmPelsWidth, devMode.dmPelsHeight) != forcedRatio) + if (!forcedRatio.undefined() && Ratio(devMode.width, devMode.height) != forcedRatio) continue; - D3DDISPLAYMODEEX mode; - mode.Size = sizeof(D3DDISPLAYMODEEX); - mode.Width = devMode.dmPelsWidth; - mode.Height = devMode.dmPelsHeight; - mode.RefreshRate = devMode.dmDisplayFrequency; - mode.Format = static_cast(Format); - mode.ScanLineOrdering = D3DSCANLINEORDERING_PROGRESSIVE; + D3DDISPLAYMODEEX mode = ConvertDisplayMode(devMode); + // Fix up the D3DFORMAT to match what we are enumerating + mode.Format = static_cast(Format); m_modes.push_back(mode); } diff --git a/src/d3d9/d3d9_annotation.h b/src/d3d9/d3d9_annotation.h index 1fdb19fc..8ae3eca3 100644 --- a/src/d3d9/d3d9_annotation.h +++ b/src/d3d9/d3d9_annotation.h @@ -2,8 +2,11 @@ #include "d3d9_device.h" #include "d3d9_include.h" + #include "../dxvk/dxvk_annotation.h" +#include "../util/thread.h" + #include #include #include @@ -43,7 +46,7 @@ namespace dxvk { std::atomic m_shouldAnnotate; - std::mutex m_mutex; + dxvk::mutex m_mutex; std::vector m_annotations; // Provide our own event depth as we diff --git a/src/d3d9/d3d9_bridge.cpp b/src/d3d9/d3d9_bridge.cpp new file mode 100644 index 00000000..88448ba9 --- /dev/null +++ b/src/d3d9/d3d9_bridge.cpp @@ -0,0 +1,107 @@ + +#include "d3d9_device.h" +#include "d3d9_interface.h" +#include "d3d9_bridge.h" +#include "d3d9_swapchain.h" +#include "d3d9_surface.h" + +namespace dxvk { + + DxvkD3D8Bridge::DxvkD3D8Bridge(D3D9DeviceEx* pDevice) + : m_device(pDevice) { + } + + DxvkD3D8Bridge::~DxvkD3D8Bridge() { + } + + ULONG STDMETHODCALLTYPE DxvkD3D8Bridge::AddRef() { + return m_device->AddRef(); + } + + ULONG STDMETHODCALLTYPE DxvkD3D8Bridge::Release() { + return m_device->Release(); + } + + HRESULT STDMETHODCALLTYPE DxvkD3D8Bridge::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_device->QueryInterface(riid, ppvObject); + } + + void DxvkD3D8Bridge::SetAPIName(const char* name) { + m_device->m_implicitSwapchain->SetApiName(name); + } + + HRESULT DxvkD3D8Bridge::UpdateTextureFromBuffer( + IDirect3DSurface9* pDestSurface, + IDirect3DSurface9* pSrcSurface, + const RECT* pSrcRect, + const POINT* pDestPoint) { + auto lock = m_device->LockDevice(); + + D3D9Surface* dst = static_cast(pDestSurface); + D3D9Surface* src = static_cast(pSrcSurface); + + if (unlikely(dst == nullptr || src == nullptr)) + return D3DERR_INVALIDCALL; + + D3D9CommonTexture* srcTextureInfo = src->GetCommonTexture(); + D3D9CommonTexture* dstTextureInfo = dst->GetCommonTexture(); + + VkOffset3D srcOffset = { 0u, 0u, 0u }; + VkOffset3D dstOffset = { 0u, 0u, 0u }; + VkExtent3D texLevelExtent = srcTextureInfo->GetExtentMip(src->GetSubresource()); + VkExtent3D extent = texLevelExtent; + + srcOffset = { pSrcRect->left, + pSrcRect->top, + 0u }; + + extent = { uint32_t(pSrcRect->right - pSrcRect->left), uint32_t(pSrcRect->bottom - pSrcRect->top), 1 }; + + // TODO: Validate extents like in D3D9DeviceEx::UpdateSurface + + dstOffset = { pDestPoint->x, + pDestPoint->y, + 0u }; + + + m_device->UpdateTextureFromBuffer( + srcTextureInfo, dstTextureInfo, + src->GetSubresource(), dst->GetSubresource(), + srcOffset, extent, dstOffset + ); + + dstTextureInfo->SetNeedsReadback(dst->GetSubresource(), true); + + if (dstTextureInfo->IsAutomaticMip()) + m_device->MarkTextureMipsDirty(dstTextureInfo); + + return D3D_OK; + } + + DxvkD3D8InterfaceBridge::DxvkD3D8InterfaceBridge(D3D9InterfaceEx* pObject) + : m_interface(pObject) { + } + + DxvkD3D8InterfaceBridge::~DxvkD3D8InterfaceBridge() { + } + + ULONG STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::AddRef() { + return m_interface->AddRef(); + } + + ULONG STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::Release() { + return m_interface->Release(); + } + + HRESULT STDMETHODCALLTYPE DxvkD3D8InterfaceBridge::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_interface->QueryInterface(riid, ppvObject); + } + + const Config* DxvkD3D8InterfaceBridge::GetConfig() const { + return &m_interface->GetInstance()->config(); + } +} \ No newline at end of file diff --git a/src/d3d9/d3d9_bridge.h b/src/d3d9/d3d9_bridge.h new file mode 100644 index 00000000..f1c12104 --- /dev/null +++ b/src/d3d9/d3d9_bridge.h @@ -0,0 +1,113 @@ +#pragma once + +#include +#include "../util/config/config.h" + +#include "../vulkan/vulkan_loader.h" + +/** + * The D3D9 bridge allows D3D8 to access DXVK internals. + * For Vulkan interop without needing DXVK internals, see d3d9_interop.h. + * + * NOTE: You must include "d3d9_include.h" or "d3d8_include.h" before this header. + */ + +/** + * \brief D3D9 device interface for D3D8 interop + */ +MIDL_INTERFACE("D3D9D3D8-42A9-4C1E-AA97-BEEFCAFE2000") +IDxvkD3D8Bridge : public IUnknown { + + // D3D8 keeps D3D9 objects contained in a namespace. + #ifdef DXVK_D3D9_NAMESPACE + using IDirect3DSurface9 = d3d9::IDirect3DSurface9; + #endif + + /** + * \brief Changes the API name displayed on the HUD + * + * \param [in] name The new API name + */ + virtual void SetAPIName(const char* name) = 0; + + /** + * \brief Updates a D3D9 surface from a D3D9 buffer + * + * \param [in] pDestSurface Destination surface (typically in VRAM) + * \param [in] pSrcSurface Source surface (typically in system memory) + * \param [in] pSrcRect Source rectangle + * \param [in] pDestPoint Destination (top-left) point + */ + virtual HRESULT UpdateTextureFromBuffer( + IDirect3DSurface9* pDestSurface, + IDirect3DSurface9* pSrcSurface, + const RECT* pSrcRect, + const POINT* pDestPoint) = 0; +}; + +/** + * \brief D3D9 instance interface for D3D8 interop + */ +MIDL_INTERFACE("D3D9D3D8-A407-773E-18E9-CAFEBEEF3000") +IDxvkD3D8InterfaceBridge : public IUnknown { + /** + * \brief Retrieves the DXVK configuration + * + * \returns The DXVK Config object + */ + virtual const dxvk::Config* GetConfig() const = 0; +}; + +#if defined(_MSC_VER) +struct DECLSPEC_UUID("D3D9D3D8-42A9-4C1E-AA97-BEEFCAFE2000") IDxvkD3D8Bridge; +struct DECLSPEC_UUID("D3D9D3D8-A407-773E-18E9-CAFEBEEF3000") IDxvkD3D8InterfaceBridge; +#else +__CRT_UUID_DECL(IDxvkD3D8Bridge, 0xD3D9D3D8, 0x42A9, 0x4C1E, 0xAA, 0x97, 0xBE, 0xEF, 0xCA, 0xFE, 0x20, 0x00); +__CRT_UUID_DECL(IDxvkD3D8InterfaceBridge, 0xD3D9D3D8, 0xA407, 0x773E, 0x18, 0xE9, 0xCA, 0xFE, 0xBE, 0xEF, 0x30, 0x00); +#endif + +namespace dxvk { + + class D3D9DeviceEx; + class D3D9InterfaceEx; + + class DxvkD3D8Bridge : public IDxvkD3D8Bridge { + public: + DxvkD3D8Bridge(D3D9DeviceEx* pDevice); + ~DxvkD3D8Bridge(); + + ULONG STDMETHODCALLTYPE AddRef(); + ULONG STDMETHODCALLTYPE Release(); + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + void SetAPIName(const char* name); + + HRESULT UpdateTextureFromBuffer( + IDirect3DSurface9* pDestSurface, + IDirect3DSurface9* pSrcSurface, + const RECT* pSrcRect, + const POINT* pDestPoint); + + private: + D3D9DeviceEx* m_device; + }; + + class DxvkD3D8InterfaceBridge : public IDxvkD3D8InterfaceBridge { + public: + DxvkD3D8InterfaceBridge(D3D9InterfaceEx* pObject); + ~DxvkD3D8InterfaceBridge(); + + ULONG STDMETHODCALLTYPE AddRef(); + ULONG STDMETHODCALLTYPE Release(); + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + const Config* GetConfig() const; + + protected: + D3D9InterfaceEx* m_interface; + }; +} diff --git a/src/d3d9/d3d9_buffer.cpp b/src/d3d9/d3d9_buffer.cpp index c0b72c46..999844ef 100644 --- a/src/d3d9/d3d9_buffer.cpp +++ b/src/d3d9/d3d9_buffer.cpp @@ -29,8 +29,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D9VertexBuffer::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(IDirect3DVertexBuffer9), riid)) { + Logger::warn("D3D9VertexBuffer::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -86,8 +89,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D9IndexBuffer::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(IDirect3DIndexBuffer9), riid)) { + Logger::warn("D3D9IndexBuffer::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d9/d3d9_common_buffer.cpp b/src/d3d9/d3d9_common_buffer.cpp index 8d142373..e40a799b 100644 --- a/src/d3d9/d3d9_common_buffer.cpp +++ b/src/d3d9/d3d9_common_buffer.cpp @@ -20,6 +20,11 @@ namespace dxvk { m_dirtyRange = D3D9Range(0, m_desc.Size); } + D3D9CommonBuffer::~D3D9CommonBuffer() { + if (m_desc.Pool == D3DPOOL_DEFAULT) + m_parent->DecrementLosableCounter(); + } + HRESULT D3D9CommonBuffer::Lock( UINT OffsetToLock, @@ -57,6 +62,32 @@ namespace dxvk { } } + + D3D9_COMMON_BUFFER_MAP_MODE D3D9CommonBuffer::DetermineMapMode(const D3D9Options* options) const { + if (m_desc.Pool != D3DPOOL_DEFAULT) + return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER; + + // CSGO keeps vertex buffers locked across multiple frames and writes to it. It uses them for drawing without unlocking first. + // Tests show that D3D9 DEFAULT + USAGE_DYNAMIC behaves like a directly mapped buffer even when unlocked. + // DEFAULT + WRITEONLY does not behave like a directly mapped buffer EXCEPT if its locked at the moment. + // That's annoying to implement so we just always directly map DEFAULT + WRITEONLY. + if (!(m_desc.Usage & (D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY))) + return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER; + + // Tests show that DISCARD does not work for pure SWVP devices. + // So force staging buffer path to avoid stalls. + // Dark Romance: Vampire in Love also expects draws to be synchronous + // and breaks if we respect NOOVERWRITE. + // D&D Temple of Elemental Evil breaks if we respect DISCARD. + if (m_parent->CanOnlySWVP()) + return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER; + + if (!options->allowDirectBufferMapping) + return D3D9_COMMON_BUFFER_MAP_MODE_BUFFER; + + return D3D9_COMMON_BUFFER_MAP_MODE_DIRECT; + } + Rc D3D9CommonBuffer::CreateBuffer() const { DxvkBufferCreateInfo info; @@ -103,7 +134,8 @@ namespace dxvk { memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; } - if (memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT && m_parent->GetOptions()->apitraceMode) { + if ((memoryFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && m_parent->GetOptions()->cachedDynamicBuffers) { + memoryFlags &= ~VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; memoryFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; } diff --git a/src/d3d9/d3d9_common_buffer.h b/src/d3d9/d3d9_common_buffer.h index c3bc413c..782be427 100644 --- a/src/d3d9/d3d9_common_buffer.h +++ b/src/d3d9/d3d9_common_buffer.h @@ -78,6 +78,8 @@ namespace dxvk { D3D9DeviceEx* pDevice, const D3D9_BUFFER_DESC* pDesc); + ~D3D9CommonBuffer(); + HRESULT Lock( UINT OffsetToLock, UINT SizeToLock, @@ -89,11 +91,7 @@ namespace dxvk { /** * \brief Determine the mapping mode of the buffer, (ie. direct mapping or backed) */ - inline D3D9_COMMON_BUFFER_MAP_MODE DetermineMapMode(const D3D9Options* options) const { - return (m_desc.Pool == D3DPOOL_DEFAULT && (m_desc.Usage & (D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY)) && options->allowDirectBufferMapping) - ? D3D9_COMMON_BUFFER_MAP_MODE_DIRECT - : D3D9_COMMON_BUFFER_MAP_MODE_BUFFER; - } + D3D9_COMMON_BUFFER_MAP_MODE DetermineMapMode(const D3D9Options* options) const; /** * \brief Get the mapping mode of the buffer, (ie. direct mapping or backed) @@ -155,11 +153,6 @@ namespace dxvk { */ inline D3D9Range& DirtyRange() { return m_dirtyRange; } - /** - * \brief The range of the buffer that might currently be read by the GPU - */ - inline D3D9Range& GPUReadingRange() { return m_gpuReadingRange; } - /** * \brief Whether or not the buffer was written to by the GPU (in IDirect3DDevice9::ProcessVertices) */ @@ -184,15 +177,6 @@ namespace dxvk { */ inline bool NeedsUpload() { return m_desc.Pool != D3DPOOL_DEFAULT && !m_dirtyRange.IsDegenerate(); } - inline bool DoesStagingBufferUploads() const { return m_uploadUsingStaging; } - - inline void EnableStagingBufferUploads() { - if (GetMapMode() != D3D9_COMMON_BUFFER_MAP_MODE_BUFFER) - return; - - m_uploadUsingStaging = true; - } - void PreLoad(); bool HasSequenceNumber() const { @@ -241,9 +225,8 @@ namespace dxvk { D3D9DeviceEx* m_parent; const D3D9_BUFFER_DESC m_desc; - DWORD m_mapFlags; + DWORD m_mapFlags = 0; bool m_needsReadback = false; - bool m_uploadUsingStaging = false; D3D9_COMMON_BUFFER_MAP_MODE m_mapMode; Rc m_buffer; @@ -252,7 +235,6 @@ namespace dxvk { DxvkBufferSliceHandle m_sliceHandle; D3D9Range m_dirtyRange; - D3D9Range m_gpuReadingRange; uint32_t m_lockCount = 0; diff --git a/src/d3d9/d3d9_common_texture.cpp b/src/d3d9/d3d9_common_texture.cpp index b0681d49..6aed7038 100644 --- a/src/d3d9/d3d9_common_texture.cpp +++ b/src/d3d9/d3d9_common_texture.cpp @@ -4,6 +4,7 @@ #include "d3d9_device.h" #include "../util/util_shared_res.h" +#include "../util/util_win32_compat.h" #include @@ -11,24 +12,27 @@ namespace dxvk { D3D9CommonTexture::D3D9CommonTexture( D3D9DeviceEx* pDevice, + IUnknown* pInterface, const D3D9_COMMON_TEXTURE_DESC* pDesc, D3DRESOURCETYPE ResourceType, HANDLE* pSharedHandle) - : m_device(pDevice), m_desc(*pDesc), m_type(ResourceType) { + : m_device(pDevice), m_desc(*pDesc), m_type(ResourceType), m_d3d9Interop(pInterface, this) { if (m_desc.Format == D3D9Format::Unknown) m_desc.Format = (m_desc.Usage & D3DUSAGE_DEPTHSTENCIL) ? D3D9Format::D32 : D3D9Format::X8R8G8B8; + m_exposedMipLevels = m_desc.MipLevels; + + if (m_desc.Usage & D3DUSAGE_AUTOGENMIPMAP) + m_exposedMipLevels = 1; + for (uint32_t i = 0; i < m_dirtyBoxes.size(); i++) { AddDirtyBox(nullptr, i); } if (m_desc.Pool != D3DPOOL_DEFAULT) { - const uint32_t subresources = CountSubresources(); - for (uint32_t i = 0; i < subresources; i++) { - SetNeedsUpload(i, true); - } + SetAllNeedUpload(); if (pSharedHandle) { throw DxvkError("D3D9: Incompatible pool type for texture sharing."); } @@ -38,9 +42,12 @@ namespace dxvk { m_mapMode = DetermineMapMode(); m_shadow = DetermineShadowState(); + m_upgradedToD32f = ConvertFormatUnfixed(m_desc.Format).FormatColor != m_mapping.FormatColor && + (m_mapping.FormatColor == VK_FORMAT_D32_SFLOAT_S8_UINT || m_mapping.FormatColor == VK_FORMAT_D32_SFLOAT); m_supportsFetch4 = DetermineFetch4Compatibility(); - if (m_mapMode == D3D9_COMMON_TEXTURE_MAP_MODE_BACKED) { + const bool createImage = m_desc.Pool != D3DPOOL_SYSTEMMEM && m_desc.Pool != D3DPOOL_SCRATCH && m_desc.Format != D3D9Format::NULL_FORMAT; + if (createImage) { bool plainSurface = m_type == D3DRTYPE_SURFACE && !(m_desc.Usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL)); @@ -67,25 +74,33 @@ namespace dxvk { CreateSampleView(0); if (!IsManaged()) { - m_size = m_image->memSize(); + m_size = m_image->memory().length(); if (!m_device->ChangeReportedMemory(-m_size)) throw DxvkError("D3D9: Reporting out of memory from tracking."); } } - if (m_mapMode == D3D9_COMMON_TEXTURE_MAP_MODE_SYSTEMMEM) - CreateBuffers(); + for (uint32_t i = 0; i < CountSubresources(); i++) { + m_memoryOffset[i] = m_totalSize; + m_totalSize += GetMipSize(i); + } - m_exposedMipLevels = m_desc.MipLevels; - - if (m_desc.Usage & D3DUSAGE_AUTOGENMIPMAP) - m_exposedMipLevels = 1; + // Initialization is handled by D3D9Initializer + if (m_mapMode == D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE) + m_data = m_device->GetAllocator()->Alloc(m_totalSize); + else if (m_mapMode != D3D9_COMMON_TEXTURE_MAP_MODE_NONE && m_desc.Pool != D3DPOOL_DEFAULT) + CreateBuffer(false); } D3D9CommonTexture::~D3D9CommonTexture() { if (m_size != 0) m_device->ChangeReportedMemory(m_size); + + m_device->RemoveMappedTexture(this); + + if (m_desc.Pool == D3DPOOL_DEFAULT) + m_device->DecrementLosableCounter(); } @@ -134,7 +149,7 @@ namespace dxvk { if (pDesc->Width == 0 || pDesc->Height == 0 || pDesc->Depth == 0) return D3DERR_INVALIDCALL; - if (FAILED(DecodeMultiSampleType(pDesc->MultiSample, pDesc->MultisampleQuality, nullptr))) + if (FAILED(DecodeMultiSampleType(pDevice->GetDXVKDevice(), pDesc->MultiSample, pDesc->MultisampleQuality, nullptr))) return D3DERR_INVALIDCALL; // Using MANAGED pool with DYNAMIC usage is illegal @@ -166,18 +181,32 @@ namespace dxvk { } - bool D3D9CommonTexture::CreateBufferSubresource(UINT Subresource) { - if (m_buffers[Subresource] != nullptr) - return false; + void* D3D9CommonTexture::GetData(UINT Subresource) { + if (unlikely(m_buffer != nullptr)) + return m_buffer->mapPtr(m_memoryOffset[Subresource]); + + m_data.Map(); + uint8_t* ptr = reinterpret_cast(m_data.Ptr()); + ptr += m_memoryOffset[Subresource]; + return ptr; + } + + + void D3D9CommonTexture::CreateBuffer(bool Initialize) { + if (likely(m_buffer != nullptr)) + return; DxvkBufferCreateInfo info; - info.size = GetMipSize(Subresource); + info.size = m_totalSize; info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; - info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT; + info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT + | VK_PIPELINE_STAGE_HOST_BIT; info.access = VK_ACCESS_TRANSFER_READ_BIT - | VK_ACCESS_TRANSFER_WRITE_BIT; + | VK_ACCESS_TRANSFER_WRITE_BIT + | VK_ACCESS_HOST_WRITE_BIT + | VK_ACCESS_HOST_READ_BIT; if (m_mapping.ConversionFormatInfo.FormatType != D3D9ConversionFormat_None) { info.usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; @@ -188,10 +217,17 @@ namespace dxvk { | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; - m_buffers[Subresource] = m_device->GetDXVKDevice()->createBuffer(info, memType); - m_mappedSlices[Subresource] = m_buffers[Subresource]->getSliceHandle(); + m_buffer = m_device->GetDXVKDevice()->createBuffer(info, memType); - return true; + if (Initialize) { + if (m_data) { + m_data.Map(); + std::memcpy(m_buffer->mapPtr(0), m_data.Ptr(), m_totalSize); + } else { + std::memset(m_buffer->mapPtr(0), 0, m_totalSize); + } + } + m_data = {}; } @@ -199,19 +235,27 @@ namespace dxvk { const UINT MipLevel = Subresource % m_desc.MipLevels; const DxvkFormatInfo* formatInfo = m_mapping.FormatColor != VK_FORMAT_UNDEFINED - ? imageFormatInfo(m_mapping.FormatColor) + ? lookupFormatInfo(m_mapping.FormatColor) : m_device->UnsupportedFormatInfo(m_desc.Format); const VkExtent3D mipExtent = util::computeMipLevelExtent( GetExtent(), MipLevel); - + + VkExtent3D blockSize = formatInfo->blockSize; + uint32_t elementSize = formatInfo->elementSize; + if (unlikely(formatInfo->flags.test(DxvkFormatFlag::MultiPlane))) { + // D3D9 doesn't allow specifying the plane when locking a texture. + // So the subsampled planes inherit the pitch of the first plane. + // That means the size is the size of plane 0 * plane count + elementSize = formatInfo->planes[0].elementSize; + blockSize = { formatInfo->planes[0].blockSize.width, formatInfo->planes[0].blockSize.height, 1u }; + } + const VkExtent3D blockCount = util::computeBlockCount( - mipExtent, formatInfo->blockSize); + mipExtent, blockSize); - const uint32_t planeCount = m_mapping.ConversionFormatInfo.PlaneCount; - - return std::min(planeCount, 2u) - * align(formatInfo->elementSize * blockCount.width, 4) + return std::min(GetPlaneCount(), 2u) + * align(elementSize * blockCount.width, 4) * blockCount.height * blockCount.depth; } @@ -258,12 +302,12 @@ namespace dxvk { imageInfo.stages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; } - DecodeMultiSampleType(m_desc.MultiSample, m_desc.MultisampleQuality, &imageInfo.sampleCount); + DecodeMultiSampleType(m_device->GetDXVKDevice(), m_desc.MultiSample, m_desc.MultisampleQuality, &imageInfo.sampleCount); // The image must be marked as mutable if it can be reinterpreted // by a view with a different format. Depth-stencil formats cannot // be reinterpreted in Vulkan, so we'll ignore those. - auto formatProperties = imageFormatInfo(m_mapping.FormatColor); + auto formatProperties = lookupFormatInfo(m_mapping.FormatColor); bool isMutable = m_mapping.FormatSrgb != VK_FORMAT_UNDEFINED; bool isColorFormat = (formatProperties->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != 0; @@ -275,15 +319,21 @@ namespace dxvk { imageInfo.viewFormats = m_mapping.Formats; } + const bool hasAttachmentFeedbackLoops = + m_device->GetDXVKDevice()->features().extAttachmentFeedbackLoopLayout.attachmentFeedbackLoopLayout; + const bool isRT = m_desc.Usage & D3DUSAGE_RENDERTARGET; + const bool isDS = m_desc.Usage & D3DUSAGE_DEPTHSTENCIL; + const bool isAutoGen = m_desc.Usage & D3DUSAGE_AUTOGENMIPMAP; + // Are we an RT, need to gen mips or an offscreen plain surface? - if (m_desc.Usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP) || TryOffscreenRT) { + if (isRT || isAutoGen || TryOffscreenRT) { imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; imageInfo.stages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; imageInfo.access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; } - if (m_desc.Usage & D3DUSAGE_DEPTHSTENCIL) { + if (isDS) { imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; imageInfo.stages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; @@ -291,6 +341,9 @@ namespace dxvk { | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; } + if (ResourceType == D3DRTYPE_TEXTURE && (isRT || isDS) && hasAttachmentFeedbackLoops) + imageInfo.usage |= VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT; + if (ResourceType == D3DRTYPE_CUBETEXTURE) imageInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; @@ -314,7 +367,7 @@ namespace dxvk { if (!CheckImageSupport(&imageInfo, imageInfo.tiling)) { throw DxvkError(str::format( "D3D9: Cannot create texture:", - "\n Type: ", std::hex, ResourceType, + "\n Type: 0x", std::hex, ResourceType, std::dec, "\n Format: ", m_desc.Format, "\n Extent: ", m_desc.Width, "x", m_desc.Height, @@ -322,8 +375,8 @@ namespace dxvk { "\n Samples: ", m_desc.MultiSample, "\n Layers: ", m_desc.ArraySize, "\n Levels: ", m_desc.MipLevels, - "\n Usage: ", std::hex, m_desc.Usage, - "\n Pool: ", std::hex, m_desc.Pool)); + "\n Usage: 0x", std::hex, m_desc.Usage, std::dec, + "\n Pool: 0x", std::hex, m_desc.Pool, std::dec)); } return m_device->GetDXVKDevice()->createImage(imageInfo, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); @@ -362,53 +415,54 @@ namespace dxvk { BOOL D3D9CommonTexture::CheckImageSupport( const DxvkImageCreateInfo* pImageInfo, VkImageTiling Tiling) const { - const Rc adapter = m_device->GetDXVKDevice()->adapter(); + DxvkFormatQuery formatQuery = { }; + formatQuery.format = pImageInfo->format; + formatQuery.type = pImageInfo->type; + formatQuery.tiling = Tiling; + formatQuery.usage = pImageInfo->usage; + formatQuery.flags = pImageInfo->flags; + + auto properties = m_device->GetDXVKDevice()->getFormatLimits(formatQuery); - VkImageFormatProperties formatProps = { }; - - VkResult status = adapter->imageFormatProperties( - pImageInfo->format, pImageInfo->type, Tiling, - pImageInfo->usage, pImageInfo->flags, formatProps); - - if (status != VK_SUCCESS) + if (!properties) return FALSE; - return (pImageInfo->extent.width <= formatProps.maxExtent.width) - && (pImageInfo->extent.height <= formatProps.maxExtent.height) - && (pImageInfo->extent.depth <= formatProps.maxExtent.depth) - && (pImageInfo->numLayers <= formatProps.maxArrayLayers) - && (pImageInfo->mipLevels <= formatProps.maxMipLevels) - && (pImageInfo->sampleCount & formatProps.sampleCounts); + return (pImageInfo->extent.width <= properties->maxExtent.width) + && (pImageInfo->extent.height <= properties->maxExtent.height) + && (pImageInfo->extent.depth <= properties->maxExtent.depth) + && (pImageInfo->numLayers <= properties->maxArrayLayers) + && (pImageInfo->mipLevels <= properties->maxMipLevels) + && (pImageInfo->sampleCount & properties->sampleCounts); } VkImageUsageFlags D3D9CommonTexture::EnableMetaCopyUsage( VkFormat Format, VkImageTiling Tiling) const { - VkFormatFeatureFlags requestedFeatures = 0; + VkFormatFeatureFlags2 requestedFeatures = 0; if (Format == VK_FORMAT_D16_UNORM || Format == VK_FORMAT_D32_SFLOAT) - requestedFeatures |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + requestedFeatures |= VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT; if (Format == VK_FORMAT_R16_UNORM || Format == VK_FORMAT_R32_SFLOAT) - requestedFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + requestedFeatures |= VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT; - if (requestedFeatures == 0) + if (!requestedFeatures) return 0; // Enable usage flags for all supported and requested features - VkFormatProperties properties = m_device->GetDXVKDevice()->adapter()->formatProperties(Format); + DxvkFormatFeatures properties = m_device->GetDXVKDevice()->getFormatFeatures(Format); requestedFeatures &= Tiling == VK_IMAGE_TILING_OPTIMAL - ? properties.optimalTilingFeatures - : properties.linearTilingFeatures; + ? properties.optimal + : properties.linear; VkImageUsageFlags requestedUsage = 0; - if (requestedFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) + if (requestedFeatures & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) requestedUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (requestedFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) + if (requestedFeatures & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT) requestedUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; return requestedUsage; @@ -446,8 +500,10 @@ namespace dxvk { // Filter out unnecessary flags. Transfer operations // are handled by the backend in a transparent manner. + // Feedback loops are handled by hazard tracking. Usage &= ~(VK_IMAGE_USAGE_TRANSFER_DST_BIT - | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + | VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT); // Ignore sampled bit in case the image was created with // an image flag that only allows attachment usage @@ -477,6 +533,20 @@ namespace dxvk { return VK_IMAGE_LAYOUT_GENERAL; } + D3D9_COMMON_TEXTURE_MAP_MODE D3D9CommonTexture::DetermineMapMode() const { + if (m_desc.Format == D3D9Format::NULL_FORMAT) + return D3D9_COMMON_TEXTURE_MAP_MODE_NONE; + +#ifdef D3D9_ALLOW_UNMAPPING + if (m_device->GetOptions()->textureMemory != 0 && m_desc.Pool != D3DPOOL_DEFAULT) + return D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE; +#endif + + if (m_desc.Pool == D3DPOOL_SYSTEMMEM || m_desc.Pool == D3DPOOL_SCRATCH) + return D3D9_COMMON_TEXTURE_MAP_MODE_SYSTEMMEM; + + return D3D9_COMMON_TEXTURE_MAP_MODE_BACKED; + } void D3D9CommonTexture::ExportImageInfo() { /* From MSDN: @@ -541,7 +611,7 @@ namespace dxvk { viewInfo.format = m_mapping.ConversionFormatInfo.FormatColor != VK_FORMAT_UNDEFINED ? PickSRGB(m_mapping.ConversionFormatInfo.FormatColor, m_mapping.ConversionFormatInfo.FormatSrgb, Srgb) : PickSRGB(m_mapping.FormatColor, m_mapping.FormatSrgb, Srgb); - viewInfo.aspect = imageFormatInfo(viewInfo.format)->aspectMask; + viewInfo.aspect = lookupFormatInfo(viewInfo.format)->aspectMask; viewInfo.swizzle = m_mapping.Swizzle; viewInfo.usage = UsageFlags; viewInfo.type = GetImageViewTypeFromResourceType(m_type, Layer); @@ -607,4 +677,22 @@ namespace dxvk { } + const Rc& D3D9CommonTexture::GetBuffer() { + return m_buffer; + } + + + DxvkBufferSlice D3D9CommonTexture::GetBufferSlice(UINT Subresource) { + return DxvkBufferSlice(GetBuffer(), m_memoryOffset[Subresource], GetMipSize(Subresource)); + } + + + uint32_t D3D9CommonTexture::GetPlaneCount() const { + const DxvkFormatInfo* formatInfo = m_mapping.FormatColor != VK_FORMAT_UNDEFINED + ? lookupFormatInfo(m_mapping.FormatColor) + : m_device->UnsupportedFormatInfo(m_desc.Format); + + return vk::getPlaneCount(formatInfo->aspectMask); + } + } diff --git a/src/d3d9/d3d9_common_texture.h b/src/d3d9/d3d9_common_texture.h index e52ead2f..37b5bc3a 100644 --- a/src/d3d9/d3d9_common_texture.h +++ b/src/d3d9/d3d9_common_texture.h @@ -3,6 +3,8 @@ #include "d3d9_format.h" #include "d3d9_util.h" #include "d3d9_caps.h" +#include "d3d9_mem.h" +#include "d3d9_interop.h" #include "../dxvk/dxvk_device.h" @@ -22,6 +24,7 @@ namespace dxvk { D3D9_COMMON_TEXTURE_MAP_MODE_NONE, ///< No mapping available D3D9_COMMON_TEXTURE_MAP_MODE_BACKED, ///< Mapped image through buffer D3D9_COMMON_TEXTURE_MAP_MODE_SYSTEMMEM, ///< Only a buffer - no image + D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE, ///< Non-Vulkan memory that can be unmapped }; /** @@ -44,6 +47,7 @@ namespace dxvk { bool Discard; bool IsBackBuffer; bool IsAttachmentOnly; + bool IsLockable; }; struct D3D9ColorView { @@ -70,6 +74,7 @@ namespace dxvk { D3D9CommonTexture( D3D9DeviceEx* pDevice, + IUnknown* pInterface, const D3D9_COMMON_TEXTURE_DESC* pDesc, D3DRESOURCETYPE ResourceType, HANDLE* pSharedHandle); @@ -141,21 +146,19 @@ namespace dxvk { return m_resolveImage; } - const Rc& GetBuffer(UINT Subresource) { - return m_buffers[Subresource]; - } + /** + * \brief Returns a pointer to the internal data used for LockRect/LockBox + * + * This works regardless of the map mode used by this texture + * and will map the memory if necessary. + * \param [in] Subresource Subresource index + * @return Pointer to locking data + */ + void* GetData(UINT Subresource); + const Rc& GetBuffer(); - DxvkBufferSliceHandle GetMappedSlice(UINT Subresource) { - return m_mappedSlices[Subresource]; - } - - - DxvkBufferSliceHandle DiscardMapSlice(UINT Subresource) { - DxvkBufferSliceHandle handle = m_buffers[Subresource]->allocSlice(); - m_mappedSlices[Subresource] = handle; - return handle; - } + DxvkBufferSlice GetBufferSlice(UINT Subresource); /** * \brief Computes subresource from the subresource index @@ -191,6 +194,14 @@ namespace dxvk { return m_shadow; } + /** + * \brief Dref Clamp + * \returns Whether the texture emulates an UNORM format with D32f + */ + bool IsUpgradedToD32f() const { + return m_upgradedToD32f; + } + /** * \brief FETCH4 compatibility * \returns Whether the format of the texture supports the FETCH4 hack @@ -215,32 +226,17 @@ namespace dxvk { return Face * m_desc.MipLevels + MipLevel; } - /** - * \brief Creates buffers - * Creates mapping and staging buffers for all subresources - * allocates new buffers if necessary - */ - void CreateBuffers() { - const uint32_t count = CountSubresources(); - for (uint32_t i = 0; i < count; i++) - CreateBufferSubresource(i); + void UnmapData() { + m_data.Unmap(); } - /** - * \brief Creates a buffer - * Creates mapping and staging buffers for a given subresource - * allocates new buffers if necessary - * \returns Whether an allocation happened - */ - bool CreateBufferSubresource(UINT Subresource); - /** * \brief Destroys a buffer * Destroys mapping and staging buffers for a given subresource */ - void DestroyBufferSubresource(UINT Subresource) { - m_buffers[Subresource] = nullptr; - SetNeedsReadback(Subresource, true); + void DestroyBuffer() { + m_buffer = nullptr; + MarkAllNeedReadback(); } bool IsDynamic() const { @@ -311,14 +307,16 @@ namespace dxvk { return util::computeMipLevelExtent(GetExtent(), MipLevel); } - bool MarkHazardous() { - return std::exchange(m_hazardous, true); + bool MarkTransitionedToHazardLayout() { + return std::exchange(m_transitionedToHazardLayout, true); } D3DRESOURCETYPE GetType() { return m_type; } + uint32_t GetPlaneCount() const; + const D3D9_VK_FORMAT_MAPPING& GetMapping() { return m_mapping; } void SetLocked(UINT Subresource, bool value) { m_locked.set(Subresource, value); } @@ -329,7 +327,7 @@ namespace dxvk { void SetNeedsReadback(UINT Subresource, bool value) { m_needsReadback.set(Subresource, value); } - bool NeedsReachback(UINT Subresource) const { return m_needsReadback.get(Subresource); } + bool NeedsReadback(UINT Subresource) const { return m_needsReadback.get(Subresource); } void MarkAllNeedReadback() { m_needsReadback.setAll(); } @@ -341,27 +339,27 @@ namespace dxvk { return m_sampleView.Pick(srgb && IsSrgbCompatible()); } - VkImageLayout DetermineRenderTargetLayout() const { + VkImageLayout DetermineRenderTargetLayout(VkImageLayout hazardLayout) const { + if (unlikely(m_transitionedToHazardLayout)) + return hazardLayout; + return m_image != nullptr && - m_image->info().tiling == VK_IMAGE_TILING_OPTIMAL && - !m_hazardous + m_image->info().tiling == VK_IMAGE_TILING_OPTIMAL ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL; } - VkImageLayout DetermineDepthStencilLayout(bool write, bool hazardous) const { - VkImageLayout layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - - if (unlikely(hazardous)) { - layout = write - ? VK_IMAGE_LAYOUT_GENERAL - : VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL; - } + VkImageLayout DetermineDepthStencilLayout(bool write, bool hazardous, VkImageLayout hazardLayout) const { + if (unlikely(m_transitionedToHazardLayout)) + return hazardLayout; if (unlikely(m_image->info().tiling != VK_IMAGE_TILING_OPTIMAL)) - layout = VK_IMAGE_LAYOUT_GENERAL; + return VK_IMAGE_LAYOUT_GENERAL; - return layout; + if (unlikely(hazardous && !write)) + return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL; + + return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; } Rc CreateView( @@ -372,22 +370,25 @@ namespace dxvk { D3D9SubresourceBitset& GetUploadBitmask() { return m_needsUpload; } void SetAllNeedUpload() { - m_needsUpload.setAll(); + if (likely(!IsAutomaticMip())) { + m_needsUpload.setAll(); + } else { + for (uint32_t a = 0; a < m_desc.ArraySize; a++) { + for (uint32_t m = 0; m < ExposedMipLevels(); m++) { + SetNeedsUpload(CalcSubresource(a, m), true); + } + } + } } void SetNeedsUpload(UINT Subresource, bool upload) { m_needsUpload.set(Subresource, upload); } bool NeedsUpload(UINT Subresource) const { return m_needsUpload.get(Subresource); } bool NeedsAnyUpload() { return m_needsUpload.any(); } void ClearNeedsUpload() { return m_needsUpload.clearAll(); } - bool DoesStagingBufferUploads(UINT Subresource) const { return m_uploadUsingStaging.get(Subresource); } - - void EnableStagingBufferUploads(UINT Subresource) { - m_uploadUsingStaging.set(Subresource, true); - } void SetNeedsMipGen(bool value) { m_needsMipGen = value; } bool NeedsMipGen() const { return m_needsMipGen; } - DWORD ExposedMipLevels() { return m_exposedMipLevels; } + DWORD ExposedMipLevels() const { return m_exposedMipLevels; } void SetMipFilter(D3DTEXTUREFILTERTYPE filter) { m_mipFilter = filter; } D3DTEXTUREFILTERTYPE GetMipFilter() const { return m_mipFilter; } @@ -461,6 +462,26 @@ namespace dxvk { : 0ull; } + /** + * \brief Mip level + * \returns Size of packed mip level in bytes + */ + VkDeviceSize GetMipSize(UINT Subresource) const; + + uint32_t GetTotalSize() const { + return m_totalSize; + } + + /** + * \brief Creates a buffer + * Creates the mapping buffer if necessary + * \param [in] Initialize Whether to copy over existing data (or clear if there is no data) + * \returns Whether an allocation happened + */ + void CreateBuffer(bool Initialize); + + ID3D9VkInteropTexture* GetVkInterop() { return &m_d3d9Interop; } + private: D3D9DeviceEx* m_device; @@ -470,23 +491,26 @@ namespace dxvk { Rc m_image; Rc m_resolveImage; - D3D9SubresourceArray< - Rc> m_buffers; - D3D9SubresourceArray< - DxvkBufferSliceHandle> m_mappedSlices; + Rc m_buffer; + D3D9Memory m_data = { }; + D3D9SubresourceArray< uint64_t> m_seqs = { }; + D3D9SubresourceArray< + uint32_t> m_memoryOffset = { }; + + uint32_t m_totalSize = 0; + D3D9_VK_FORMAT_MAPPING m_mapping; bool m_shadow; //< Depth Compare-ness + bool m_upgradedToD32f; // Dref Clamp bool m_supportsFetch4; int64_t m_size = 0; - bool m_systemmemModified = false; - - bool m_hazardous = false; + bool m_transitionedToHazardLayout = false; D3D9ColorView m_sampleView; @@ -498,8 +522,6 @@ namespace dxvk { D3D9SubresourceBitset m_needsUpload = { }; - D3D9SubresourceBitset m_uploadUsingStaging = { }; - DWORD m_exposedMipLevels = 0; bool m_needsMipGen = false; @@ -508,11 +530,7 @@ namespace dxvk { std::array m_dirtyBoxes; - /** - * \brief Mip level - * \returns Size of packed mip level in bytes - */ - VkDeviceSize GetMipSize(UINT Subresource) const; + D3D9VkInteropTexture m_d3d9Interop; Rc CreatePrimaryImage(D3DRESOURCETYPE ResourceType, bool TryOffscreenRT, HANDLE* pSharedHandle) const; @@ -530,15 +548,7 @@ namespace dxvk { VkFormat Format, VkImageTiling Tiling) const; - D3D9_COMMON_TEXTURE_MAP_MODE DetermineMapMode() const { - if (m_desc.Format == D3D9Format::NULL_FORMAT) - return D3D9_COMMON_TEXTURE_MAP_MODE_NONE; - - if (m_desc.Pool == D3DPOOL_SYSTEMMEM || m_desc.Pool == D3DPOOL_SCRATCH) - return D3D9_COMMON_TEXTURE_MAP_MODE_SYSTEMMEM; - - return D3D9_COMMON_TEXTURE_MAP_MODE_BACKED; - } + D3D9_COMMON_TEXTURE_MAP_MODE DetermineMapMode() const; VkImageLayout OptimizeLayout( VkImageUsageFlags Usage) const; diff --git a/src/d3d9/d3d9_constant_buffer.cpp b/src/d3d9/d3d9_constant_buffer.cpp new file mode 100644 index 00000000..5bbd9a1d --- /dev/null +++ b/src/d3d9/d3d9_constant_buffer.cpp @@ -0,0 +1,155 @@ +#include "d3d9_constant_buffer.h" +#include "d3d9_device.h" + +namespace dxvk { + + D3D9ConstantBuffer::D3D9ConstantBuffer() { + + } + + + D3D9ConstantBuffer::D3D9ConstantBuffer( + D3D9DeviceEx* pDevice, + DxsoProgramType ShaderStage, + DxsoConstantBuffers BufferType, + VkDeviceSize Size) + : D3D9ConstantBuffer(pDevice, getBufferUsage(pDevice, ShaderStage, BufferType), GetShaderStage(ShaderStage), + computeResourceSlotId(ShaderStage, DxsoBindingType::ConstantBuffer, BufferType), + Size) { + + } + + + D3D9ConstantBuffer::D3D9ConstantBuffer( + D3D9DeviceEx* pDevice, + VkBufferUsageFlags Usage, + VkShaderStageFlags Stages, + uint32_t ResourceSlot, + VkDeviceSize Size) + : m_device (pDevice) + , m_binding (ResourceSlot) + , m_usage (Usage) + , m_stages (Stages) + , m_size (Size) + , m_align (getAlignment(pDevice->GetDXVKDevice())) { + + } + + + D3D9ConstantBuffer::~D3D9ConstantBuffer() { + + } + + + void* D3D9ConstantBuffer::Alloc(VkDeviceSize size) { + if (unlikely(m_buffer == nullptr)) { + this->createBuffer(); + m_slice = m_buffer->getSliceHandle(); + } + + size = align(size, m_align); + + if (unlikely(m_offset + size > m_size)) { + m_slice = m_buffer->allocSlice(); + m_offset = 0; + + m_device->EmitCs([ + cBuffer = m_buffer, + cSlice = m_slice + ] (DxvkContext* ctx) { + ctx->invalidateBuffer(cBuffer, cSlice); + }); + } + + m_device->EmitCs([ + cStages = m_stages, + cBinding = m_binding, + cOffset = m_offset, + cLength = size + ] (DxvkContext* ctx) { + ctx->bindUniformBufferRange(cStages, cBinding, cOffset, cLength); + }); + + void* mapPtr = reinterpret_cast(m_slice.mapPtr) + m_offset; + m_offset += size; + return mapPtr; + } + + + void* D3D9ConstantBuffer::AllocSlice() { + if (unlikely(m_buffer == nullptr)) + this->createBuffer(); + + m_slice = m_buffer->allocSlice(); + + m_device->EmitCs([ + cBuffer = m_buffer, + cSlice = m_slice + ] (DxvkContext* ctx) { + ctx->invalidateBuffer(cBuffer, cSlice); + }); + + return m_slice.mapPtr; + } + + + void D3D9ConstantBuffer::createBuffer() { + auto options = m_device->GetOptions(); + + // Buffer usage and access flags don't make much of a difference + // in the backend, so set both STORAGE and UNIFORM usage/access. + DxvkBufferCreateInfo bufferInfo; + bufferInfo.size = align(m_size, m_align); + bufferInfo.usage = m_usage; + bufferInfo.access = 0; + bufferInfo.stages = util::pipelineStages(m_stages); + + if (m_usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) + bufferInfo.access |= VK_ACCESS_UNIFORM_READ_BIT; + if (m_usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) + bufferInfo.access |= VK_ACCESS_SHADER_READ_BIT; + + VkMemoryPropertyFlags memoryFlags + = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + + if (options->deviceLocalConstantBuffers) + memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + + m_buffer = m_device->GetDXVKDevice()->createBuffer(bufferInfo, memoryFlags); + + m_device->EmitCs([ + cStages = m_stages, + cBinding = m_binding, + cSlice = DxvkBufferSlice(m_buffer) + ] (DxvkContext* ctx) mutable { + ctx->bindUniformBuffer(cStages, cBinding, std::move(cSlice)); + }); + } + + + VkDeviceSize D3D9ConstantBuffer::getAlignment(const Rc& device) const { + return std::max(std::max( + device->properties().core.properties.limits.minUniformBufferOffsetAlignment, + device->properties().core.properties.limits.minStorageBufferOffsetAlignment), + device->properties().extRobustness2.robustUniformBufferAccessSizeAlignment); + } + + + VkBufferUsageFlags D3D9ConstantBuffer::getBufferUsage( + D3D9DeviceEx* pDevice, + DxsoProgramType ShaderStage, + DxsoConstantBuffers BufferType) { + VkBufferUsageFlags result = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + + // We won't always need this, but the only buffer that + // this applies to is so large that it will not matter. + if (pDevice->CanSWVP() + && ShaderStage == DxsoProgramType::VertexShader + && BufferType == DxsoConstantBuffers::VSConstantBuffer) + result |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + + return result; + } + +} diff --git a/src/d3d9/d3d9_constant_buffer.h b/src/d3d9/d3d9_constant_buffer.h new file mode 100644 index 00000000..22abe222 --- /dev/null +++ b/src/d3d9/d3d9_constant_buffer.h @@ -0,0 +1,90 @@ +#pragma once + +#include "../dxvk/dxvk_buffer.h" + +#include "../dxso/dxso_util.h" + +#include "../util/util_math.h" + +#include "d3d9_include.h" + +namespace dxvk { + + class D3D9DeviceEx; + + /** + * \brief Constant buffer + */ + class D3D9ConstantBuffer { + + public: + + D3D9ConstantBuffer(); + + D3D9ConstantBuffer( + D3D9DeviceEx* pDevice, + DxsoProgramType ShaderStage, + DxsoConstantBuffers BufferType, + VkDeviceSize Size); + + D3D9ConstantBuffer( + D3D9DeviceEx* pDevice, + VkBufferUsageFlags Usage, + VkShaderStageFlags Stages, + uint32_t ResourceSlot, + VkDeviceSize Size); + + ~D3D9ConstantBuffer(); + + /** + * \brief Queries alignment + * + * Useful to pad copies with initialized data. + * \returns Data alignment + */ + VkDeviceSize GetAlignment() const { + return m_align; + } + + /** + * \brief Allocates a given amount of memory + * + * \param [in] size Number of bytes to allocate + * \returns Map pointer of the allocated region + */ + void* Alloc(VkDeviceSize size); + + /** + * \brief Allocates a full buffer slice + * + * This must not be called if \ref Alloc is used. + * \returns Map pointer of the allocated region + */ + void* AllocSlice(); + + private: + + D3D9DeviceEx* m_device = nullptr; + + uint32_t m_binding = 0u; + VkBufferUsageFlags m_usage = 0u; + VkShaderStageFlags m_stages = 0u; + VkDeviceSize m_size = 0ull; + VkDeviceSize m_align = 0ull; + VkDeviceSize m_offset = 0ull; + + Rc m_buffer = nullptr; + DxvkBufferSliceHandle m_slice = { }; + + void createBuffer(); + + VkDeviceSize getAlignment(const Rc& device) const; + + static VkBufferUsageFlags getBufferUsage( + D3D9DeviceEx* pDevice, + DxsoProgramType ShaderStage, + DxsoConstantBuffers BufferType); + + }; + +} \ No newline at end of file diff --git a/src/d3d9/d3d9_constant_set.h b/src/d3d9/d3d9_constant_set.h index a927a1b1..fb64a586 100644 --- a/src/d3d9/d3d9_constant_set.h +++ b/src/d3d9/d3d9_constant_set.h @@ -1,6 +1,7 @@ #pragma once #include "d3d9_caps.h" +#include "d3d9_constant_buffer.h" #include "../dxvk/dxvk_buffer.h" @@ -39,14 +40,13 @@ namespace dxvk { }; struct D3D9SwvpConstantBuffers { - Rc floatBuffer; - Rc intBuffer; - Rc boolBuffer; + D3D9ConstantBuffer intBuffer; + D3D9ConstantBuffer boolBuffer; }; struct D3D9ConstantSets { - D3D9SwvpConstantBuffers swvpBuffers; - Rc buffer; + D3D9SwvpConstantBuffers swvp; + D3D9ConstantBuffer buffer; DxsoShaderMetaInfo meta = {}; bool dirty = true; }; diff --git a/src/d3d9/d3d9_cursor.cpp b/src/d3d9/d3d9_cursor.cpp index 408268c1..16ec41d6 100644 --- a/src/d3d9/d3d9_cursor.cpp +++ b/src/d3d9/d3d9_cursor.cpp @@ -5,6 +5,7 @@ namespace dxvk { +#ifdef _WIN32 void D3D9Cursor::UpdateCursor(int X, int Y) { POINT currentPos = { }; if (::GetCursorPos(¤tPos) && currentPos == POINT{ X, Y }) @@ -15,7 +16,11 @@ namespace dxvk { BOOL D3D9Cursor::ShowCursor(BOOL bShow) { - ::SetCursor(bShow ? m_hCursor : nullptr); + if (likely(m_hCursor != nullptr)) + ::SetCursor(bShow ? m_hCursor : nullptr); + else + Logger::debug("D3D9Cursor::ShowCursor: Software cursor not implemented."); + return std::exchange(m_visible, bShow); } @@ -43,5 +48,23 @@ namespace dxvk { return D3D_OK; } +#else + void D3D9Cursor::UpdateCursor(int X, int Y) { + Logger::warn("D3D9Cursor::UpdateCursor: Not supported on current platform."); + } -} \ No newline at end of file + + BOOL D3D9Cursor::ShowCursor(BOOL bShow) { + Logger::warn("D3D9Cursor::ShowCursor: Not supported on current platform."); + return std::exchange(m_visible, bShow); + } + + + HRESULT D3D9Cursor::SetHardwareCursor(UINT XHotSpot, UINT YHotSpot, const CursorBitmap& bitmap) { + Logger::warn("D3D9Cursor::SetHardwareCursor: Not supported on current platform."); + + return D3D_OK; + } +#endif + +} diff --git a/src/d3d9/d3d9_cursor.h b/src/d3d9/d3d9_cursor.h index 32645d26..d69e3974 100644 --- a/src/d3d9/d3d9_cursor.h +++ b/src/d3d9/d3d9_cursor.h @@ -26,7 +26,9 @@ namespace dxvk { BOOL m_visible = FALSE; +#ifdef _WIN32 HCURSOR m_hCursor = nullptr; +#endif }; diff --git a/src/d3d9/d3d9_device.cpp b/src/d3d9/d3d9_device.cpp index 1ca50924..7c14efa1 100644 --- a/src/d3d9/d3d9_device.cpp +++ b/src/d3d9/d3d9_device.cpp @@ -1,6 +1,7 @@ #include "d3d9_device.h" #include "d3d9_annotation.h" +#include "d3d9_common_texture.h" #include "d3d9_interface.h" #include "d3d9_swapchain.h" #include "d3d9_caps.h" @@ -39,18 +40,25 @@ namespace dxvk { HWND hFocusWindow, DWORD BehaviorFlags, Rc dxvkDevice) - : m_parent ( pParent ) - , m_deviceType ( DeviceType ) - , m_window ( hFocusWindow ) - , m_behaviorFlags ( BehaviorFlags ) - , m_adapter ( pAdapter ) - , m_dxvkDevice ( dxvkDevice ) - , m_shaderModules ( new D3D9ShaderModuleSet ) - , m_d3d9Options ( dxvkDevice, pParent->GetInstance()->config() ) - , m_multithread ( BehaviorFlags & D3DCREATE_MULTITHREADED ) - , m_isSWVP ( (BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING) ? true : false ) - , m_csThread ( dxvkDevice, dxvkDevice->createContext() ) - , m_csChunk ( AllocCsChunk() ) { + : m_parent ( pParent ) + , m_deviceType ( DeviceType ) + , m_window ( hFocusWindow ) + , m_behaviorFlags ( BehaviorFlags ) + , m_adapter ( pAdapter ) + , m_dxvkDevice ( dxvkDevice ) + , m_memoryAllocator ( ) + , m_shaderAllocator ( ) + , m_shaderModules ( new D3D9ShaderModuleSet ) + , m_stagingBuffer ( dxvkDevice, StagingBufferSize ) + , m_d3d9Options ( dxvkDevice, pParent->GetInstance()->config() ) + , m_multithread ( BehaviorFlags & D3DCREATE_MULTITHREADED ) + , m_isSWVP ( (BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING) ? true : false ) + , m_csThread ( dxvkDevice, dxvkDevice->createContext(DxvkContextType::Primary) ) + , m_csChunk ( AllocCsChunk() ) + , m_submissionFence (new sync::Fence()) + , m_d3d9Interop ( this ) + , m_d3d9On12 ( this ) + , m_d3d8Bridge ( this ) { // If we can SWVP, then we use an extended constant set // as SWVP has many more slots available than HWVP. bool canSWVP = CanSWVP(); @@ -108,10 +116,35 @@ namespace dxvk { } } + m_usingGraphicsPipelines = dxvkDevice->features().extGraphicsPipelineLibrary.graphicsPipelineLibrary; + + m_depthBiasRepresentation = { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, false }; + if (dxvkDevice->features().extDepthBiasControl.depthBiasControl) { + if (dxvkDevice->features().extDepthBiasControl.depthBiasExact) + m_depthBiasRepresentation.depthBiasExact = true; + + if (dxvkDevice->features().extDepthBiasControl.floatRepresentation) { + m_depthBiasRepresentation.depthBiasRepresentation = VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT; + m_depthBiasScale = 1.0f; + } + else if (dxvkDevice->features().extDepthBiasControl.leastRepresentableValueForceUnormRepresentation) + m_depthBiasRepresentation.depthBiasRepresentation = VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT; + } + + EmitCs([ + cRepresentation = m_depthBiasRepresentation + ] (DxvkContext* ctx) { + ctx->setDepthBiasRepresentation(cRepresentation); + }); + CreateConstantBuffers(); m_availableMemory = DetermineInitialTextureMemory(); + m_hazardLayout = dxvkDevice->features().extAttachmentFeedbackLoopLayout.attachmentFeedbackLoopLayout + ? VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT + : VK_IMAGE_LAYOUT_GENERAL; + // Initially set all the dirty flags so we // always end up giving the backend *something* to work with. m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); @@ -141,10 +174,24 @@ namespace dxvk { m_flags.set(D3D9DeviceFlag::DirtySharedPixelShaderData); m_flags.set(D3D9DeviceFlag::DirtyDepthBounds); m_flags.set(D3D9DeviceFlag::DirtyPointScale); + + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + + // Bitfields can't be initialized in header. + m_boundRTs = 0; + m_anyColorWrites = 0; + m_activeRTsWhichAreTextures = 0; + m_alphaSwizzleRTs = 0; + m_lastHazardsRT = 0; } D3D9DeviceEx::~D3D9DeviceEx() { + // Avoids hanging when in this state, see comment + // in DxvkDevice::~DxvkDevice. + if (this_thread::isInModuleDetachment()) + return; + Flush(); SynchronizeCsThread(DxvkCsThread::SynchronizeAll); @@ -173,20 +220,46 @@ namespace dxvk { *ppvObject = ref(this); return S_OK; } + + if (riid == __uuidof(IDxvkD3D8Bridge)) { + *ppvObject = ref(&m_d3d8Bridge); + return S_OK; + } + + if (riid == __uuidof(ID3D9VkInteropDevice)) { + *ppvObject = ref(&m_d3d9Interop); + return S_OK; + } + + if (riid == __uuidof(IDirect3DDevice9On12)) { + *ppvObject = ref(&m_d3d9On12); + return S_OK; + } // We want to ignore this if the extended device is queried and we weren't made extended. if (riid == __uuidof(IDirect3DDevice9Ex)) return E_NOINTERFACE; - Logger::warn("D3D9DeviceEx::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(IDirect3DDevice9), riid)) { + Logger::warn("D3D9DeviceEx::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } HRESULT STDMETHODCALLTYPE D3D9DeviceEx::TestCooperativeLevel() { + D3D9DeviceLock lock = LockDevice(); + // Equivelant of D3D11/DXGI present tests. We can always present. - return D3D_OK; + if (likely(m_deviceLostState == D3D9DeviceLostState::Ok)) { + return D3D_OK; + } else if (m_deviceLostState == D3D9DeviceLostState::NotReset) { + return D3DERR_DEVICENOTRESET; + } else { + return D3DERR_DEVICELOST; + } } @@ -220,7 +293,15 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9DeviceEx::GetDeviceCaps(D3DCAPS9* pCaps) { - return m_adapter->GetDeviceCaps(m_deviceType, pCaps); + if (pCaps == nullptr) + return D3DERR_INVALIDCALL; + + m_adapter->GetDeviceCaps(m_deviceType, pCaps); + + // When in SWVP mode, 256 matrices can be used for indexed vertex blending + pCaps->MaxVertexBlendMatrixIndex = m_isSWVP ? 255 : 8; + + return D3D_OK; } @@ -262,7 +343,9 @@ namespace dxvk { uint32_t inputHeight = cursorTex->Desc()->Height; // Always use a hardware cursor when windowed. - bool hwCursor = m_presentParams.Windowed; + D3DPRESENT_PARAMETERS params; + m_implicitSwapchain->GetPresentParameters(¶ms); + bool hwCursor = params.Windowed; // Always use a hardware cursor w/h <= 32 px hwCursor |= inputWidth <= HardwareCursorWidth @@ -356,13 +439,45 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9DeviceEx::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) { D3D9DeviceLock lock = LockDevice(); - HRESULT hr = ResetSwapChain(pPresentationParameters, nullptr); - if (FAILED(hr)) - return hr; + Logger::info("Device reset"); + m_deviceLostState = D3D9DeviceLostState::Ok; - hr = ResetState(pPresentationParameters); - if (FAILED(hr)) + if (!IsExtended()) { + // The internal references are always cleared, regardless of whether the Reset call succeeds. + ResetState(pPresentationParameters); + m_implicitSwapchain->DestroyBackBuffers(); + m_autoDepthStencil = nullptr; + } else { + // Extended devices only reset the bound render targets + for (uint32_t i = 0; i < caps::MaxSimultaneousRenderTargets; i++) { + SetRenderTargetInternal(i, nullptr); + } + SetDepthStencilSurface(nullptr); + } + + /* + * Before calling the IDirect3DDevice9::Reset method for a device, + * an application should release any explicit render targets, + * depth stencil surfaces, additional swap chains, state blocks, + * and D3DPOOL_DEFAULT resources associated with the device. + * + * We have to check after ResetState clears the references held by SetTexture, etc. + * This matches what Windows D3D9 does. + */ + if (unlikely(m_losableResourceCounter.load() != 0 && !IsExtended())) { + Logger::warn(str::format("Device reset failed because device still has alive losable resources: Device not reset. Remaining resources: ", m_losableResourceCounter.load())); + m_deviceLostState = D3D9DeviceLostState::NotReset; + return D3DERR_INVALIDCALL; + } + + HRESULT hr = ResetSwapChain(pPresentationParameters, nullptr); + if (FAILED(hr)) { + if (!IsExtended()) { + Logger::warn("Device reset failed: Device not reset"); + m_deviceLostState = D3D9DeviceLostState::NotReset; + } return hr; + } Flush(); SynchronizeCsThread(DxvkCsThread::SynchronizeAll); @@ -459,6 +574,12 @@ namespace dxvk { desc.MultisampleQuality = 0; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = FALSE; + // Docs: + // Textures placed in the D3DPOOL_DEFAULT pool cannot be locked + // unless they are dynamic textures or they are private, FOURCC, driver formats. + desc.IsLockable = Pool != D3DPOOL_DEFAULT + || (Usage & D3DUSAGE_DYNAMIC) + || IsVendorFormat(EnumerateFormat(Format)); if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -479,6 +600,9 @@ namespace dxvk { m_initializer->InitTexture(texture->GetCommonTexture(), initialData); *ppTexture = texture.ref(); + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError& e) { @@ -520,6 +644,12 @@ namespace dxvk { desc.MultisampleQuality = 0; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = FALSE; + // Docs: + // Textures placed in the D3DPOOL_DEFAULT pool cannot be locked + // unless they are dynamic textures or they are private, FOURCC, driver formats. + desc.IsLockable = Pool != D3DPOOL_DEFAULT + || (Usage & D3DUSAGE_DYNAMIC) + || IsVendorFormat(EnumerateFormat(Format)); if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -528,6 +658,9 @@ namespace dxvk { const Com texture = new D3D9Texture3D(this, &desc); m_initializer->InitTexture(texture->GetCommonTexture()); *ppVolumeTexture = texture.ref(); + + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; return D3D_OK; } @@ -568,6 +701,12 @@ namespace dxvk { desc.MultisampleQuality = 0; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = FALSE; + // Docs: + // Textures placed in the D3DPOOL_DEFAULT pool cannot be locked + // unless they are dynamic textures or they are private, FOURCC, driver formats. + desc.IsLockable = Pool != D3DPOOL_DEFAULT + || (Usage & D3DUSAGE_DYNAMIC) + || IsVendorFormat(EnumerateFormat(Format)); if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -576,6 +715,9 @@ namespace dxvk { const Com texture = new D3D9TextureCube(this, &desc); m_initializer->InitTexture(texture->GetCommonTexture()); *ppCubeTexture = texture.ref(); + + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; return D3D_OK; } @@ -616,6 +758,9 @@ namespace dxvk { const Com buffer = new D3D9VertexBuffer(this, &desc); m_initializer->InitBuffer(buffer->GetCommonBuffer()); *ppVertexBuffer = buffer.ref(); + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError & e) { @@ -654,6 +799,9 @@ namespace dxvk { const Com buffer = new D3D9IndexBuffer(this, &desc); m_initializer->InitBuffer(buffer->GetCommonBuffer()); *ppIndexBuffer = buffer.ref(); + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError & e) { @@ -729,7 +877,13 @@ namespace dxvk { if (unlikely(srcTextureInfo->Desc()->Format != dstTextureInfo->Desc()->Format)) return D3DERR_INVALIDCALL; - const DxvkFormatInfo* formatInfo = imageFormatInfo(dstTextureInfo->GetFormatMapping().FormatColor); + if (unlikely(srcTextureInfo->Desc()->MultiSample != D3DMULTISAMPLE_NONE)) + return D3DERR_INVALIDCALL; + + if (unlikely(dstTextureInfo->Desc()->MultiSample != D3DMULTISAMPLE_NONE)) + return D3DERR_INVALIDCALL; + + const DxvkFormatInfo* formatInfo = lookupFormatInfo(dstTextureInfo->GetFormatMapping().FormatColor); VkOffset3D srcOffset = { 0u, 0u, 0u }; VkOffset3D dstOffset = { 0u, 0u, 0u }; @@ -806,9 +960,19 @@ namespace dxvk { uint32_t mipLevels = dstTexInfo->IsAutomaticMip() ? 1 : dstTexInfo->Desc()->MipLevels; uint32_t arraySlices = std::min(srcTexInfo->Desc()->ArraySize, dstTexInfo->Desc()->ArraySize); - uint32_t srcMipOffset = srcTexInfo->Desc()->MipLevels - mipLevels; - VkExtent3D srcFirstMipExtent = util::computeMipLevelExtent(srcTexInfo->GetExtent(), srcMipOffset); + uint32_t srcMipOffset = 0; + VkExtent3D srcFirstMipExtent = srcTexInfo->GetExtent(); VkExtent3D dstFirstMipExtent = dstTexInfo->GetExtent(); + + if (srcFirstMipExtent != dstFirstMipExtent) { + // UpdateTexture can be used with textures that have different mip lengths. + // It will either match the the top mips or the bottom ones. + + srcMipOffset = srcTexInfo->Desc()->MipLevels - mipLevels; + srcFirstMipExtent = util::computeMipLevelExtent(srcTexInfo->GetExtent(), srcMipOffset); + dstFirstMipExtent = dstTexInfo->GetExtent(); + } + if (srcFirstMipExtent != dstFirstMipExtent) return D3DERR_INVALIDCALL; @@ -840,7 +1004,7 @@ namespace dxvk { if (dstTexInfo->IsAutomaticMip() && mipLevels != dstTexInfo->Desc()->MipLevels) MarkTextureMipsDirty(dstTexInfo); - FlushImplicit(false); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); return D3D_OK; } @@ -851,6 +1015,10 @@ namespace dxvk { IDirect3DSurface9* pDestSurface) { D3D9DeviceLock lock = LockDevice(); + if (unlikely(IsDeviceLost())) { + return D3DERR_DEVICELOST; + } + D3D9Surface* src = static_cast(pRenderTarget); D3D9Surface* dst = static_cast(pDestSurface); @@ -869,10 +1037,17 @@ namespace dxvk { if (dstTexInfo->Desc()->Pool == D3DPOOL_DEFAULT) return this->StretchRect(pRenderTarget, nullptr, pDestSurface, nullptr, D3DTEXF_NONE); - Rc dstBuffer = dstTexInfo->GetBuffer(dst->GetSubresource()); + VkExtent3D dstTexExtent = dstTexInfo->GetExtentMip(dst->GetMipLevel()); + VkExtent3D srcTexExtent = srcTexInfo->GetExtentMip(src->GetMipLevel()); - Rc srcImage = srcTexInfo->GetImage(); - const DxvkFormatInfo* srcFormatInfo = imageFormatInfo(srcImage->info().format); + const bool clearDst = dstTexInfo->Desc()->MipLevels > 1 + || dstTexExtent.width > srcTexExtent.width + || dstTexExtent.height > srcTexExtent.height; + + dstTexInfo->CreateBuffer(clearDst); + DxvkBufferSlice dstBufferSlice = dstTexInfo->GetBufferSlice(dst->GetSubresource()); + Rc srcImage = srcTexInfo->GetImage(); + const DxvkFormatInfo* srcFormatInfo = lookupFormatInfo(srcImage->info().format); const VkImageSubresource srcSubresource = srcTexInfo->GetSubresourceFromIndex(srcFormatInfo->aspectMask, src->GetSubresource()); VkImageSubresourceLayers srcSubresourceLayers = { @@ -880,22 +1055,13 @@ namespace dxvk { srcSubresource.mipLevel, srcSubresource.arrayLayer, 1 }; - VkExtent3D srcExtent = srcTexInfo->GetExtentMip(src->GetMipLevel()); - - VkExtent3D texLevelExtentBlockCount = util::computeBlockCount(srcExtent, srcFormatInfo->blockSize); - VkDeviceSize pitch = align(texLevelExtentBlockCount.width * uint32_t(srcFormatInfo->elementSize), 4); - uint32_t pitchBlocks = uint32_t(pitch / srcFormatInfo->elementSize); - VkExtent2D dstExtent = VkExtent2D{ pitchBlocks, - texLevelExtentBlockCount.height * pitchBlocks }; - EmitCs([ - cBuffer = dstBuffer, + cBufferSlice = std::move(dstBufferSlice), cImage = srcImage, cSubresources = srcSubresourceLayers, - cLevelExtent = srcExtent, - cDstExtent = dstExtent + cLevelExtent = srcTexExtent ] (DxvkContext* ctx) { - ctx->copyImageToBuffer(cBuffer, 0, 4, 0, + ctx->copyImageToBuffer(cBufferSlice.buffer(), cBufferSlice.offset(), 4, 0, cImage, cSubresources, VkOffset3D { 0, 0, 0 }, cLevelExtent); }); @@ -944,8 +1110,11 @@ namespace dxvk { Rc dstImage = dstTextureInfo->GetImage(); Rc srcImage = srcTextureInfo->GetImage(); - const DxvkFormatInfo* dstFormatInfo = imageFormatInfo(dstImage->info().format); - const DxvkFormatInfo* srcFormatInfo = imageFormatInfo(srcImage->info().format); + if (dstImage == nullptr || srcImage == nullptr) + return D3DERR_INVALIDCALL; + + const DxvkFormatInfo* dstFormatInfo = lookupFormatInfo(dstImage->info().format); + const DxvkFormatInfo* srcFormatInfo = lookupFormatInfo(srcImage->info().format); const VkImageSubresource dstSubresource = dstTextureInfo->GetSubresourceFromIndex(dstFormatInfo->aspectMask, dst->GetSubresource()); const VkImageSubresource srcSubresource = srcTextureInfo->GetSubresourceFromIndex(srcFormatInfo->aspectMask, src->GetSubresource()); @@ -1062,8 +1231,8 @@ namespace dxvk { else { ctx->resolveDepthStencilImage( cDstImage, cSrcImage, cRegion, - VK_RESOLVE_MODE_AVERAGE_BIT_KHR, - VK_RESOLVE_MODE_AVERAGE_BIT_KHR); + VK_RESOLVE_MODE_AVERAGE_BIT, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); } }); }; @@ -1215,14 +1384,22 @@ namespace dxvk { 0); } - HRESULT STDMETHODCALLTYPE D3D9DeviceEx::SetRenderTarget( DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) { D3D9DeviceLock lock = LockDevice(); - if (unlikely(RenderTargetIndex >= caps::MaxSimultaneousRenderTargets - || (pRenderTarget == nullptr && RenderTargetIndex == 0))) + if (unlikely((pRenderTarget == nullptr && RenderTargetIndex == 0))) + return D3DERR_INVALIDCALL; + + return SetRenderTargetInternal(RenderTargetIndex, pRenderTarget); + } + + + HRESULT STDMETHODCALLTYPE D3D9DeviceEx::SetRenderTargetInternal( + DWORD RenderTargetIndex, + IDirect3DSurface9* pRenderTarget) { + if (unlikely(RenderTargetIndex >= caps::MaxSimultaneousRenderTargets)) return D3DERR_INVALIDCALL; D3D9Surface* rt = static_cast(pRenderTarget); @@ -1234,21 +1411,28 @@ namespace dxvk { return D3DERR_INVALIDCALL; if (RenderTargetIndex == 0) { - auto rtSize = rt->GetSurfaceExtent(); - D3DVIEWPORT9 viewport; viewport.X = 0; viewport.Y = 0; - viewport.Width = rtSize.width; - viewport.Height = rtSize.height; viewport.MinZ = 0.0f; viewport.MaxZ = 1.0f; RECT scissorRect; scissorRect.left = 0; scissorRect.top = 0; - scissorRect.right = rtSize.width; - scissorRect.bottom = rtSize.height; + + if (likely(rt != nullptr)) { + auto rtSize = rt->GetSurfaceExtent(); + viewport.Width = rtSize.width; + viewport.Height = rtSize.height; + scissorRect.right = rtSize.width; + scissorRect.bottom = rtSize.height; + } else { + viewport.Width = 0; + viewport.Height = 0; + scissorRect.right = 0; + scissorRect.bottom = 0; + } if (m_state.viewport != viewport) { m_flags.set(D3D9DeviceFlag::DirtyFFViewport); @@ -1267,7 +1451,9 @@ namespace dxvk { return D3D_OK; // Do a strong flush if the first render target is changed. - FlushImplicit(RenderTargetIndex == 0 ? TRUE : FALSE); + ConsiderFlush(RenderTargetIndex == 0 + ? GpuFlushType::ImplicitStrongHint + : GpuFlushType::ImplicitWeakHint); m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); m_state.renderTargets[RenderTargetIndex] = rt; @@ -1291,13 +1477,23 @@ namespace dxvk { m_flags.set(D3D9DeviceFlag::DirtyBlendState); if (RenderTargetIndex == 0) { - bool validSampleMask = texInfo->Desc()->MultiSample > D3DMULTISAMPLE_NONMASKABLE; + if (likely(texInfo != nullptr)) { + if (IsAlphaTestEnabled()) { + // Need to recalculate the precision. + m_flags.set(D3D9DeviceFlag::DirtyAlphaTestState); + } - if (validSampleMask != m_flags.test(D3D9DeviceFlag::ValidSampleMask)) { + bool validSampleMask = texInfo->Desc()->MultiSample > D3DMULTISAMPLE_NONMASKABLE; + + if (validSampleMask != m_flags.test(D3D9DeviceFlag::ValidSampleMask)) { + m_flags.clr(D3D9DeviceFlag::ValidSampleMask); + if (validSampleMask) + m_flags.set(D3D9DeviceFlag::ValidSampleMask); + + m_flags.set(D3D9DeviceFlag::DirtyMultiSampleState); + } + } else { m_flags.clr(D3D9DeviceFlag::ValidSampleMask); - if (validSampleMask) - m_flags.set(D3D9DeviceFlag::ValidSampleMask); - m_flags.set(D3D9DeviceFlag::DirtyMultiSampleState); } } @@ -1336,11 +1532,14 @@ namespace dxvk { if (m_state.depthStencil == ds) return D3D_OK; - FlushImplicit(FALSE); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); - if (ds != nullptr) { - float rValue = GetDepthBufferRValue(ds->GetCommonTexture()->GetFormatMapping().FormatColor); + if (ds != nullptr && m_depthBiasRepresentation.depthBiasRepresentation != VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT) { + const int32_t vendorId = m_dxvkDevice->adapter()->deviceProperties().vendorID; + const bool exact = m_depthBiasRepresentation.depthBiasExact; + const bool forceUnorm = m_depthBiasRepresentation.depthBiasRepresentation == VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT; + const float rValue = GetDepthBufferRValue(ds->GetCommonTexture()->GetFormatMapping().FormatColor, vendorId, exact, forceUnorm); if (m_depthBiasScale != rValue) { m_depthBiasScale = rValue; m_flags.set(D3D9DeviceFlag::DirtyDepthBias); @@ -1392,7 +1591,7 @@ namespace dxvk { if (unlikely(!m_flags.test(D3D9DeviceFlag::InScene))) return D3DERR_INVALIDCALL; - FlushImplicit(true); + ConsiderFlush(GpuFlushType::ImplicitStrongHint); m_flags.clr(D3D9DeviceFlag::InScene); @@ -1455,7 +1654,7 @@ namespace dxvk { if (Flags & D3DCLEAR_STENCIL) depthAspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; - depthAspectMask &= imageFormatInfo(m_state.depthStencil->GetCommonTexture()->GetFormatMapping().FormatColor)->aspectMask; + depthAspectMask &= lookupFormatInfo(m_state.depthStencil->GetCommonTexture()->GetFormatMapping().FormatColor)->aspectMask; } auto ClearImageView = [this]( @@ -1538,6 +1737,10 @@ namespace dxvk { // This works around that. uint32_t alignment = m_d3d9Options.lenientClear ? 8 : 1; + if (extent.width == 0 || extent.height == 0) { + return D3D_OK; + } + if (!Count) { // Clear our viewport & scissor minified region in this rendertarget. ClearViewRect(alignment, offset, extent); @@ -1551,6 +1754,11 @@ namespace dxvk { 0 }; + if (std::min(pRects[i].x2, offset.x + extent.width) <= rectOffset.x + || std::min(pRects[i].y2, offset.y + extent.height) <= rectOffset.y) { + continue; + } + VkExtent3D rectExtent = { std::min(pRects[i].x2, offset.x + extent.width) - rectOffset.x, std::min(pRects[i].y2, offset.y + extent.height) - rectOffset.y, @@ -1585,10 +1793,10 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9DeviceEx::MultiplyTransform(D3DTRANSFORMSTATETYPE TransformState, const D3DMATRIX* pMatrix) { D3D9DeviceLock lock = LockDevice(); - if (unlikely(ShouldRecord())) - return m_recorder->MultiplyStateTransform(TransformState, pMatrix); + const uint32_t idx = GetTransformIndex(TransformState); - uint32_t idx = GetTransformIndex(TransformState); + if (unlikely(ShouldRecord())) + return m_recorder->MultiplyStateTransform(idx, pMatrix); m_state.transforms[idx] = m_state.transforms[idx] * ConvertMatrix(pMatrix); @@ -1667,7 +1875,7 @@ namespace dxvk { return D3DERR_INVALIDCALL; if (unlikely(ShouldRecord())) { - Logger::warn("D3D9DeviceEx::SetLight: State block not implemented."); + m_recorder->SetLight(Index, pLight); return D3D_OK; } @@ -1701,6 +1909,11 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9DeviceEx::LightEnable(DWORD Index, BOOL Enable) { D3D9DeviceLock lock = LockDevice(); + if (unlikely(ShouldRecord())) { + m_recorder->LightEnable(Index, Enable); + return D3D_OK; + } + if (unlikely(Index >= m_state.lights.size())) m_state.lights.resize(Index + 1); @@ -1881,31 +2094,23 @@ namespace dxvk { break; case D3DRS_COLORWRITEENABLE: - if (likely(!old != !Value)) { - m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); - UpdateActiveRTs(0); - } + if (likely(!old != !Value)) + UpdateAnyColorWrites<0>(!!Value); m_flags.set(D3D9DeviceFlag::DirtyBlendState); break; case D3DRS_COLORWRITEENABLE1: - if (likely(!old != !Value && m_state.renderTargets[1] != nullptr)) { - m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); - UpdateActiveRTs(1); - } + if (likely(!old != !Value)) + UpdateAnyColorWrites<1>(!!Value); m_flags.set(D3D9DeviceFlag::DirtyBlendState); break; case D3DRS_COLORWRITEENABLE2: - if (likely(!old != !Value && m_state.renderTargets[2] != nullptr)) { - m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); - UpdateActiveRTs(2); - } + if (likely(!old != !Value)) + UpdateAnyColorWrites<2>(!!Value); m_flags.set(D3D9DeviceFlag::DirtyBlendState); break; case D3DRS_COLORWRITEENABLE3: - if (likely(!old != !Value && m_state.renderTargets[3] != nullptr)) { - m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); - UpdateActiveRTs(3); - } + if (likely(!old != !Value)) + UpdateAnyColorWrites<3>(!!Value); m_flags.set(D3D9DeviceFlag::DirtyBlendState); break; @@ -1935,8 +2140,11 @@ namespace dxvk { m_flags.set(D3D9DeviceFlag::DirtyMultiSampleState); break; - case D3DRS_STENCILENABLE: case D3DRS_ZWRITEENABLE: + if (likely(!old != !Value)) + UpdateActiveHazardsDS(UINT32_MAX); + [[fallthrough]]; + case D3DRS_STENCILENABLE: case D3DRS_ZENABLE: if (likely(m_state.depthStencil != nullptr)) m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); @@ -2077,13 +2285,7 @@ namespace dxvk { break; case D3DRS_SHADEMODE: - if (m_state.pixelShader != nullptr) { - BindShader( - GetCommonShader(m_state.pixelShader), - GetPixelShaderPermutation()); - } - - m_flags.set(D3D9DeviceFlag::DirtyFFPixelShader); + m_flags.set(D3D9DeviceFlag::DirtyRasterizerState); break; case D3DRS_TWEENFACTOR: @@ -2106,6 +2308,9 @@ namespace dxvk { case D3DRS_ADAPTIVETESS_W: if (states[D3DRS_ADAPTIVETESS_X] == uint32_t(D3D9Format::NVDB) || oldNVDB) { m_flags.set(D3D9DeviceFlag::DirtyDepthBounds); + + if (m_state.depthStencil != nullptr && m_state.renderStates[D3DRS_ZENABLE]) + m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); break; } [[fallthrough]]; @@ -2155,6 +2360,8 @@ namespace dxvk { try { const Com sb = new D3D9StateBlock(this, ConvertStateBlockType(Type)); *ppSB = sb.ref(); + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError & e) { @@ -2185,6 +2392,7 @@ namespace dxvk { return D3DERR_INVALIDCALL; *ppSB = m_recorder.ref(); + m_losableResourceCounter++; m_recorder = nullptr; return D3D_OK; @@ -2241,13 +2449,8 @@ namespace dxvk { if (unlikely(pValue == nullptr)) return D3DERR_INVALIDCALL; - *pValue = 0; - - if (unlikely(Stage >= caps::TextureStageCount)) - return D3DERR_INVALIDCALL; - - if (unlikely(dxvkType >= TextureStageStateCount)) - return D3DERR_INVALIDCALL; + Stage = std::min(Stage, DWORD(caps::TextureStageCount - 1)); + dxvkType = std::min(dxvkType, D3D9TextureStageStateTypes(DXVK_TSS_COUNT - 1)); *pValue = m_state.textureStages[Stage][dxvkType]; @@ -2298,10 +2501,12 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9DeviceEx::ValidateDevice(DWORD* pNumPasses) { + D3D9DeviceLock lock = LockDevice(); + if (pNumPasses != nullptr) *pNumPasses = 1; - return D3D_OK; + return IsDeviceLost() ? D3DERR_DEVICELOST : D3D_OK; } @@ -2367,6 +2572,9 @@ namespace dxvk { if (bSoftware && !CanSWVP()) return D3DERR_INVALIDCALL; + if (!bSoftware && (m_behaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING)) + return D3DERR_INVALIDCALL; + m_isSWVP = bSoftware; return D3D_OK; @@ -2407,15 +2615,16 @@ namespace dxvk { EmitCs([this, cPrimType = PrimitiveType, cPrimCount = PrimitiveCount, - cStartVertex = StartVertex, - cInstanceCount = GetInstanceCount() + cStartVertex = StartVertex ](DxvkContext* ctx) { - auto drawInfo = GenerateDrawInfo(cPrimType, cPrimCount, cInstanceCount); + uint32_t vertexCount = GetVertexCount(cPrimType, cPrimCount); ApplyPrimitiveType(ctx, cPrimType); + // Tests on Windows show that D3D9 does not do non-indexed instanced draws. + ctx->draw( - drawInfo.vertexCount, drawInfo.instanceCount, + vertexCount, 1, cStartVertex, 0); }); @@ -2476,28 +2685,27 @@ namespace dxvk { PrepareDraw(PrimitiveType); - auto drawInfo = GenerateDrawInfo(PrimitiveType, PrimitiveCount, 0); + uint32_t vertexCount = GetVertexCount(PrimitiveType, PrimitiveCount); - const uint32_t dataSize = GetUPDataSize(drawInfo.vertexCount, VertexStreamZeroStride); - const uint32_t bufferSize = GetUPBufferSize(drawInfo.vertexCount, VertexStreamZeroStride); + const uint32_t dataSize = GetUPDataSize(vertexCount, VertexStreamZeroStride); + const uint32_t bufferSize = GetUPBufferSize(vertexCount, VertexStreamZeroStride); - auto upSlice = AllocTempBuffer(bufferSize); + auto upSlice = AllocUPBuffer(bufferSize); FillUPVertexBuffer(upSlice.mapPtr, pVertexStreamZeroData, dataSize, bufferSize); EmitCs([this, cBufferSlice = std::move(upSlice.slice), cPrimType = PrimitiveType, - cPrimCount = PrimitiveCount, - cInstanceCount = GetInstanceCount(), - cStride = VertexStreamZeroStride - ](DxvkContext* ctx) { - auto drawInfo = GenerateDrawInfo(cPrimType, cPrimCount, cInstanceCount); - + cStride = VertexStreamZeroStride, + cVertexCount = vertexCount + ](DxvkContext* ctx) mutable { ApplyPrimitiveType(ctx, cPrimType); - ctx->bindVertexBuffer(0, cBufferSlice, cStride); + // Tests on Windows show that D3D9 does not do non-indexed instanced draws. + + ctx->bindVertexBuffer(0, std::move(cBufferSlice), cStride); ctx->draw( - drawInfo.vertexCount, drawInfo.instanceCount, + cVertexCount, 1, 0, 0); ctx->bindVertexBuffer(0, DxvkBufferSlice(), 0); }); @@ -2529,17 +2737,17 @@ namespace dxvk { PrepareDraw(PrimitiveType); - auto drawInfo = GenerateDrawInfo(PrimitiveType, PrimitiveCount, 0); + uint32_t vertexCount = GetVertexCount(PrimitiveType, PrimitiveCount); const uint32_t vertexDataSize = GetUPDataSize(MinVertexIndex + NumVertices, VertexStreamZeroStride); const uint32_t vertexBufferSize = GetUPBufferSize(MinVertexIndex + NumVertices, VertexStreamZeroStride); const uint32_t indexSize = IndexDataFormat == D3DFMT_INDEX16 ? 2 : 4; - const uint32_t indicesSize = drawInfo.vertexCount * indexSize; + const uint32_t indicesSize = vertexCount * indexSize; const uint32_t upSize = vertexBufferSize + indicesSize; - auto upSlice = AllocTempBuffer(upSize); + auto upSlice = AllocUPBuffer(upSize); uint8_t* data = reinterpret_cast(upSlice.mapPtr); FillUPVertexBuffer(data, pVertexStreamZeroData, vertexDataSize, vertexBufferSize); std::memcpy(data + vertexBufferSize, pIndexData, indicesSize); @@ -2587,9 +2795,18 @@ namespace dxvk { DWORD Flags) { D3D9DeviceLock lock = LockDevice(); - if (unlikely(pDestBuffer == nullptr || pVertexDecl == nullptr)) + if (unlikely(pDestBuffer == nullptr)) return D3DERR_INVALIDCALL; + // When vertex shader 3.0 or above is set as the current vertex shader, + // the output vertex declaration must be present. + if (UseProgrammableVS()) { + const auto& programInfo = GetCommonShader(m_state.vertexShader)->GetInfo(); + + if (unlikely(programInfo.majorVersion() >= 3) && (pVertexDecl == nullptr)) + return D3DERR_INVALIDCALL; + } + if (!SupportsSWVP()) { static bool s_errorShown = false; @@ -2630,9 +2847,8 @@ namespace dxvk { cVertexCount = VertexCount, cStartIndex = SrcStartIndex, cInstanceCount = GetInstanceCount(), - cBufferSlice = slice, - cIndexed = m_state.indices != nullptr - ](DxvkContext* ctx) { + cBufferSlice = slice + ](DxvkContext* ctx) mutable { Rc shader = m_swvpEmulator.GetShaderModule(this, cDecl); auto drawInfo = GenerateDrawInfo(D3DPT_POINTLIST, cVertexCount, cInstanceCount); @@ -2647,15 +2863,15 @@ namespace dxvk { // Unbind the pixel shader, we aren't drawing // to avoid val errors / UB. - ctx->bindShader(VK_SHADER_STAGE_FRAGMENT_BIT, nullptr); + ctx->bindShader(nullptr); - ctx->bindShader(VK_SHADER_STAGE_GEOMETRY_BIT, shader); - ctx->bindResourceBuffer(getSWVPBufferSlot(), cBufferSlice); + ctx->bindShader(std::move(shader)); + ctx->bindUniformBuffer(VK_SHADER_STAGE_GEOMETRY_BIT, getSWVPBufferSlot(), std::move(cBufferSlice)); ctx->draw( drawInfo.vertexCount, drawInfo.instanceCount, cStartIndex, 0); - ctx->bindResourceBuffer(getSWVPBufferSlot(), DxvkBufferSlice()); - ctx->bindShader(VK_SHADER_STAGE_GEOMETRY_BIT, nullptr); + ctx->bindUniformBuffer(VK_SHADER_STAGE_GEOMETRY_BIT, getSWVPBufferSlot(), DxvkBufferSlice()); + ctx->bindShader(nullptr); }); // We unbound the pixel shader before, @@ -2664,8 +2880,7 @@ namespace dxvk { if (m_state.pixelShader != nullptr) { BindShader( - GetCommonShader(m_state.pixelShader), - GetPixelShaderPermutation()); + GetCommonShader(m_state.pixelShader)); } if (dst->GetMapMode() == D3D9_COMMON_BUFFER_MAP_MODE_BUFFER) { @@ -2806,14 +3021,20 @@ namespace dxvk { moduleInfo.options = m_dxsoOptions; D3D9CommonShader module; + uint32_t bytecodeLength; if (FAILED(this->CreateShaderModule(&module, + &bytecodeLength, VK_SHADER_STAGE_VERTEX_BIT, pFunction, &moduleInfo))) return D3DERR_INVALIDCALL; - *ppShader = ref(new D3D9VertexShader(this, module)); + *ppShader = ref(new D3D9VertexShader(this, + &m_shaderAllocator, + module, + pFunction, + bytecodeLength)); return D3D_OK; } @@ -2852,10 +3073,7 @@ namespace dxvk { m_flags.clr(D3D9DeviceFlag::DirtyProgVertexShader); m_flags.set(D3D9DeviceFlag::DirtyFFVertexShader); - BindShader( - GetCommonShader(shader), - GetVertexShaderPermutation()); - + BindShader(GetCommonShader(shader)); m_vsShaderMasks = newShader->GetShaderMask(); } else @@ -3138,14 +3356,20 @@ namespace dxvk { moduleInfo.options = m_dxsoOptions; D3D9CommonShader module; + uint32_t bytecodeLength; if (FAILED(this->CreateShaderModule(&module, + &bytecodeLength, VK_SHADER_STAGE_FRAGMENT_BIT, pFunction, &moduleInfo))) return D3DERR_INVALIDCALL; - *ppShader = ref(new D3D9PixelShader(this, module)); + *ppShader = ref(new D3D9PixelShader(this, + &m_shaderAllocator, + module, + pFunction, + bytecodeLength)); return D3D_OK; } @@ -3180,24 +3404,36 @@ namespace dxvk { m_state.pixelShader = shader; + D3D9ShaderMasks newShaderMasks; + if (shader != nullptr) { m_flags.set(D3D9DeviceFlag::DirtyFFPixelShader); - BindShader( - GetCommonShader(shader), - GetPixelShaderPermutation()); - - m_psShaderMasks = newShader->GetShaderMask(); + BindShader(newShader); + newShaderMasks = newShader->GetShaderMask(); } else { // TODO: What fixed function textures are in use? // Currently we are making all 8 of them as in use here. // The RT output is always 0 for fixed function. - m_psShaderMasks = FixedFunctionMask; + newShaderMasks = FixedFunctionMask; } - UpdateActiveHazardsRT(UINT32_MAX); + // If we have any RTs we would have bound to the the FB + // not in the new shader mask, mark the framebuffer as dirty + // so we unbind them. + uint32_t oldUseMask = m_boundRTs & m_anyColorWrites & m_psShaderMasks.rtMask; + uint32_t newUseMask = m_boundRTs & m_anyColorWrites & newShaderMasks.rtMask; + if (oldUseMask != newUseMask) + m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); + + if (m_psShaderMasks.samplerMask != newShaderMasks.samplerMask || + m_psShaderMasks.rtMask != newShaderMasks.rtMask) { + m_psShaderMasks = newShaderMasks; + UpdateActiveHazardsRT(UINT32_MAX); + UpdateActiveHazardsDS(UINT32_MAX); + } return D3D_OK; } @@ -3488,6 +3724,7 @@ namespace dxvk { desc.MultisampleQuality = MultisampleQuality; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = TRUE; + desc.IsLockable = Lockable; if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -3496,6 +3733,8 @@ namespace dxvk { const Com surface = new D3D9Surface(this, &desc, nullptr, pSharedHandle); m_initializer->InitTexture(surface->GetCommonTexture()); *ppSurface = surface.ref(); + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError& e) { @@ -3532,6 +3771,8 @@ namespace dxvk { desc.MultisampleQuality = 0; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = Pool == D3DPOOL_DEFAULT; + // Docs: Off-screen plain surfaces are always lockable, regardless of their pool types. + desc.IsLockable = TRUE; if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -3543,6 +3784,10 @@ namespace dxvk { const Com surface = new D3D9Surface(this, &desc, nullptr, pSharedHandle); m_initializer->InitTexture(surface->GetCommonTexture()); *ppSurface = surface.ref(); + + if (desc.Pool == D3DPOOL_DEFAULT) + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError& e) { @@ -3581,6 +3826,8 @@ namespace dxvk { desc.MultisampleQuality = MultisampleQuality; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = TRUE; + // Docs don't say anything, so just assume it's lockable. + desc.IsLockable = TRUE; if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_INVALIDCALL; @@ -3589,6 +3836,8 @@ namespace dxvk { const Com surface = new D3D9Surface(this, &desc, nullptr, pSharedHandle); m_initializer->InitTexture(surface->GetCommonTexture()); *ppSurface = surface.ref(); + m_losableResourceCounter++; + return D3D_OK; } catch (const DxvkError& e) { @@ -3641,11 +3890,16 @@ namespace dxvk { if (!m_implicitSwapchain->GetPresentParams()->Windowed) return D3DERR_INVALIDCALL; + if (unlikely(IsDeviceLost())) { + return D3DERR_DEVICELOST; + } + m_implicitSwapchain->Invalidate(pPresentationParameters->hDeviceWindow); try { auto* swapchain = new D3D9SwapChainEx(this, pPresentationParameters, pFullscreenDisplayMode); *ppSwapChain = ref(swapchain); + m_losableResourceCounter++; } catch (const DxvkError & e) { Logger::err(e.message()); @@ -3672,6 +3926,8 @@ namespace dxvk { state[StateSampler][Type] = Value; + const uint32_t samplerBit = 1u << StateSampler; + if (Type == D3DSAMP_ADDRESSU || Type == D3DSAMP_ADDRESSV || Type == D3DSAMP_ADDRESSW @@ -3682,38 +3938,24 @@ namespace dxvk { || Type == D3DSAMP_MIPMAPLODBIAS || Type == D3DSAMP_MAXMIPLEVEL || Type == D3DSAMP_BORDERCOLOR) - m_dirtySamplerStates |= 1u << StateSampler; - else if (Type == D3DSAMP_SRGBTEXTURE && (m_activeTextures & (1u << StateSampler))) - m_dirtyTextures |= 1u << StateSampler; + m_dirtySamplerStates |= samplerBit; + else if (Type == D3DSAMP_SRGBTEXTURE && (m_activeTextures & samplerBit)) + m_dirtyTextures |= samplerBit; constexpr DWORD Fetch4Enabled = MAKEFOURCC('G', 'E', 'T', '4'); constexpr DWORD Fetch4Disabled = MAKEFOURCC('G', 'E', 'T', '1'); if (unlikely(Type == D3DSAMP_MIPMAPLODBIAS)) { - auto texture = GetCommonTexture(m_state.textures[StateSampler]); - bool textureSupportsFetch4 = texture != nullptr && texture->SupportsFetch4(); + if (unlikely(Value == Fetch4Enabled)) + m_fetch4Enabled |= samplerBit; + else if (unlikely(Value == Fetch4Disabled)) + m_fetch4Enabled &= ~samplerBit; - if (unlikely(Value == Fetch4Enabled)) { - m_fetch4Enabled |= 1u << StateSampler; - if (textureSupportsFetch4 && state[StateSampler][D3DSAMP_MAGFILTER] == D3DTEXF_POINT) { - m_fetch4 |= 1u << StateSampler; - } - } - else if (unlikely(Value == Fetch4Disabled)) { - m_fetch4Enabled &= ~(1u << StateSampler); - m_fetch4 &= ~(1u << StateSampler); - } + UpdateActiveFetch4(StateSampler); } - if (unlikely(Type == D3DSAMP_MAGFILTER && (m_fetch4Enabled & (1u << StateSampler)))) { - auto texture = GetCommonTexture(m_state.textures[StateSampler]); - bool textureSupportsFetch4 = texture != nullptr && texture->SupportsFetch4(); - - if (Value == D3DTEXF_POINT && textureSupportsFetch4) - m_fetch4 |= 1u << StateSampler; - else - m_fetch4 &= ~(1u << StateSampler); - } + if (unlikely(Type == D3DSAMP_MAGFILTER && (m_fetch4Enabled & samplerBit))) + UpdateActiveFetch4(StateSampler); return D3D_OK; } @@ -3751,41 +3993,37 @@ namespace dxvk { DWORD oldUsage = oldTexture != nullptr ? oldTexture->Desc()->Usage : 0; DWORD newUsage = newTexture != nullptr ? newTexture->Desc()->Usage : 0; + DWORD combinedUsage = oldUsage | newUsage; + TextureChangePrivate(m_state.textures[StateSampler], pTexture); + m_dirtyTextures |= 1u << StateSampler; + UpdateActiveTextures(StateSampler, combinedUsage); if (newTexture != nullptr) { const bool oldDepth = m_depthTextures & (1u << StateSampler); const bool newDepth = newTexture->IsShadow(); if (oldDepth != newDepth) { - m_depthTextures &= ~(1u << StateSampler); - if (newDepth) - m_depthTextures |= 1u << StateSampler; - + m_depthTextures ^= 1u << StateSampler; m_dirtySamplerStates |= 1u << StateSampler; } - if (unlikely(m_fetch4Enabled & (1u << StateSampler) && !(m_fetch4 & (1u << StateSampler)))) { - bool textureSupportsFetch4 = newTexture->SupportsFetch4(); - if (textureSupportsFetch4 - && m_state.samplerStates[StateSampler][D3DSAMP_MAGFILTER] == D3DTEXF_POINT - && m_state.samplerStates[StateSampler][D3DSAMP_MINFILTER] == D3DTEXF_POINT) { - m_fetch4 |= 1u << StateSampler; - m_dirtySamplerStates |= 1u << StateSampler; - } + m_drefClamp &= ~(1u << StateSampler); + m_drefClamp |= uint32_t(newTexture->IsUpgradedToD32f()) << StateSampler; + + const bool oldCube = m_cubeTextures & (1u << StateSampler); + const bool newCube = newTexture->GetType() == D3DRTYPE_CUBETEXTURE; + if (oldCube != newCube) { + m_cubeTextures ^= 1u << StateSampler; + m_dirtySamplerStates |= 1u << StateSampler; } - } else if (unlikely(m_fetch4 & (1u << StateSampler))) { - m_fetch4 &= ~(1u << StateSampler); - m_dirtySamplerStates |= 1u << StateSampler; + + if (unlikely(m_fetch4Enabled & (1u << StateSampler))) + UpdateActiveFetch4(StateSampler); + } else { + if (unlikely(m_fetch4 & (1u << StateSampler))) + UpdateActiveFetch4(StateSampler); } - DWORD combinedUsage = oldUsage | newUsage; - - TextureChangePrivate(m_state.textures[StateSampler], pTexture); - - m_dirtyTextures |= 1u << StateSampler; - - UpdateActiveTextures(StateSampler, combinedUsage); - return D3D_OK; } @@ -3811,14 +4049,14 @@ namespace dxvk { DWORD Stage, D3D9TextureStageStateTypes Type, DWORD Value) { + + // Clamp values instead of checking and returning INVALID_CALL + // Matches tests + Dawn of Magic 2 relies on it. + Stage = std::min(Stage, DWORD(caps::TextureStageCount - 1)); + Type = std::min(Type, D3D9TextureStageStateTypes(DXVK_TSS_COUNT - 1)); + D3D9DeviceLock lock = LockDevice(); - if (unlikely(Stage >= caps::TextureStageCount)) - return D3DERR_INVALIDCALL; - - if (unlikely(Type >= TextureStageStateCount)) - return D3DERR_INVALIDCALL; - if (unlikely(ShouldRecord())) return m_recorder->SetStateTextureStageState(Stage, Type, Value); @@ -3891,23 +4129,20 @@ namespace dxvk { // Geometry shaders are used for some meta ops enabled.core.features.geometryShader = VK_TRUE; enabled.core.features.robustBufferAccess = VK_TRUE; - enabled.extRobustness2.robustBufferAccess2 = supported.extRobustness2.robustBufferAccess2; + + enabled.vk12.samplerMirrorClampToEdge = VK_TRUE; + + enabled.vk13.shaderDemoteToHelperInvocation = VK_TRUE; enabled.extMemoryPriority.memoryPriority = supported.extMemoryPriority.memoryPriority; - enabled.extShaderDemoteToHelperInvocation.shaderDemoteToHelperInvocation = supported.extShaderDemoteToHelperInvocation.shaderDemoteToHelperInvocation; - enabled.extVertexAttributeDivisor.vertexAttributeInstanceRateDivisor = supported.extVertexAttributeDivisor.vertexAttributeInstanceRateDivisor; enabled.extVertexAttributeDivisor.vertexAttributeInstanceRateZeroDivisor = supported.extVertexAttributeDivisor.vertexAttributeInstanceRateZeroDivisor; - // Null Descriptors - enabled.extRobustness2.nullDescriptor = supported.extRobustness2.nullDescriptor; - // ProcessVertices enabled.core.features.vertexPipelineStoresAndAtomics = supported.core.features.vertexPipelineStoresAndAtomics; // DXVK Meta - enabled.core.features.shaderStorageImageWriteWithoutFormat = VK_TRUE; enabled.core.features.imageCubeArray = VK_TRUE; // SM1 level hardware @@ -3923,9 +4158,6 @@ namespace dxvk { // Ensure we support real BC formats and unofficial vendor ones. enabled.core.features.textureCompressionBC = VK_TRUE; - enabled.extDepthClipEnable.depthClipEnable = supported.extDepthClipEnable.depthClipEnable; - enabled.extHostQueryReset.hostQueryReset = VK_TRUE; - // SM2 level hardware enabled.core.features.occlusionQueryPrecise = VK_TRUE; @@ -3944,6 +4176,18 @@ namespace dxvk { enabled.extCustomBorderColor.customBorderColorWithoutFormat = VK_TRUE; } + if (supported.extAttachmentFeedbackLoopLayout.attachmentFeedbackLoopLayout) + enabled.extAttachmentFeedbackLoopLayout.attachmentFeedbackLoopLayout = VK_TRUE; + + enabled.extNonSeamlessCubeMap.nonSeamlessCubeMap = supported.extNonSeamlessCubeMap.nonSeamlessCubeMap; + + enabled.extDepthBiasControl.depthBiasControl = supported.extDepthBiasControl.depthBiasControl; + enabled.extDepthBiasControl.depthBiasExact = supported.extDepthBiasControl.depthBiasExact; + if (supported.extDepthBiasControl.floatRepresentation) + enabled.extDepthBiasControl.floatRepresentation = VK_TRUE; + else if (supported.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation) + enabled.extDepthBiasControl.leastRepresentableValueForceUnormRepresentation = VK_TRUE; + return enabled; } @@ -3961,82 +4205,148 @@ namespace dxvk { } - template - D3D9BufferSlice D3D9DeviceEx::AllocTempBuffer(VkDeviceSize size) { - constexpr VkDeviceSize DefaultSize = 1 << 20; + D3D9BufferSlice D3D9DeviceEx::AllocUPBuffer(VkDeviceSize size) { + constexpr VkDeviceSize UPBufferSize = 1 << 20; - VkMemoryPropertyFlags memoryFlags - = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT - | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; + if (unlikely(m_upBuffer == nullptr || size > UPBufferSize)) { + VkMemoryPropertyFlags memoryFlags + = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT + | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - if constexpr (UpBuffer) { - memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + DxvkBufferCreateInfo info; + info.size = std::max(UPBufferSize, size); + info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT + | VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + info.access = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT + | VK_ACCESS_INDEX_READ_BIT; + info.stages = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; + + Rc buffer = m_dxvkDevice->createBuffer(info, memoryFlags); + + if (size <= UPBufferSize) { + m_upBuffer = std::move(buffer); + m_upBufferMapPtr = m_upBuffer->mapPtr(0); + } else { + // Temporary buffer + D3D9BufferSlice result; + result.slice = DxvkBufferSlice(std::move(buffer), 0, size); + result.mapPtr = buffer->mapPtr(0); + return result; + } } - D3D9BufferSlice& currentSlice = UpBuffer ? m_upBuffer : m_managedUploadBuffer; + VkDeviceSize alignedSize = align(size, CACHE_LINE_SIZE); - if (size <= DefaultSize) { - if (unlikely(!currentSlice.slice.defined())) { - DxvkBufferCreateInfo info; - info.size = DefaultSize; - if constexpr (UpBuffer) { - info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT - | VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - info.access = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT - | VK_ACCESS_INDEX_READ_BIT; - info.stages = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; - } else { - info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; - info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; - info.access = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_READ_BIT; + if (unlikely(m_upBufferOffset + alignedSize > UPBufferSize)) { + auto sliceHandle = m_upBuffer->allocSlice(); + + m_upBufferOffset = 0; + m_upBufferMapPtr = sliceHandle.mapPtr; + + EmitCs([ + cBuffer = m_upBuffer, + cSlice = sliceHandle + ] (DxvkContext* ctx) { + ctx->invalidateBuffer(cBuffer, cSlice); + }); + } + + D3D9BufferSlice result; + result.slice = DxvkBufferSlice(m_upBuffer, m_upBufferOffset, size); + result.mapPtr = reinterpret_cast(m_upBufferMapPtr) + m_upBufferOffset; + + m_upBufferOffset += alignedSize; + return result; + } + + + D3D9BufferSlice D3D9DeviceEx::AllocStagingBuffer(VkDeviceSize size) { + m_stagingBufferAllocated += size; + + D3D9BufferSlice result; + result.slice = m_stagingBuffer.alloc(256, size); + result.mapPtr = result.slice.mapPtr(0); + return result; + } + + + void D3D9DeviceEx::EmitStagingBufferMarker() { + if (m_stagingBufferLastAllocated == m_stagingBufferAllocated) + return; + + D3D9StagingBufferMarkerPayload payload; + payload.sequenceNumber = GetCurrentSequenceNumber(); + payload.allocated = m_stagingBufferAllocated; + m_stagingBufferLastAllocated = m_stagingBufferAllocated; + + Rc marker = new D3D9StagingBufferMarker(payload); + m_stagingBufferMarkers.push(marker); + + EmitCs([ + cMarker = std::move(marker) + ] (DxvkContext* ctx) { + ctx->insertMarker(cMarker); + }); + } + + + void D3D9DeviceEx::WaitStagingBuffer() { + // The number below is not a hard limit, however we can be reasonably + // sure that there will never be more than two additional staging buffers + // in flight in addition to the number of staging buffers specified here. + constexpr VkDeviceSize maxStagingMemoryInFlight = env::is32BitHostPlatform() + ? StagingBufferSize * 4 + : StagingBufferSize * 16; + + // If the game uploads a significant amount of data at once, it's + // possible that we exceed the limit while the queue is empty. In + // that case, enforce a flush early to populate the marker queue. + bool didFlush = false; + + if (m_stagingBufferLastSignaled + maxStagingMemoryInFlight < m_stagingBufferAllocated + && m_stagingBufferMarkers.empty()) { + Flush(); + didFlush = true; + } + + // Process the marker queue. We'll remove as many markers as we + // can without stalling, and will stall until we're below the + // allocation limit again. + uint64_t lastSequenceNumber = m_csThread.lastSequenceNumber(); + + while (!m_stagingBufferMarkers.empty()) { + const auto& marker = m_stagingBufferMarkers.front(); + const auto& payload = marker->payload(); + + bool needsStall = m_stagingBufferLastSignaled + maxStagingMemoryInFlight < m_stagingBufferAllocated; + + if (payload.sequenceNumber > lastSequenceNumber) { + if (!needsStall) + break; + + SynchronizeCsThread(payload.sequenceNumber); + lastSequenceNumber = payload.sequenceNumber; + } + + if (marker->isInUse(DxvkAccess::Read)) { + if (!needsStall) + break; + + if (!didFlush) { + Flush(); + didFlush = true; } - currentSlice.slice = DxvkBufferSlice(m_dxvkDevice->createBuffer(info, memoryFlags)); - currentSlice.mapPtr = currentSlice.slice.mapPtr(0); - } else if (unlikely(currentSlice.slice.length() < size)) { - auto physSlice = currentSlice.slice.buffer()->allocSlice(); - - currentSlice.slice = DxvkBufferSlice(currentSlice.slice.buffer()); - currentSlice.mapPtr = physSlice.mapPtr; - - EmitCs([ - cBuffer = currentSlice.slice.buffer(), - cSlice = physSlice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); + m_dxvkDevice->waitForResource(marker, DxvkAccess::Read); } - D3D9BufferSlice result; - result.slice = currentSlice.slice.subSlice(0, size); - result.mapPtr = reinterpret_cast(currentSlice.mapPtr) + currentSlice.slice.offset(); - - VkDeviceSize adjust = align(size, CACHE_LINE_SIZE); - currentSlice.slice = currentSlice.slice.subSlice(adjust, currentSlice.slice.length() - adjust); - return result; - } else { - // Create a temporary buffer for very large allocations - DxvkBufferCreateInfo info; - info.size = size; - if constexpr (UpBuffer) { - info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT - | VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - info.access = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT - | VK_ACCESS_INDEX_READ_BIT; - info.stages = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; - } else { - info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; - info.stages = VK_PIPELINE_STAGE_TRANSFER_BIT; - info.access = VK_ACCESS_TRANSFER_READ_BIT; - } - - D3D9BufferSlice result; - result.slice = DxvkBufferSlice(m_dxvkDevice->createBuffer(info, memoryFlags)); - result.mapPtr = result.slice.mapPtr(0); - return result; + m_stagingBufferLastSignaled = marker->payload().allocated; + m_stagingBufferMarkers.pop(); } } + bool D3D9DeviceEx::ShouldRecord() { return m_recorder != nullptr && !m_recorder->IsApplying(); } @@ -4073,7 +4383,7 @@ namespace dxvk { // We don't have to wait, but misbehaving games may // still try to spin on `Map` until the resource is // idle, so we should flush pending commands - FlushImplicit(FALSE); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); return false; } else { @@ -4104,10 +4414,15 @@ namespace dxvk { if (FormatInfo != nullptr) { elementSize = FormatInfo->elementSize; + VkExtent3D blockSize = FormatInfo->blockSize; + if (unlikely(FormatInfo->flags.test(DxvkFormatFlag::MultiPlane))) { + elementSize = FormatInfo->planes[0].elementSize; + blockSize = { FormatInfo->planes[0].blockSize.width, FormatInfo->planes[0].blockSize.height, 1u }; + } - offsets[0] = offsets[0] / FormatInfo->blockSize.depth; - offsets[1] = offsets[1] / FormatInfo->blockSize.height; - offsets[2] = offsets[2] / FormatInfo->blockSize.width; + offsets[0] = offsets[0] / blockSize.depth; + offsets[1] = offsets[1] / blockSize.height; + offsets[2] = offsets[2] / blockSize.width; } return offsets[0] * SlicePitch + @@ -4134,22 +4449,26 @@ namespace dxvk { if (unlikely((Flags & (D3DLOCK_DISCARD | D3DLOCK_READONLY)) == (D3DLOCK_DISCARD | D3DLOCK_READONLY))) return D3DERR_INVALIDCALL; - if (unlikely(!m_d3d9Options.allowDoNotWait)) - Flags &= ~D3DLOCK_DONOTWAIT; + // We only ever wait for textures that were used with GetRenderTargetData or GetFrontBufferData anyway. + // Games like Beyond Good and Evil break if this doesn't succeed. + Flags &= ~D3DLOCK_DONOTWAIT; if (unlikely((Flags & (D3DLOCK_DISCARD | D3DLOCK_NOOVERWRITE)) == (D3DLOCK_DISCARD | D3DLOCK_NOOVERWRITE))) Flags &= ~D3DLOCK_DISCARD; + // Tests show that D3D9 drivers ignore DISCARD when the device is lost. + if (unlikely(m_deviceLostState != D3D9DeviceLostState::Ok)) + Flags &= ~D3DLOCK_DISCARD; + auto& desc = *(pResource->Desc()); - bool alloced = pResource->CreateBufferSubresource(Subresource); - - const Rc mappedBuffer = pResource->GetBuffer(Subresource); + if (unlikely(!desc.IsLockable)) + return D3DERR_INVALIDCALL; auto& formatMapping = pResource->GetFormatMapping(); const DxvkFormatInfo* formatInfo = formatMapping.IsValid() - ? imageFormatInfo(formatMapping.FormatColor) : UnsupportedFormatInfo(pResource->Desc()->Format); + ? lookupFormatInfo(formatMapping.FormatColor) : UnsupportedFormatInfo(pResource->Desc()->Format); auto subresource = pResource->GetSubresourceFromIndex( formatInfo->aspectMask, Subresource); @@ -4157,10 +4476,6 @@ namespace dxvk { VkExtent3D levelExtent = pResource->GetExtentMip(MipLevel); VkExtent3D blockCount = util::computeBlockCount(levelExtent, formatInfo->blockSize); - const bool systemmem = desc.Pool == D3DPOOL_SYSTEMMEM; - const bool managed = IsPoolManaged(desc.Pool); - const bool scratch = desc.Pool == D3DPOOL_SCRATCH; - bool fullResource = pBox == nullptr; if (unlikely(!fullResource)) { VkOffset3D lockOffset; @@ -4197,114 +4512,108 @@ namespace dxvk { // then we need to copy -> buffer // We are also always dirty if we are a render target, // a depth stencil, or auto generate mipmaps. - bool needsReadback = pResource->NeedsReachback(Subresource) || renderable; + bool needsReadback = pResource->NeedsReadback(Subresource) || renderable; + + // Skip readback if we discard is specified. We can only do this for textures that have an associated Vulkan image. + // Any other texture might write to the Vulkan staging buffer directly. (GetBackbufferData for example) + needsReadback &= pResource->GetImage() != nullptr || !(Flags & D3DLOCK_DISCARD); pResource->SetNeedsReadback(Subresource, false); - DxvkBufferSliceHandle physSlice; - if (Flags & D3DLOCK_DISCARD) { - // We do not have to preserve the contents of the - // buffer if the entire image gets discarded. - physSlice = pResource->DiscardMapSlice(Subresource); + if (unlikely(pResource->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_BACKED || needsReadback)) { + // Create mapping buffer if it doesn't exist yet. (POOL_DEFAULT) + pResource->CreateBuffer(!needsReadback); + } - EmitCs([ - cImageBuffer = std::move(mappedBuffer), - cBufferSlice = physSlice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cImageBuffer, cBufferSlice); - }); - } else { - physSlice = pResource->GetMappedSlice(Subresource); + // Don't use MapTexture here to keep the mapped list small while the resource is still locked. + void* mapPtr = pResource->GetData(Subresource); - // We do not need to wait for the resource in the event the - // calling app promises not to overwrite data that is in use - // or is reading. Remember! This will only trigger for MANAGED resources - // that cannot get affected by GPU, therefore readonly is A-OK for NOT waiting. - const bool usesStagingBuffer = pResource->DoesStagingBufferUploads(Subresource); - const bool skipWait = (scratch || managed || systemmem) && !needsReadback - && (usesStagingBuffer || readOnly); + if (unlikely(needsReadback)) { + DxvkBufferSlice mappedBufferSlice = pResource->GetBufferSlice(Subresource); + const Rc mappedBuffer = pResource->GetBuffer(); - if (alloced && !needsReadback) { - std::memset(physSlice.mapPtr, 0, physSlice.length); + if (unlikely(pResource->GetFormatMapping().ConversionFormatInfo.FormatType != D3D9ConversionFormat_None)) { + Logger::err(str::format("Reading back format", pResource->Desc()->Format, " is not supported. It is uploaded using the fomrat converter.")); } - else if (!skipWait) { - if (unlikely(needsReadback) && pResource->GetImage() != nullptr) { - Rc resourceImage = pResource->GetImage(); - Rc mappedImage = resourceImage->info().sampleCount != 1 - ? pResource->GetResolveImage() - : std::move(resourceImage); + if (pResource->GetImage() != nullptr) { + Rc resourceImage = pResource->GetImage(); - // When using any map mode which requires the image contents - // to be preserved, and if the GPU has write access to the - // image, copy the current image contents into the buffer. - auto subresourceLayers = vk::makeSubresourceLayers(subresource); - - // We need to resolve this, some games - // lock MSAA render targets even though - // that's entirely illegal and they explicitly - // tell us that they do NOT want to lock them... - if (resourceImage != nullptr) { - EmitCs([ - cMainImage = resourceImage, - cResolveImage = mappedImage, - cSubresource = subresourceLayers - ] (DxvkContext* ctx) { - VkImageResolve region; - region.srcSubresource = cSubresource; - region.srcOffset = VkOffset3D { 0, 0, 0 }; - region.dstSubresource = cSubresource; - region.dstOffset = VkOffset3D { 0, 0, 0 }; - region.extent = cMainImage->mipLevelExtent(cSubresource.mipLevel); - - if (cSubresource.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { - ctx->resolveImage( - cResolveImage, cMainImage, region, - cMainImage->info().format); - } - else { - ctx->resolveDepthStencilImage( - cResolveImage, cMainImage, region, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR); - } - }); - } - - VkFormat packedFormat = GetPackedDepthStencilFormat(desc.Format); - - EmitCs([ - cImageBuffer = mappedBuffer, - cImage = std::move(mappedImage), - cSubresources = subresourceLayers, - cLevelExtent = levelExtent, - cPackedFormat = packedFormat - ] (DxvkContext* ctx) { - if (cSubresources.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { - ctx->copyImageToBuffer(cImageBuffer, 0, 4, 0, - cImage, cSubresources, VkOffset3D { 0, 0, 0 }, - cLevelExtent); - } else { - // Copying DS to a packed buffer is only supported for D24S8 and D32S8 - // right now so the 4 byte row alignment is guaranteed by the format size - ctx->copyDepthStencilImageToPackedBuffer( - cImageBuffer, 0, - VkOffset2D { 0, 0 }, - VkExtent2D { cLevelExtent.width, cLevelExtent.height }, - cImage, cSubresources, - VkOffset2D { 0, 0 }, - VkExtent2D { cLevelExtent.width, cLevelExtent.height }, - cPackedFormat); - } - }); - TrackTextureMappingBufferSequenceNumber(pResource, Subresource); - } else if (!(Flags & D3DLOCK_DONOTWAIT) && !WaitForResource(mappedBuffer, pResource->GetMappingBufferSequenceNumber(Subresource), D3DLOCK_DONOTWAIT)) { - pResource->EnableStagingBufferUploads(Subresource); + Rc mappedImage; + if (resourceImage->info().sampleCount != 1) { + mappedImage = pResource->GetResolveImage(); + } else { + mappedImage = std::move(resourceImage); } - if (!WaitForResource(mappedBuffer, pResource->GetMappingBufferSequenceNumber(Subresource), Flags)) - return D3DERR_WASSTILLDRAWING; + // When using any map mode which requires the image contents + // to be preserved, and if the GPU has write access to the + // image, copy the current image contents into the buffer. + auto subresourceLayers = vk::makeSubresourceLayers(subresource); + + // We need to resolve this, some games + // lock MSAA render targets even though + // that's entirely illegal and they explicitly + // tell us that they do NOT want to lock them... + if (resourceImage != nullptr) { + EmitCs([ + cMainImage = resourceImage, + cResolveImage = mappedImage, + cSubresource = subresourceLayers + ] (DxvkContext* ctx) { + VkImageResolve region; + region.srcSubresource = cSubresource; + region.srcOffset = VkOffset3D { 0, 0, 0 }; + region.dstSubresource = cSubresource; + region.dstOffset = VkOffset3D { 0, 0, 0 }; + region.extent = cMainImage->mipLevelExtent(cSubresource.mipLevel); + + if (cSubresource.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + ctx->resolveImage( + cResolveImage, cMainImage, region, + cMainImage->info().format); + } + else { + ctx->resolveDepthStencilImage( + cResolveImage, cMainImage, region, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT); + } + }); + } + + VkFormat packedFormat = GetPackedDepthStencilFormat(desc.Format); + + EmitCs([ + cImageBufferSlice = std::move(mappedBufferSlice), + cImage = std::move(mappedImage), + cSubresources = subresourceLayers, + cLevelExtent = levelExtent, + cPackedFormat = packedFormat + ] (DxvkContext* ctx) { + if (cSubresources.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + ctx->copyImageToBuffer(cImageBufferSlice.buffer(), + cImageBufferSlice.offset(), 4, 0, cImage, + cSubresources, VkOffset3D { 0, 0, 0 }, + cLevelExtent); + } else { + // Copying DS to a packed buffer is only supported for D24S8 and D32S8 + // right now so the 4 byte row alignment is guaranteed by the format size + ctx->copyDepthStencilImageToPackedBuffer( + cImageBufferSlice.buffer(), cImageBufferSlice.offset(), + VkOffset2D { 0, 0 }, + VkExtent2D { cLevelExtent.width, cLevelExtent.height }, + cImage, cSubresources, + VkOffset2D { 0, 0 }, + VkExtent2D { cLevelExtent.width, cLevelExtent.height }, + cPackedFormat); + } + }); + TrackTextureMappingBufferSequenceNumber(pResource, Subresource); } + + if (!WaitForResource(mappedBuffer, pResource->GetMappingBufferSequenceNumber(Subresource), Flags)) + return D3DERR_WASSTILLDRAWING; } const bool atiHack = desc.Format == D3D9Format::ATI1 || desc.Format == D3D9Format::ATI2; @@ -4315,17 +4624,24 @@ namespace dxvk { pLockedBox->RowPitch = align(std::max(desc.Width >> MipLevel, 1u), 4); pLockedBox->SlicePitch = pLockedBox->RowPitch * std::max(desc.Height >> MipLevel, 1u); } - else { - // Data is tightly packed within the mapped buffer. + else if (likely(!formatInfo->flags.test(DxvkFormatFlag::MultiPlane))) { pLockedBox->RowPitch = align(formatInfo->elementSize * blockCount.width, 4); pLockedBox->SlicePitch = pLockedBox->RowPitch * blockCount.height; + } else { + auto plane = &formatInfo->planes[0]; + uint32_t planeElementSize = plane->elementSize; + VkExtent3D planeBlockSize = { plane->blockSize.width, plane->blockSize.height, 1u }; + VkExtent3D blockCount = util::computeBlockCount(levelExtent, planeBlockSize); + pLockedBox->RowPitch = align(planeElementSize * blockCount.width, 4); + pLockedBox->SlicePitch = pLockedBox->RowPitch * blockCount.height; } pResource->SetLocked(Subresource, true); + UnmapTextures(); + const bool noDirtyUpdate = Flags & D3DLOCK_NO_DIRTY_UPDATE; - if (likely((pResource->IsManaged() && m_d3d9Options.evictManagedOnUnlock) - || ((desc.Pool == D3DPOOL_DEFAULT || !noDirtyUpdate) && !readOnly))) { + if ((desc.Pool == D3DPOOL_DEFAULT || !noDirtyUpdate) && !readOnly) { if (pBox && MipLevel != 0) { D3DBOX scaledBox = *pBox; scaledBox.Left <<= MipLevel; @@ -4340,7 +4656,7 @@ namespace dxvk { } } - if (managed && !m_d3d9Options.evictManagedOnUnlock && !readOnly) { + if (IsPoolManaged(desc.Pool) && !readOnly) { pResource->SetNeedsUpload(Subresource, true); for (uint32_t i : bit::BitMask(m_activeTextures)) { @@ -4361,8 +4677,7 @@ namespace dxvk { (!atiHack) ? formatInfo : nullptr, pBox); - - uint8_t* data = reinterpret_cast(physSlice.mapPtr); + uint8_t* data = reinterpret_cast(mapPtr); data += offset; pLockedBox->pBits = data; return D3D_OK; @@ -4381,6 +4696,7 @@ namespace dxvk { if (unlikely(!pResource->GetLocked(Subresource))) return D3D_OK; + MapTexture(pResource, Subresource); // Add it to the list of mapped resources pResource->SetLocked(Subresource, false); // Flush image contents from staging if we aren't read only @@ -4388,7 +4704,7 @@ namespace dxvk { const D3DBOX& box = pResource->GetDirtyBox(Face); bool shouldFlush = pResource->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_BACKED; shouldFlush &= box.Left < box.Right && box.Top < box.Bottom && box.Front < box.Back; - shouldFlush &= !pResource->IsManaged() || m_d3d9Options.evictManagedOnUnlock; + shouldFlush &= !pResource->IsManaged(); if (shouldFlush) { this->FlushImage(pResource, Subresource); @@ -4400,13 +4716,16 @@ namespace dxvk { // and we aren't managed (for sysmem copy.) bool shouldToss = pResource->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_BACKED; shouldToss &= !pResource->IsDynamic(); - shouldToss &= !pResource->IsManaged() || m_d3d9Options.evictManagedOnUnlock; + shouldToss &= !pResource->IsManaged(); + shouldToss &= !pResource->IsAnySubresourceLocked(); - if (shouldToss) { - pResource->DestroyBufferSubresource(Subresource); - pResource->SetNeedsReadback(Subresource, true); - } + // The texture converter cannot handle converting back. So just keep textures in memory as a workaround. + shouldToss &= pResource->GetFormatMapping().ConversionFormatInfo.FormatType == D3D9ConversionFormat_None; + if (shouldToss) + pResource->DestroyBuffer(); + + UnmapTextures(); return D3D_OK; } @@ -4416,7 +4735,7 @@ namespace dxvk { UINT Subresource) { const Rc image = pResource->GetImage(); - auto formatInfo = imageFormatInfo(image->info().format); + auto formatInfo = lookupFormatInfo(image->info().format); auto subresource = pResource->GetSubresourceFromIndex( formatInfo->aspectMask, Subresource); @@ -4442,15 +4761,15 @@ namespace dxvk { UINT SrcSubresource, VkOffset3D SrcOffset, VkExtent3D SrcExtent, - VkOffset3D DestOffset - ) { + VkOffset3D DestOffset) { + WaitStagingBuffer(); + const Rc image = pDestTexture->GetImage(); // Now that data has been written into the buffer, // we need to copy its contents into the image - const DxvkBufferSliceHandle srcSlice = pSrcTexture->GetMappedSlice(SrcSubresource); - auto formatInfo = imageFormatInfo(image->info().format); + auto formatInfo = lookupFormatInfo(pDestTexture->GetFormatMapping().FormatColor); auto srcSubresource = pSrcTexture->GetSubresourceFromIndex( formatInfo->aspectMask, SrcSubresource); @@ -4460,10 +4779,18 @@ namespace dxvk { VkExtent3D dstTexLevelExtent = image->mipLevelExtent(dstSubresource.mipLevel); VkExtent3D srcTexLevelExtent = util::computeMipLevelExtent(pSrcTexture->GetExtent(), srcSubresource.mipLevel); - VkExtent3D srcTexLevelExtentBlockCount = util::computeBlockCount(srcTexLevelExtent, formatInfo->blockSize); auto convertFormat = pDestTexture->GetFormatMapping().ConversionFormatInfo; + if (unlikely(pSrcTexture->NeedsReadback(SrcSubresource))) { + // The src texutre has to be in POOL_SYSTEMEM, so it cannot use AUTOMIPGEN. + // That means that NeedsReadback is only true if the texture has been used with GetRTData or GetFrontbufferData before. + // Those functions create a buffer, so the buffer always exists here. + const Rc& buffer = pSrcTexture->GetBuffer(); + WaitForResource(buffer, pSrcTexture->GetMappingBufferSequenceNumber(SrcSubresource), 0); + pSrcTexture->SetNeedsReadback(SrcSubresource, false); + } + if (likely(convertFormat.FormatType == D3D9ConversionFormat_None)) { VkOffset3D alignedDestOffset = { int32_t(alignDown(DestOffset.x, formatInfo->blockSize.width)), @@ -4491,48 +4818,46 @@ namespace dxvk { + srcOffsetBlockCount.y * pitch + srcOffsetBlockCount.x * formatInfo->elementSize; - VkDeviceSize sliceAlignment = 1; - VkDeviceSize rowAlignment = 1; - DxvkBufferSlice copySrcSlice; - if (pSrcTexture->DoesStagingBufferUploads(SrcSubresource)) { - VkDeviceSize dirtySize = extentBlockCount.width * extentBlockCount.height * extentBlockCount.depth * formatInfo->elementSize; - D3D9BufferSlice slice = AllocTempBuffer(dirtySize); - copySrcSlice = slice.slice; - void* srcData = reinterpret_cast(srcSlice.mapPtr) + copySrcOffset; - util::packImageData( - slice.mapPtr, srcData, extentBlockCount, formatInfo->elementSize, - pitch, pitch * srcTexLevelExtentBlockCount.height); - } else { - copySrcSlice = DxvkBufferSlice(pSrcTexture->GetBuffer(SrcSubresource), copySrcOffset, srcSlice.length); - // row/slice alignment can act as the pitch parameter - rowAlignment = pitch; - sliceAlignment = srcTexLevelExtentBlockCount.height * pitch; - } + const void* mapPtr = MapTexture(pSrcTexture, SrcSubresource); + VkDeviceSize dirtySize = extentBlockCount.width * extentBlockCount.height * extentBlockCount.depth * formatInfo->elementSize; + D3D9BufferSlice slice = AllocStagingBuffer(dirtySize); + const void* srcData = reinterpret_cast(mapPtr) + copySrcOffset; + util::packImageData( + slice.mapPtr, srcData, extentBlockCount, formatInfo->elementSize, + pitch, pitch * srcTexLevelExtentBlockCount.height); + + VkFormat packedDSFormat = GetPackedDepthStencilFormat(pDestTexture->Desc()->Format); EmitCs([ - cSrcSlice = std::move(copySrcSlice), + cSrcSlice = slice.slice, cDstImage = image, cDstLayers = dstLayers, cDstLevelExtent = alignedExtent, cOffset = alignedDestOffset, - cRowAlignment = rowAlignment, - cSliceAlignment = sliceAlignment + cPackedDSFormat = packedDSFormat ] (DxvkContext* ctx) { - ctx->copyBufferToImage( - cDstImage, cDstLayers, - cOffset, cDstLevelExtent, - cSrcSlice.buffer(), cSrcSlice.offset(), - cRowAlignment, cSliceAlignment); + if (cDstLayers.aspectMask != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { + ctx->copyBufferToImage( + cDstImage, cDstLayers, + cOffset, cDstLevelExtent, + cSrcSlice.buffer(), cSrcSlice.offset(), + 1, 1); + } else { + ctx->copyPackedBufferToDepthStencilImage( + cDstImage, cDstLayers, + VkOffset2D { cOffset.x, cOffset.y }, + VkExtent2D { cDstLevelExtent.width, cDstLevelExtent.height }, + cSrcSlice.buffer(), cSrcSlice.offset(), + VkOffset2D { 0, 0 }, + VkExtent2D { cDstLevelExtent.width, cDstLevelExtent.height }, + cPackedDSFormat); + } }); TrackTextureMappingBufferSequenceNumber(pSrcTexture, SrcSubresource); } else { - const DxvkFormatInfo* formatInfo = imageFormatInfo(pDestTexture->GetFormatMapping().FormatColor); - - // Add more blocks for the other planes that we might have. - // TODO: PLEASE CLEAN ME - srcTexLevelExtentBlockCount.height *= std::min(convertFormat.PlaneCount, 2u); + const void* mapPtr = MapTexture(pSrcTexture, SrcSubresource); if (unlikely(SrcOffset.x != 0 || SrcOffset.y != 0 || SrcOffset.z != 0 || DestOffset.x != 0 || DestOffset.y != 0 || DestOffset.z != 0 @@ -4545,22 +4870,36 @@ namespace dxvk { return; } + uint32_t formatElementSize = formatInfo->elementSize; + VkExtent3D srcBlockSize = formatInfo->blockSize; + if (formatInfo->flags.test(DxvkFormatFlag::MultiPlane)) { + formatElementSize = formatInfo->planes[0].elementSize; + srcBlockSize = { formatInfo->planes[0].blockSize.width, formatInfo->planes[0].blockSize.height, 1u }; + } + VkExtent3D srcBlockCount = util::computeBlockCount(srcTexLevelExtent, srcBlockSize); + srcBlockCount.height *= std::min(pSrcTexture->GetPlaneCount(), 2u); + // the converter can not handle the 4 aligned pitch so we always repack into a staging buffer - D3D9BufferSlice slice = AllocTempBuffer(srcSlice.length); - VkDeviceSize pitch = align(srcTexLevelExtentBlockCount.width * formatInfo->elementSize, 4); + D3D9BufferSlice slice = AllocStagingBuffer(pSrcTexture->GetMipSize(SrcSubresource)); + VkDeviceSize pitch = align(srcBlockCount.width * formatElementSize, 4); + + const DxvkFormatInfo* convertedFormatInfo = lookupFormatInfo(convertFormat.FormatColor); + VkImageSubresourceLayers convertedDstLayers = { convertedFormatInfo->aspectMask, dstSubresource.mipLevel, dstSubresource.arrayLayer, 1 }; util::packImageData( - slice.mapPtr, srcSlice.mapPtr, srcTexLevelExtentBlockCount, formatInfo->elementSize, - pitch, std::min(convertFormat.PlaneCount, 2u) * pitch * srcTexLevelExtentBlockCount.height); + slice.mapPtr, mapPtr, srcBlockCount, formatElementSize, + pitch, std::min(pSrcTexture->GetPlaneCount(), 2u) * pitch * srcBlockCount.height); Flush(); SynchronizeCsThread(DxvkCsThread::SynchronizeAll); m_converter->ConvertFormat( convertFormat, - image, dstLayers, + image, convertedDstLayers, slice.slice); } + UnmapTextures(); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); } void D3D9DeviceEx::EmitGenerateMips( @@ -4588,9 +4927,6 @@ namespace dxvk { if (unlikely(ppbData == nullptr)) return D3DERR_INVALIDCALL; - if (!m_d3d9Options.allowDiscard) - Flags &= ~D3DLOCK_DISCARD; - auto& desc = *pResource->Desc(); // Ignore DISCARD if NOOVERWRITE is set @@ -4608,6 +4944,10 @@ namespace dxvk { if (desc.Usage & D3DUSAGE_DYNAMIC) Flags &= ~D3DLOCK_DONOTWAIT; + // Tests show that D3D9 drivers ignore DISCARD when the device is lost. + if (unlikely(m_deviceLostState != D3D9DeviceLostState::Ok)) + Flags &= ~D3DLOCK_DISCARD; + // We only bounds check for MANAGED. // (TODO: Apparently this is meant to happen for DYNAMIC too but I am not sure // how that works given it is meant to be a DIRECT access..?) @@ -4623,11 +4963,14 @@ namespace dxvk { if ((desc.Pool == D3DPOOL_DEFAULT || !(Flags & D3DLOCK_NO_DIRTY_UPDATE)) && !(Flags & D3DLOCK_READONLY)) pResource->DirtyRange().Conjoin(lockRange); + const bool directMapping = pResource->GetMapMode() == D3D9_COMMON_BUFFER_MAP_MODE_DIRECT; + const bool needsReadback = pResource->NeedsReadback(); + Rc mappingBuffer = pResource->GetBuffer(); DxvkBufferSliceHandle physSlice; - if (Flags & D3DLOCK_DISCARD) { + if ((Flags & D3DLOCK_DISCARD) && (directMapping || needsReadback)) { // Allocate a new backing slice for the buffer and set // it as the 'new' mapped slice. This assumes that the // only way to invalidate a buffer is by mapping it. @@ -4641,7 +4984,6 @@ namespace dxvk { }); pResource->SetNeedsReadback(false); - pResource->GPUReadingRange().Clear(); } else { // Use map pointer from previous map operation. This @@ -4649,31 +4991,18 @@ namespace dxvk { // if the map mode is D3DLOCK_NOOVERWRITE. physSlice = pResource->GetMappedSlice(); - // NOOVERWRITE promises that they will not write in a currently used area. - // Therefore we can skip waiting for these two cases. - // We can also skip waiting if there is not dirty range overlap, if we are one of those resources. - - // If we are respecting the bounds ie. (MANAGED) we can test overlap - // of our bounds, otherwise we just ignore this and go for it all the time. const bool needsReadback = pResource->NeedsReadback(); const bool readOnly = Flags & D3DLOCK_READONLY; - const bool noOverlap = !pResource->GPUReadingRange().Overlaps(lockRange); + // NOOVERWRITE promises that they will not write in a currently used area. const bool noOverwrite = Flags & D3DLOCK_NOOVERWRITE; - const bool usesStagingBuffer = pResource->DoesStagingBufferUploads(); const bool directMapping = pResource->GetMapMode() == D3D9_COMMON_BUFFER_MAP_MODE_DIRECT; - const bool skipWait = (!needsReadback && (usesStagingBuffer || readOnly || (noOverlap && !directMapping))) || noOverwrite; + const bool skipWait = (!needsReadback && (readOnly || !directMapping)) || noOverwrite; if (!skipWait) { - if (unlikely(needsReadback)) { - Logger::warn("Buffer readback is unimplemented."); - // Remember to update the sequence number when implementing buffer readback. - } else if (!(Flags & D3DLOCK_DONOTWAIT) && !WaitForResource(mappingBuffer, pResource->GetMappingBufferSequenceNumber(), D3DLOCK_DONOTWAIT)) - pResource->EnableStagingBufferUploads(); - + const Rc mappingBuffer = pResource->GetBuffer(); if (!WaitForResource(mappingBuffer, pResource->GetMappingBufferSequenceNumber(), Flags)) return D3DERR_WASSTILLDRAWING; pResource->SetNeedsReadback(false); - pResource->GPUReadingRange().Clear(); } } @@ -4693,30 +5022,27 @@ namespace dxvk { pResource->SetMapFlags(Flags | oldFlags); pResource->IncrementLockCount(); + UnmapTextures(); return D3D_OK; } HRESULT D3D9DeviceEx::FlushBuffer( D3D9CommonBuffer* pResource) { + WaitStagingBuffer(); + auto dstBuffer = pResource->GetBufferSlice(); auto srcSlice = pResource->GetMappedSlice(); D3D9Range& range = pResource->DirtyRange(); - DxvkBufferSlice copySrcSlice; - if (pResource->DoesStagingBufferUploads()) { - D3D9BufferSlice slice = AllocTempBuffer(range.max - range.min); - copySrcSlice = slice.slice; - void* srcData = reinterpret_cast(srcSlice.mapPtr) + range.min; - memcpy(slice.mapPtr, srcData, range.max - range.min); - } else { - copySrcSlice = DxvkBufferSlice(pResource->GetBuffer(), range.min, range.max - range.min); - } + D3D9BufferSlice slice = AllocStagingBuffer(range.max - range.min); + void* srcData = reinterpret_cast(srcSlice.mapPtr) + range.min; + memcpy(slice.mapPtr, srcData, range.max - range.min); EmitCs([ cDstSlice = dstBuffer, - cSrcSlice = copySrcSlice, + cSrcSlice = slice.slice, cDstOffset = range.min, cLength = range.max - range.min ] (DxvkContext* ctx) { @@ -4728,11 +5054,12 @@ namespace dxvk { cLength); }); - pResource->GPUReadingRange().Conjoin(pResource->DirtyRange()); pResource->DirtyRange().Clear(); TrackBufferMappingBufferSequenceNumber(pResource); - return D3D_OK; + UnmapTextures(); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); + return D3D_OK; } @@ -4754,8 +5081,6 @@ namespace dxvk { if (pResource->Desc()->Pool != D3DPOOL_DEFAULT) return D3D_OK; - FlushImplicit(FALSE); - FlushBuffer(pResource); return D3D_OK; @@ -4764,25 +5089,15 @@ namespace dxvk { void D3D9DeviceEx::EmitCsChunk(DxvkCsChunkRef&& chunk) { m_csSeqNum = m_csThread.dispatchChunk(std::move(chunk)); - m_csIsBusy = true; } - void D3D9DeviceEx::FlushImplicit(BOOL StrongHint) { - // Flush only if the GPU is about to go idle, in - // order to keep the number of submissions low. - uint32_t pending = m_dxvkDevice->pendingSubmissions(); + void D3D9DeviceEx::ConsiderFlush(GpuFlushType FlushType) { + uint64_t chunkId = GetCurrentSequenceNumber(); + uint64_t submissionId = m_submissionFence->value(); - if (StrongHint || pending <= MaxPendingSubmits) { - auto now = dxvk::high_resolution_clock::now(); - - uint32_t delay = MinFlushIntervalUs - + IncFlushIntervalUs * pending; - - // Prevent flushing too often in short intervals. - if (now - m_lastFlush >= std::chrono::microseconds(delay)) - Flush(); - } + if (m_flushTracker.considerFlush(FlushType, chunkId, submissionId)) + Flush(); } @@ -4791,7 +5106,8 @@ namespace dxvk { // Dispatch current chunk so that all commands // recorded prior to this function will be run - FlushCsChunk(); + if (SequenceNumber > m_csSeqNum) + FlushCsChunk(); m_csThread.synchronize(SequenceNumber); } @@ -4860,94 +5176,64 @@ namespace dxvk { } - Rc D3D9DeviceEx::CreateConstantBuffer( - bool SSBO, - VkDeviceSize Size, - DxsoProgramType ShaderStage, - DxsoConstantBuffers BufferType) { - DxvkBufferCreateInfo info = { }; - info.usage = SSBO ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; - info.access = SSBO ? VK_ACCESS_SHADER_READ_BIT : VK_ACCESS_UNIFORM_READ_BIT; - info.size = Size; - info.stages = ShaderStage == DxsoProgramType::VertexShader - ? VK_PIPELINE_STAGE_VERTEX_SHADER_BIT - : VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; - - VkMemoryPropertyFlags memoryFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT - | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - - if (m_d3d9Options.deviceLocalConstantBuffers) - memoryFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - - Rc buffer = m_dxvkDevice->createBuffer(info, memoryFlags); - - const uint32_t slotId = computeResourceSlotId( - ShaderStage, DxsoBindingType::ConstantBuffer, - BufferType); - - EmitCs([ - cSlotId = slotId, - cBuffer = buffer - ] (DxvkContext* ctx) { - ctx->bindResourceBuffer(cSlotId, - DxvkBufferSlice(cBuffer, 0, cBuffer->info().size)); - }); - - if (ShaderStage == DxsoProgramType::PixelShader) - m_boundPSConstantsBufferSize = buffer->info().size; - else - m_boundVSConstantsBufferSize = buffer->info().size; - - return buffer; - } - - void D3D9DeviceEx::CreateConstantBuffers() { - if (!m_isSWVP) { - m_consts[DxsoProgramTypes::VertexShader].buffer = - CreateConstantBuffer(false, - m_vsLayout.totalSize(), - DxsoProgramType::VertexShader, - DxsoConstantBuffers::VSConstantBuffer); + constexpr VkDeviceSize DefaultConstantBufferSize = 1024ull << 10; + constexpr VkDeviceSize SmallConstantBufferSize = 64ull << 10; + + m_consts[DxsoProgramTypes::VertexShader].buffer = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSConstantBuffer, + DefaultConstantBufferSize); + + m_consts[DxsoProgramTypes::VertexShader].swvp.intBuffer = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSIntConstantBuffer, + SmallConstantBufferSize); + + m_consts[DxsoProgramTypes::VertexShader].swvp.boolBuffer = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSBoolConstantBuffer, + SmallConstantBufferSize); + + m_consts[DxsoProgramTypes::PixelShader].buffer = D3D9ConstantBuffer(this, + DxsoProgramType::PixelShader, + DxsoConstantBuffers::PSConstantBuffer, + DefaultConstantBufferSize); + + m_vsClipPlanes = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSClipPlanes, + caps::MaxClipPlanes * sizeof(D3D9ClipPlane)); + + m_vsFixedFunction = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSFixedFunction, + sizeof(D3D9FixedFunctionVS)); + + m_psFixedFunction = D3D9ConstantBuffer(this, + DxsoProgramType::PixelShader, + DxsoConstantBuffers::PSFixedFunction, + sizeof(D3D9FixedFunctionPS)); + + m_psShared = D3D9ConstantBuffer(this, + DxsoProgramType::PixelShader, + DxsoConstantBuffers::PSShared, + sizeof(D3D9SharedPS)); + + m_vsVertexBlend = D3D9ConstantBuffer(this, + DxsoProgramType::VertexShader, + DxsoConstantBuffers::VSVertexBlendData, + CanSWVP() + ? sizeof(D3D9FixedFunctionVertexBlendDataSW) + : sizeof(D3D9FixedFunctionVertexBlendDataHW)); + + if (m_usingGraphicsPipelines) { + m_specBuffer = D3D9ConstantBuffer(this, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, + getSpecConstantBufferSlot(), + sizeof(D3D9SpecializationInfo)); } - // SWVP constant buffers are created late based on the amount of constants set by the application - m_consts[DxsoProgramTypes::PixelShader].buffer = - CreateConstantBuffer(false, - m_psLayout.totalSize(), - DxsoProgramType::PixelShader, - DxsoConstantBuffers::PSConstantBuffer); - - m_vsClipPlanes = - CreateConstantBuffer(false, - caps::MaxClipPlanes * sizeof(D3D9ClipPlane), - DxsoProgramType::VertexShader, - DxsoConstantBuffers::VSClipPlanes); - - m_vsFixedFunction = - CreateConstantBuffer(false, - sizeof(D3D9FixedFunctionVS), - DxsoProgramType::VertexShader, - DxsoConstantBuffers::VSFixedFunction); - - m_psFixedFunction = - CreateConstantBuffer(false, - sizeof(D3D9FixedFunctionPS), - DxsoProgramType::PixelShader, - DxsoConstantBuffers::PSFixedFunction); - - m_psShared = - CreateConstantBuffer(false, - sizeof(D3D9SharedPS), - DxsoProgramType::PixelShader, - DxsoConstantBuffers::PSShared); - - m_vsVertexBlend = - CreateConstantBuffer(true, - CanSWVP() - ? sizeof(D3D9FixedFunctionVertexBlendDataSW) - : sizeof(D3D9FixedFunctionVertexBlendDataHW), - DxsoProgramType::VertexShader, - DxsoConstantBuffers::VSVertexBlendData); } @@ -4977,14 +5263,13 @@ namespace dxvk { const uint32_t intDataSize = std::min(constSet.meta.maxConstIndexI, m_vsIntConstsCount) * sizeof(Vector4i); const uint32_t boolDataSize = divCeil(std::min(constSet.meta.maxConstIndexB, m_vsBoolConstsCount), 32u) * uint32_t(sizeof(uint32_t)); - Rc& floatBuffer = constSet.swvpBuffers.floatBuffer; // Max copy source size is 8192 * 16 => always aligned to any plausible value // => we won't copy out of bounds - if (likely(constSet.meta.maxConstIndexF != 0 || floatBuffer == nullptr)) { - DxvkBufferSliceHandle floatBufferSlice = CopySoftwareConstants(DxsoConstantBuffers::VSFloatConstantBuffer, floatBuffer, Src.fConsts, floatDataSize, m_dxsoOptions.vertexFloatConstantBufferAsSSBO); + if (likely(constSet.meta.maxConstIndexF != 0)) { + auto mapPtr = CopySoftwareConstants(constSet.buffer, Src.fConsts, floatDataSize); if (constSet.meta.needsConstantCopies) { - Vector4* data = reinterpret_cast(floatBufferSlice.mapPtr); + Vector4* data = reinterpret_cast(mapPtr); auto& shaderConsts = GetCommonShader(m_state.vertexShader)->GetConstants(); @@ -4995,42 +5280,24 @@ namespace dxvk { } } - Rc& intBuffer = constSet.swvpBuffers.intBuffer; // Max copy source size is 2048 * 16 => always aligned to any plausible value // => we won't copy out of bounds - if (likely(constSet.meta.maxConstIndexI != 0 || intBuffer == nullptr)) { - CopySoftwareConstants(DxsoConstantBuffers::VSIntConstantBuffer, intBuffer, Src.iConsts, intDataSize, false); - } + if (likely(constSet.meta.maxConstIndexI != 0)) + CopySoftwareConstants(constSet.swvp.intBuffer, Src.iConsts, intDataSize); - Rc& boolBuffer = constSet.swvpBuffers.boolBuffer; - if (likely(constSet.meta.maxConstIndexB != 0 || boolBuffer == nullptr)) { - CopySoftwareConstants(DxsoConstantBuffers::VSBoolConstantBuffer, boolBuffer, Src.bConsts, boolDataSize, false); - } + if (likely(constSet.meta.maxConstIndexB != 0)) + CopySoftwareConstants(constSet.swvp.boolBuffer, Src.bConsts, boolDataSize); } - inline DxvkBufferSliceHandle D3D9DeviceEx::CopySoftwareConstants(DxsoConstantBuffers cBufferTarget, Rc& dstBuffer, const void* src, uint32_t size, bool useSSBO) { - uint32_t alignment = useSSBO ? m_robustSSBOAlignment : m_robustUBOAlignment; - alignment = std::max(alignment, 64u); + inline void* D3D9DeviceEx::CopySoftwareConstants(D3D9ConstantBuffer& dstBuffer, const void* src, uint32_t size) { + uint32_t alignment = dstBuffer.GetAlignment(); size = std::max(size, alignment); size = align(size, alignment); - DxvkBufferSliceHandle slice; - if (unlikely(dstBuffer == nullptr || dstBuffer->info().size < size)) { - dstBuffer = CreateConstantBuffer(useSSBO, size, DxsoProgramType::VertexShader, cBufferTarget); - slice = dstBuffer->getSliceHandle(); - } else { - slice = dstBuffer->allocSlice(); - EmitCs([ - cBuffer = dstBuffer, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); - } - - std::memcpy(slice.mapPtr, src, size); - return slice; + auto mapPtr = dstBuffer.Alloc(size); + std::memcpy(mapPtr, src, size); + return mapPtr; } @@ -5057,34 +5324,12 @@ namespace dxvk { const uint32_t intRange = caps::MaxOtherConstants * sizeof(Vector4i); const uint32_t intDataSize = constSet.meta.maxConstIndexI * sizeof(Vector4i); uint32_t floatDataSize = floatCount * sizeof(Vector4); - const uint32_t alignment = std::max(m_robustUBOAlignment, 64u); // Make sure we do not recreate the buffer because the new one has to be a tiny bit larger + const uint32_t alignment = constSet.buffer.GetAlignment(); const uint32_t bufferSize = align(std::max(floatDataSize + intRange, alignment), alignment); - floatDataSize = bufferSize - intRange; // Read additional floats for padding so we don't end up with garbage data + floatDataSize = bufferSize - intRange; - VkDeviceSize& boundConstantBufferSize = ShaderStage == DxsoProgramType::VertexShader ? m_boundVSConstantsBufferSize : m_boundPSConstantsBufferSize; - if (boundConstantBufferSize < bufferSize) { - constexpr uint32_t slotId = computeResourceSlotId(ShaderStage, DxsoBindingType::ConstantBuffer, 0); - EmitCs([ - cBuffer = constSet.buffer, - cSlotId = slotId, - cSize = bufferSize - ] (DxvkContext* ctx) { - ctx->bindResourceBuffer(cSlotId, - DxvkBufferSlice(cBuffer, 0, cSize)); - }); - boundConstantBufferSize = bufferSize; - } - - DxvkBufferSliceHandle slice = constSet.buffer->allocSlice(); - - EmitCs([ - cBuffer = constSet.buffer, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); - - auto* dst = reinterpret_cast(slice.mapPtr); + void* mapPtr = constSet.buffer.Alloc(bufferSize); + auto* dst = reinterpret_cast(mapPtr); if (constSet.meta.maxConstIndexI != 0) std::memcpy(dst->iConsts, Src.iConsts, intDataSize); @@ -5108,11 +5353,11 @@ namespace dxvk { void D3D9DeviceEx::UploadConstants() { if constexpr (ShaderStage == DxsoProgramTypes::VertexShader) { if (CanSWVP()) - return UploadSoftwareConstantSet(m_state.vsConsts, m_vsLayout); + return UploadSoftwareConstantSet(m_state.vsConsts.get(), m_vsLayout); else - return UploadConstantSet(m_state.vsConsts, m_vsLayout, m_state.vertexShader); + return UploadConstantSet(m_state.vsConsts.get(), m_vsLayout, m_state.vertexShader); } else { - return UploadConstantSet (m_state.psConsts, m_psLayout, m_state.pixelShader); + return UploadConstantSet (m_state.psConsts.get(), m_psLayout, m_state.pixelShader); } } @@ -5120,21 +5365,14 @@ namespace dxvk { void D3D9DeviceEx::UpdateClipPlanes() { m_flags.clr(D3D9DeviceFlag::DirtyClipPlanes); - auto slice = m_vsClipPlanes->allocSlice(); - auto dst = reinterpret_cast(slice.mapPtr); + auto mapPtr = m_vsClipPlanes.AllocSlice(); + auto dst = reinterpret_cast(mapPtr); for (uint32_t i = 0; i < caps::MaxClipPlanes; i++) { dst[i] = (m_state.renderStates[D3DRS_CLIPPLANEENABLE] & (1 << i)) ? m_state.clipPlanes[i] : D3D9ClipPlane(); } - - EmitCs([ - cBuffer = m_vsClipPlanes, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); } @@ -5157,8 +5395,8 @@ namespace dxvk { auto& rs = m_state.renderStates; if constexpr (Item == D3D9RenderStateItem::AlphaRef) { - float alpha = float(rs[D3DRS_ALPHAREF] & 0xFF) / 255.0f; - UpdatePushConstant(&alpha); + uint32_t alpha = rs[D3DRS_ALPHAREF] & 0xFF; + UpdatePushConstant(&alpha); } else if constexpr (Item == D3D9RenderStateItem::FogColor) { Vector4 color; @@ -5219,19 +5457,33 @@ namespace dxvk { m_initializer->Flush(); m_converter->Flush(); - if (m_csIsBusy || !m_csChunk->empty()) { - // Add commands to flush the threaded - // context, then flush the command list - EmitCs([](DxvkContext* ctx) { - ctx->flushCommandList(); - }); + EmitStagingBufferMarker(); - FlushCsChunk(); + // Add commands to flush the threaded + // context, then flush the command list + uint64_t submissionId = ++m_submissionId; - // Reset flush timer used for implicit flushes - m_lastFlush = dxvk::high_resolution_clock::now(); - m_csIsBusy = false; - } + EmitCs([ + cSubmissionFence = m_submissionFence, + cSubmissionId = submissionId + ] (DxvkContext* ctx) { + ctx->signal(cSubmissionFence, cSubmissionId); + ctx->flushCommandList(nullptr); + }); + + FlushCsChunk(); + + m_flushSeqNum = m_csSeqNum; + m_flushTracker.notifyFlush(m_flushSeqNum, submissionId); + } + + + void D3D9DeviceEx::EndFrame() { + D3D9DeviceLock lock = LockDevice(); + + EmitCs([] (DxvkContext* ctx) { + ctx->endFrame(); + }); } @@ -5249,22 +5501,38 @@ namespace dxvk { inline void D3D9DeviceEx::UpdateActiveRTs(uint32_t index) { const uint32_t bit = 1 << index; - m_activeRTs &= ~bit; + m_activeRTsWhichAreTextures &= ~bit; if ((m_boundRTs & bit) != 0 && m_state.renderTargets[index]->GetBaseTexture() != nullptr && - m_state.renderStates[ColorWriteIndex(index)]) - m_activeRTs |= bit; + m_anyColorWrites & bit) + m_activeRTsWhichAreTextures |= bit; UpdateActiveHazardsRT(bit); } + template + inline void D3D9DeviceEx::UpdateAnyColorWrites(bool has) { + const uint32_t bit = 1 << Index; + + m_anyColorWrites &= ~bit; + + if (has) + m_anyColorWrites |= bit; + + // The 0th RT is always bound. + if (Index == 0 || m_boundRTs & bit) { + m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); + UpdateActiveRTs(Index); + } + } + inline void D3D9DeviceEx::UpdateActiveTextures(uint32_t index, DWORD combinedUsage) { const uint32_t bit = 1 << index; - m_activeRTTextures &= ~bit; - m_activeDSTextures &= ~bit; + m_activeTextureRTs &= ~bit; + m_activeTextureDSs &= ~bit; m_activeTextures &= ~bit; m_activeTexturesToUpload &= ~bit; m_activeTexturesToGen &= ~bit; @@ -5274,10 +5542,10 @@ namespace dxvk { m_activeTextures |= bit; if (unlikely(tex->IsRenderTarget())) - m_activeRTTextures |= bit; + m_activeTextureRTs |= bit; if (unlikely(tex->IsDepthStencil())) - m_activeDSTextures |= bit; + m_activeTextureDSs |= bit; if (unlikely(tex->NeedsAnyUpload())) m_activeTexturesToUpload |= bit; @@ -5287,19 +5555,19 @@ namespace dxvk { } if (unlikely(combinedUsage & D3DUSAGE_RENDERTARGET)) - UpdateActiveHazardsRT(UINT32_MAX); + UpdateActiveHazardsRT(bit); if (unlikely(combinedUsage & D3DUSAGE_DEPTHSTENCIL)) UpdateActiveHazardsDS(bit); } - inline void D3D9DeviceEx::UpdateActiveHazardsRT(uint32_t rtMask) { + inline void D3D9DeviceEx::UpdateActiveHazardsRT(uint32_t texMask) { auto masks = m_psShaderMasks; - masks.rtMask &= m_activeRTs & rtMask; - masks.samplerMask &= m_activeRTTextures; + masks.rtMask &= m_activeRTsWhichAreTextures; + masks.samplerMask &= m_activeTextureRTs & texMask; - m_activeHazardsRT = m_activeHazardsRT & (~rtMask); + m_activeHazardsRT = m_activeHazardsRT & (~texMask); for (uint32_t rtIdx : bit::BitMask(masks.rtMask)) { for (uint32_t samplerIdx : bit::BitMask(masks.samplerMask)) { D3D9Surface* rtSurf = m_state.renderTargets[rtIdx].ptr(); @@ -5315,18 +5583,20 @@ namespace dxvk { if (likely(rtSurf->GetMipLevel() != 0 || rtBase != texBase)) continue; - m_activeHazardsRT |= 1 << rtIdx; + m_activeHazardsRT |= 1 << samplerIdx; } } } inline void D3D9DeviceEx::UpdateActiveHazardsDS(uint32_t texMask) { + auto masks = m_psShaderMasks; + masks.samplerMask &= m_activeTextureDSs & texMask; + m_activeHazardsDS = m_activeHazardsDS & (~texMask); if (m_state.depthStencil != nullptr && m_state.depthStencil->GetBaseTexture() != nullptr) { - uint32_t samplerMask = m_activeDSTextures & texMask; - for (uint32_t samplerIdx : bit::BitMask(samplerMask)) { + for (uint32_t samplerIdx : bit::BitMask(masks.samplerMask)) { IDirect3DBaseTexture9* dsBase = m_state.depthStencil->GetBaseTexture(); IDirect3DBaseTexture9* texBase = m_state.textures[samplerIdx]; @@ -5340,20 +5610,80 @@ namespace dxvk { void D3D9DeviceEx::MarkRenderHazards() { - for (uint32_t rtIdx : bit::BitMask(m_activeHazardsRT)) { + struct { + uint8_t RT : 1; + uint8_t DS : 1; + } hazardState; + hazardState.RT = m_activeHazardsRT != 0; + hazardState.DS = m_activeHazardsDS != 0; + + EmitCs([ + cHazardState = hazardState + ](DxvkContext* ctx) { + VkPipelineStageFlags srcStages = 0; + VkAccessFlags srcAccess = 0; + + if (cHazardState.RT != 0) { + srcStages |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + srcAccess |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + } + if (cHazardState.DS != 0) { + srcStages |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; + srcAccess |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + } + + ctx->emitGraphicsBarrier( + srcStages, + srcAccess, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + VK_ACCESS_SHADER_READ_BIT); + }); + + for (uint32_t samplerIdx : bit::BitMask(m_activeHazardsRT)) { // Guaranteed to not be nullptr... - auto tex = m_state.renderTargets[rtIdx]->GetCommonTexture(); - if (unlikely(!tex->MarkHazardous())) { - TransitionImage(tex, VK_IMAGE_LAYOUT_GENERAL); + auto tex = GetCommonTexture(m_state.textures[samplerIdx]); + if (unlikely(!tex->MarkTransitionedToHazardLayout())) { + TransitionImage(tex, m_hazardLayout); + m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); + } + } + + bool zWriteEnabled = m_state.renderStates[D3DRS_ZWRITEENABLE]; + if (m_activeHazardsDS != 0 && zWriteEnabled) { + // Guaranteed to not be nullptr... + auto tex = m_state.depthStencil->GetCommonTexture(); + if (unlikely(!tex->MarkTransitionedToHazardLayout())) { + TransitionImage(tex, m_hazardLayout); m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); } } } + void D3D9DeviceEx::UpdateActiveFetch4(uint32_t stateSampler) { + auto& state = m_state.samplerStates; + + const uint32_t samplerBit = 1u << stateSampler; + + auto texture = GetCommonTexture(m_state.textures[stateSampler]); + const bool textureSupportsFetch4 = texture != nullptr && texture->SupportsFetch4(); + + const bool fetch4Enabled = m_fetch4Enabled & samplerBit; + const bool pointSampled = state[stateSampler][D3DSAMP_MAGFILTER] == D3DTEXF_POINT; + const bool shouldFetch4 = fetch4Enabled && textureSupportsFetch4 && pointSampled; + + if (unlikely(shouldFetch4 != !!(m_fetch4 & samplerBit))) { + if (shouldFetch4) + m_fetch4 |= samplerBit; + else + m_fetch4 &= ~samplerBit; + } + } + + void D3D9DeviceEx::UploadManagedTexture(D3D9CommonTexture* pResource) { for (uint32_t subresource = 0; subresource < pResource->CountSubresources(); subresource++) { - if (!pResource->NeedsUpload(subresource) || pResource->GetBuffer(subresource) == nullptr) + if (!pResource->NeedsUpload(subresource)) continue; this->FlushImage(pResource, subresource); @@ -5390,7 +5720,6 @@ namespace dxvk { void D3D9DeviceEx::MarkTextureMipsDirty(D3D9CommonTexture* pResource) { pResource->SetNeedsMipGen(true); - pResource->MarkAllNeedReadback(); for (uint32_t i : bit::BitMask(m_activeTextures)) { // Guaranteed to not be nullptr... @@ -5429,42 +5758,31 @@ namespace dxvk { } - template - void D3D9DeviceEx::UpdatePointMode() { - if constexpr (!Points) { - m_lastPointMode = 0; - - EmitCs([](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PointMode, 0); - }); + void D3D9DeviceEx::UpdatePointMode(bool pointList) { + if (!pointList) { + UpdatePointModeSpec(0); + return; } - else { - auto& rs = m_state.renderStates; - const bool scale = rs[D3DRS_POINTSCALEENABLE] && !UseProgrammableVS(); - const bool sprite = rs[D3DRS_POINTSPRITEENABLE]; + auto& rs = m_state.renderStates; - const uint32_t scaleBit = scale ? 1u : 0u; - const uint32_t spriteBit = sprite ? 2u : 0u; + const bool scale = rs[D3DRS_POINTSCALEENABLE] && !UseProgrammableVS(); + const bool sprite = rs[D3DRS_POINTSPRITEENABLE]; - uint32_t mode = scaleBit | spriteBit; + const uint32_t scaleBit = scale ? 1u : 0u; + const uint32_t spriteBit = sprite ? 2u : 0u; - if (rs[D3DRS_POINTSCALEENABLE] && m_flags.test(D3D9DeviceFlag::DirtyPointScale)) { - m_flags.clr(D3D9DeviceFlag::DirtyPointScale); + uint32_t mode = scaleBit | spriteBit; - UpdatePushConstant(); - UpdatePushConstant(); - UpdatePushConstant(); - } + if (rs[D3DRS_POINTSCALEENABLE] && m_flags.test(D3D9DeviceFlag::DirtyPointScale)) { + m_flags.clr(D3D9DeviceFlag::DirtyPointScale); - if (unlikely(mode != m_lastPointMode)) { - EmitCs([cMode = mode] (DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PointMode, cMode); - }); - - m_lastPointMode = mode; - } + UpdatePushConstant(); + UpdatePushConstant(); + UpdatePushConstant(); } + + UpdatePointModeSpec(mode); } @@ -5509,11 +5827,7 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFogState)) { m_flags.clr(D3D9DeviceFlag::DirtyFogState); - EmitCs([cMode = mode] (DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::FogEnabled, true); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::VertexFogMode, cMode); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PixelFogMode, D3DFOG_NONE); - }); + UpdateFogModeSpec(true, mode, D3DFOG_NONE); } } else if (pixelFog) { @@ -5524,11 +5838,7 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFogState)) { m_flags.clr(D3D9DeviceFlag::DirtyFogState); - EmitCs([cMode = mode] (DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::FogEnabled, true); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::VertexFogMode, D3DFOG_NONE); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PixelFogMode, cMode); - }); + UpdateFogModeSpec(true, D3DFOG_NONE, mode); } } else { @@ -5538,11 +5848,7 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFogState)) { m_flags.clr(D3D9DeviceFlag::DirtyFogState); - EmitCs([cEnabled = fogEnabled] (DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::FogEnabled, cEnabled); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::VertexFogMode, D3DFOG_NONE); - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PixelFogMode, D3DFOG_NONE); - }); + UpdateFogModeSpec(fogEnabled, D3DFOG_NONE, D3DFOG_NONE); } } } @@ -5568,33 +5874,46 @@ namespace dxvk { else if (unlikely(sampleCount != rtImageInfo.sampleCount)) continue; - if (!m_state.renderStates[ColorWriteIndex(i)]) + if (!(m_anyColorWrites & (1 << i))) + continue; + + if (!(m_psShaderMasks.rtMask & (1 << i))) continue; attachments.color[i] = { m_state.renderTargets[i]->GetRenderTargetView(srgb), - m_state.renderTargets[i]->GetRenderTargetLayout() }; + m_state.renderTargets[i]->GetRenderTargetLayout(m_hazardLayout) }; } if (m_state.depthStencil != nullptr && (m_state.renderStates[D3DRS_ZENABLE] || m_state.renderStates[D3DRS_ZWRITEENABLE] - || m_state.renderStates[D3DRS_STENCILENABLE])) { + || m_state.renderStates[D3DRS_STENCILENABLE] + || m_state.renderStates[D3DRS_ADAPTIVETESS_X] == uint32_t(D3D9Format::NVDB))) { const DxvkImageCreateInfo& dsImageInfo = m_state.depthStencil->GetCommonTexture()->GetImage()->info(); const bool depthWrite = m_state.renderStates[D3DRS_ZWRITEENABLE]; if (likely(sampleCount == VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM || sampleCount == dsImageInfo.sampleCount)) { attachments.depth = { m_state.depthStencil->GetDepthStencilView(), - m_state.depthStencil->GetDepthStencilLayout(depthWrite, m_activeHazardsDS != 0) }; + m_state.depthStencil->GetDepthStencilLayout(depthWrite, m_activeHazardsDS != 0, m_hazardLayout) }; } } + VkImageAspectFlags feedbackLoopAspects = 0u; + if (m_hazardLayout == VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT) { + if (m_activeHazardsRT != 0) + feedbackLoopAspects |= VK_IMAGE_ASPECT_COLOR_BIT; + if (m_activeHazardsDS != 0 && attachments.depth.layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) + feedbackLoopAspects |= VK_IMAGE_ASPECT_DEPTH_BIT; + } + // Create and bind the framebuffer object to the context EmitCs([ - cAttachments = std::move(attachments) - ] (DxvkContext* ctx) { - ctx->bindRenderTargets(cAttachments); + cAttachments = std::move(attachments), + cFeedbackLoopAspects = feedbackLoopAspects + ] (DxvkContext* ctx) mutable { + ctx->bindRenderTargets(std::move(cAttachments), cFeedbackLoopAspects); }); } @@ -5616,12 +5935,23 @@ namespace dxvk { // Originally we did this only for powers of two // resolutions but since NEAREST filtering fixed to // truncate, we need to do this all the time now. - float cf = 0.5f - (1.0f / 128.0f); + constexpr float cf = 0.5f - (1.0f / 128.0f); + + // How much to bias MinZ by to avoid a depth + // degenerate viewport. + // Tests show that the bias is only applied below minZ values of 0.5 + float zBias; + if (vp.MinZ >= 0.5f) { + zBias = 0.0f; + } else { + zBias = 0.001f; + } viewport = VkViewport{ float(vp.X) + cf, float(vp.Height + vp.Y) + cf, float(vp.Width), -float(vp.Height), - vp.MinZ, vp.MaxZ, + std::clamp(vp.MinZ, 0.0f, 1.0f), + std::clamp(std::max(vp.MaxZ, vp.MinZ + zBias), 0.0f, 1.0f), }; // Scissor rectangles. Vulkan does not provide an easy way @@ -5824,14 +6154,13 @@ namespace dxvk { auto& rs = m_state.renderStates; - DxvkRasterizerState state; + DxvkRasterizerState state = { }; state.cullMode = DecodeCullMode(D3DCULL(rs[D3DRS_CULLMODE])); state.depthBiasEnable = IsDepthBiasEnabled(); state.depthClipEnable = true; state.frontFace = VK_FRONT_FACE_CLOCKWISE; state.polygonMode = DecodeFillMode(D3DFILLMODE(rs[D3DRS_FILLMODE])); - state.conservativeMode = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT; - state.sampleCount = 0; + state.flatShading = m_state.renderStates[D3DRS_SHADEMODE] == D3DSHADE_FLAT; EmitCs([ cState = state @@ -5862,6 +6191,42 @@ namespace dxvk { } + uint32_t D3D9DeviceEx::GetAlphaTestPrecision() { + if (m_state.renderTargets[0] == nullptr) + return 0; + + D3D9Format format = m_state.renderTargets[0]->GetCommonTexture()->Desc()->Format; + + switch (format) { + case D3D9Format::A2B10G10R10: + case D3D9Format::A2R10G10B10: + case D3D9Format::A2W10V10U10: + case D3D9Format::A2B10G10R10_XR_BIAS: + return 0x2; /* 10 bit */ + + case D3D9Format::R16F: + case D3D9Format::G16R16F: + case D3D9Format::A16B16G16R16F: + return 0x7; /* 15 bit */ + + case D3D9Format::G16R16: + case D3D9Format::A16B16G16R16: + case D3D9Format::V16U16: + case D3D9Format::L16: + case D3D9Format::Q16W16V16U16: + return 0x8; /* 16 bit */ + + case D3D9Format::R32F: + case D3D9Format::G32R32F: + case D3D9Format::A32B32G32R32F: + return 0xF; /* float */ + + default: + return 0x0; /* 8 bit */ + } + } + + void D3D9DeviceEx::BindAlphaTestState() { m_flags.clr(D3D9DeviceFlag::DirtyAlphaTestState); @@ -5871,9 +6236,11 @@ namespace dxvk { ? DecodeCompareOp(D3DCMPFUNC(rs[D3DRS_ALPHAFUNC])) : VK_COMPARE_OP_ALWAYS; - EmitCs([cAlphaOp = alphaOp] (DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::AlphaCompareOp, cAlphaOp); - }); + uint32_t precision = alphaOp != VK_COMPARE_OP_ALWAYS + ? GetAlphaTestPrecision() + : 0u; + + UpdateAlphaTestSpec(alphaOp, precision); } @@ -5904,6 +6271,12 @@ namespace dxvk { key.BorderColor = D3DCOLOR(state[D3DSAMP_BORDERCOLOR]); key.Depth = m_depthTextures & (1u << Sampler); + if (m_cubeTextures & (1u << Sampler)) { + key.AddressU = D3DTADDRESS_CLAMP; + key.AddressV = D3DTADDRESS_CLAMP; + key.AddressW = D3DTADDRESS_CLAMP; + } + if (m_d3d9Options.samplerAnisotropy != -1) { if (key.MagFilter == D3DTEXF_LINEAR) key.MagFilter = D3DTEXF_ANISOTROPIC; @@ -5926,9 +6299,12 @@ namespace dxvk { cSlot = slot, cKey = key ] (DxvkContext* ctx) { + VkShaderStageFlags stage = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + auto pair = m_samplers.find(cKey); if (pair != m_samplers.end()) { - ctx->bindResourceSampler(cSlot, pair->second); + ctx->bindResourceSampler(stage, cSlot, + Rc(pair->second)); return; } @@ -5945,10 +6321,16 @@ namespace dxvk { info.mipmapMode = mipFilter.MipFilter; info.maxAnisotropy = float(cKey.MaxAnisotropy); info.useAnisotropy = cKey.MaxAnisotropy > 1; - info.mipmapLodBias = cKey.MipmapLodBias; + + info.mipmapLodBias = cKey.MipmapLodBias + m_d3d9Options.samplerLodBias; + if (m_d3d9Options.clampNegativeLodBias) + info.mipmapLodBias = std::max(info.mipmapLodBias, 0.0f); + info.mipmapLodMin = mipFilter.MipsEnabled ? float(cKey.MaxMipLevel) : 0; info.mipmapLodMax = mipFilter.MipsEnabled ? FLT_MAX : 0; + info.reductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE; info.usePixelCoord = VK_FALSE; + info.nonSeamless = m_dxvkDevice->features().extNonSeamlessCubeMap.nonSeamlessCubeMap && !m_d3d9Options.seamlessCubes; DecodeD3DCOLOR(cKey.BorderColor, info.borderColor.float32); @@ -5968,7 +6350,7 @@ namespace dxvk { auto sampler = m_dxvkDevice->createSampler(info); m_samplers.insert(std::make_pair(cKey, sampler)); - ctx->bindResourceSampler(cSlot, std::move(sampler)); + ctx->bindResourceSampler(stage, cSlot, std::move(sampler)); m_samplerCount++; } @@ -5994,8 +6376,9 @@ namespace dxvk { EmitCs([ cSlot = slot, cImageView = commonTex->GetSampleView(srgb) - ](DxvkContext* ctx) { - ctx->bindResourceView(cSlot, cImageView, nullptr); + ](DxvkContext* ctx) mutable { + VkShaderStageFlags stage = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + ctx->bindResourceImageView(stage, cSlot, std::move(cImageView)); }); } @@ -6010,7 +6393,8 @@ namespace dxvk { uint32_t slot = computeResourceSlotId(shaderSampler.first, DxsoBindingType::Image, uint32_t(shaderSampler.second)); - ctx->bindResourceView(slot, nullptr, nullptr); + VkShaderStageFlags stage = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + ctx->bindResourceImageView(stage, slot, nullptr); } }); } @@ -6066,18 +6450,14 @@ namespace dxvk { void D3D9DeviceEx::PrepareDraw(D3DPRIMITIVETYPE PrimitiveType) { - if (unlikely(m_activeHazardsRT != 0)) { - EmitCs([](DxvkContext* ctx) { - ctx->emitRenderTargetReadbackBarrier(); - }); + if (unlikely(m_activeHazardsRT != 0 || m_activeHazardsDS != 0)) + MarkRenderHazards(); - if (m_d3d9Options.generalHazards) - MarkRenderHazards(); - } - - if (unlikely((m_lastHazardsDS == 0) != (m_activeHazardsDS == 0))) { + if (unlikely((!m_lastHazardsDS) != (!m_activeHazardsDS)) + || unlikely((!m_lastHazardsRT) != (!m_activeHazardsRT))) { m_flags.set(D3D9DeviceFlag::DirtyFramebuffer); m_lastHazardsDS = m_activeHazardsDS; + m_lastHazardsRT = m_activeHazardsRT; } for (uint32_t i = 0; i < caps::MaxStreams; i++) { @@ -6138,47 +6518,32 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyClipPlanes)) UpdateClipPlanes(); - if (PrimitiveType == D3DPT_POINTLIST) - UpdatePointMode(); - else if (m_lastPointMode != 0) - UpdatePointMode(); + UpdatePointMode(PrimitiveType == D3DPT_POINTLIST); if (likely(UseProgrammableVS())) { if (unlikely(m_flags.test(D3D9DeviceFlag::DirtyProgVertexShader))) { m_flags.set(D3D9DeviceFlag::DirtyInputLayout); BindShader( - GetCommonShader(m_state.vertexShader), - GetVertexShaderPermutation()); + GetCommonShader(m_state.vertexShader)); } UploadConstants(); if (likely(!CanSWVP())) { - UpdateBoolSpecConstantVertex( - m_state.vsConsts.bConsts[0] & + UpdateVertexBoolSpec( + m_state.vsConsts->bConsts[0] & m_consts[DxsoProgramType::VertexShader].meta.boolConstantMask); } else - UpdateBoolSpecConstantVertex(0); + UpdateVertexBoolSpec(0); } else { - UpdateBoolSpecConstantVertex(0); + UpdateVertexBoolSpec(0); UpdateFixedFunctionVS(); } if (m_flags.test(D3D9DeviceFlag::DirtyInputLayout)) BindInputLayout(); - auto UpdateSamplerTypes = [&](uint32_t types, uint32_t projections, uint32_t fetch4) { - if (m_lastSamplerTypes != types) - UpdateSamplerSpecConsant(types); - - if (m_lastProjectionBitfield != projections) - UpdateProjectionSpecConstant(projections); - - if (m_lastFetch4 != fetch4) - UpdateFetch4SpecConstant(fetch4); - }; - if (likely(UseProgrammablePS())) { UploadConstants(); @@ -6189,38 +6554,31 @@ namespace dxvk { const auto& programInfo = GetCommonShader(m_state.pixelShader)->GetInfo(); if (programInfo.majorVersion() >= 2) - UpdateSamplerTypes(m_d3d9Options.forceSamplerTypeSpecConstants ? m_textureTypes : 0u, 0u, fetch4); + UpdatePixelShaderSamplerSpec(m_d3d9Options.forceSamplerTypeSpecConstants ? m_textureTypes : 0u, 0u, fetch4); else - UpdateSamplerTypes(m_textureTypes, programInfo.minorVersion() >= 4 ? 0u : projected, fetch4); // For implicit samplers... + UpdatePixelShaderSamplerSpec(m_textureTypes, programInfo.minorVersion() >= 4 ? 0u : projected, fetch4); // For implicit samplers... - UpdateBoolSpecConstantPixel( - m_state.psConsts.bConsts[0] & + UpdatePixelBoolSpec( + m_state.psConsts->bConsts[0] & m_consts[DxsoProgramType::PixelShader].meta.boolConstantMask); } else { - UpdateBoolSpecConstantPixel(0); - UpdateSamplerTypes(0u, 0u, 0u); + UpdatePixelBoolSpec(0); + UpdatePixelShaderSamplerSpec(0u, 0u, 0u); UpdateFixedFunctionPS(); } + const uint32_t nullTextureMask = usedSamplerMask & ~usedTextureMask; const uint32_t depthTextureMask = m_depthTextures & usedTextureMask; - if (depthTextureMask != m_lastSamplerDepthMode) - UpdateSamplerDepthModeSpecConstant(depthTextureMask); + const uint32_t drefClampMask = m_drefClamp & depthTextureMask; + UpdateCommonSamplerSpec(nullTextureMask, depthTextureMask, drefClampMask); if (m_flags.test(D3D9DeviceFlag::DirtySharedPixelShaderData)) { m_flags.clr(D3D9DeviceFlag::DirtySharedPixelShaderData); - DxvkBufferSliceHandle slice = m_psShared->allocSlice(); - - EmitCs([ - cBuffer = m_psShared, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); - - D3D9SharedPS* data = reinterpret_cast(slice.mapPtr); + auto mapPtr = m_psShared.AllocSlice(); + D3D9SharedPS* data = reinterpret_cast(mapPtr); for (uint32_t i = 0; i < caps::TextureStageCount; i++) { DecodeD3DCOLOR(D3DCOLOR(m_state.textureStages[i][DXVK_TSS_CONSTANT]), data->Stages[i].Constant); @@ -6251,17 +6609,24 @@ namespace dxvk { ctx->setDepthBounds(cDepthBounds); }); } + + BindSpecConstants(); } template void D3D9DeviceEx::BindShader( - const D3D9CommonShader* pShaderModule, - D3D9ShaderPermutation Permutation) { + const D3D9CommonShader* pShaderModule) { + auto shader = pShaderModule->GetShader(); + + if (unlikely(shader->needsLibraryCompile())) + m_dxvkDevice->requestCompileShader(shader); + EmitCs([ - cShader = pShaderModule->GetShader(Permutation) - ] (DxvkContext* ctx) { - ctx->bindShader(GetShaderStage(ShaderStage), cShader); + cShader = std::move(shader) + ] (DxvkContext* ctx) mutable { + constexpr VkShaderStageFlagBits stage = GetShaderStage(ShaderStage); + ctx->bindShader(std::move(cShader)); }); } @@ -6337,6 +6702,7 @@ namespace dxvk { DxvkVertexBinding binding; binding.binding = attrib.binding; + binding.extent = attrib.offset + lookupFormatInfo(attrib.format)->elementSize; uint32_t instanceData = cStreamFreq[binding.binding % caps::MaxStreams]; if (instanceData & D3DSTREAMSOURCE_INSTANCEDATA) { @@ -6348,19 +6714,12 @@ namespace dxvk { binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; } - // Check if the binding was already defined. - bool bindingDefined = false; - - for (uint32_t j = 0; j < i; j++) { - uint32_t bindingId = attrList.at(j).binding; - - if (binding.binding == bindingId) { - bindingDefined = true; - } - } - - if (!bindingDefined) + if (bindMask & (1u << binding.binding)) { + bindList.at(binding.binding).extent = std::max( + bindList.at(binding.binding).extent, binding.extent); + } else { bindList.at(binding.binding) = binding; + } attrMask |= 1u << i; bindMask |= 1u << binding.binding; @@ -6390,8 +6749,8 @@ namespace dxvk { pBuffer->GetCommonBuffer()->GetBufferSlice(Offset) : DxvkBufferSlice(), cStride = pBuffer != nullptr ? Stride : 0 - ] (DxvkContext* ctx) { - ctx->bindVertexBuffer(cSlotId, cBufferSlice, cStride); + ] (DxvkContext* ctx) mutable { + ctx->bindVertexBuffer(cSlotId, std::move(cBufferSlice), cStride); }); } @@ -6407,8 +6766,8 @@ namespace dxvk { EmitCs([ cBufferSlice = buffer != nullptr ? buffer->GetBufferSlice() : DxvkBufferSlice(), cIndexType = indexType - ](DxvkContext* ctx) { - ctx->bindIndexBuffer(cBufferSlice, cIndexType); + ](DxvkContext* ctx) mutable { + ctx->bindIndexBuffer(std::move(cBufferSlice), cIndexType); }); } @@ -6433,24 +6792,24 @@ namespace dxvk { if (unlikely(pQuery->IsEvent())) { pQuery->IsStalling() ? Flush() - : FlushImplicit(TRUE); + : ConsiderFlush(GpuFlushType::ImplicitStrongHint); } else if (pQuery->IsStalling()) { - FlushImplicit(FALSE); + ConsiderFlush(GpuFlushType::ImplicitWeakHint); } } void D3D9DeviceEx::SetVertexBoolBitfield(uint32_t idx, uint32_t mask, uint32_t bits) { - m_state.vsConsts.bConsts[idx] &= ~mask; - m_state.vsConsts.bConsts[idx] |= bits & mask; + m_state.vsConsts->bConsts[idx] &= ~mask; + m_state.vsConsts->bConsts[idx] |= bits & mask; m_consts[DxsoProgramTypes::VertexShader].dirty = true; } void D3D9DeviceEx::SetPixelBoolBitfield(uint32_t idx, uint32_t mask, uint32_t bits) { - m_state.psConsts.bConsts[idx] &= ~mask; - m_state.psConsts.bConsts[idx] |= bits & mask; + m_state.psConsts->bConsts[idx] &= ~mask; + m_state.psConsts->bConsts[idx] |= bits & mask; m_consts[DxsoProgramTypes::PixelShader].dirty = true; } @@ -6458,12 +6817,13 @@ namespace dxvk { HRESULT D3D9DeviceEx::CreateShaderModule( D3D9CommonShader* pShaderModule, + uint32_t* pLength, VkShaderStageFlagBits ShaderStage, const DWORD* pShaderBytecode, const DxsoModuleInfo* pModuleInfo) { try { m_shaderModules->GetShaderModule(this, pShaderModule, - ShaderStage, pModuleInfo, pShaderBytecode); + pLength, ShaderStage, pModuleInfo, pShaderBytecode); return D3D_OK; } @@ -6640,7 +7000,7 @@ namespace dxvk { &cShaders = m_ffModules ](DxvkContext* ctx) { auto shader = cShaders.GetShaderModule(this, cKey); - ctx->bindShader(VK_SHADER_STAGE_VERTEX_BIT, shader.GetShader()); + ctx->bindShader(shader.GetShader()); }); } @@ -6678,19 +7038,12 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFFVertexData)) { m_flags.clr(D3D9DeviceFlag::DirtyFFVertexData); - DxvkBufferSliceHandle slice = m_vsFixedFunction->allocSlice(); - - EmitCs([ - cBuffer = m_vsFixedFunction, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); + auto mapPtr = m_vsFixedFunction.AllocSlice(); auto WorldView = m_state.transforms[GetTransformIndex(D3DTS_VIEW)] * m_state.transforms[GetTransformIndex(D3DTS_WORLD)]; auto NormalMatrix = inverse(WorldView); - D3D9FixedFunctionVS* data = reinterpret_cast(slice.mapPtr); + D3D9FixedFunctionVS* data = reinterpret_cast(mapPtr); data->WorldView = WorldView; data->NormalMatrix = NormalMatrix; data->InverseView = transpose(inverse(m_state.transforms[GetTransformIndex(D3DTS_VIEW)])); @@ -6719,23 +7072,15 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFFVertexBlend) && vertexBlendMode == D3D9FF_VertexBlendMode_Normal) { m_flags.clr(D3D9DeviceFlag::DirtyFFVertexBlend); - DxvkBufferSliceHandle slice = m_vsVertexBlend->allocSlice(); - - EmitCs([ - cBuffer = m_vsVertexBlend, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); - + auto mapPtr = m_vsVertexBlend.AllocSlice(); auto UploadVertexBlendData = [&](auto data) { for (uint32_t i = 0; i < std::size(data->WorldView); i++) data->WorldView[i] = m_state.transforms[GetTransformIndex(D3DTS_VIEW)] * m_state.transforms[GetTransformIndex(D3DTS_WORLDMATRIX(i))]; }; (m_isSWVP && indexedVertexBlend) - ? UploadVertexBlendData(reinterpret_cast(slice.mapPtr)) - : UploadVertexBlendData(reinterpret_cast(slice.mapPtr)); + ? UploadVertexBlendData(reinterpret_cast(mapPtr)) + : UploadVertexBlendData(reinterpret_cast(mapPtr)); } } @@ -6784,6 +7129,8 @@ namespace dxvk { break; } + stage.TextureBound = m_state.textures[idx] != nullptr ? 1 : 0; + stage.ColorOp = data[DXVK_TSS_COLOROP]; stage.AlphaOp = data[DXVK_TSS_ALPHAOP]; @@ -6816,7 +7163,6 @@ namespace dxvk { } stage0.GlobalSpecularEnable = m_state.renderStates[D3DRS_SPECULARENABLE]; - stage0.GlobalFlatShade = m_state.renderStates[D3DRS_SHADEMODE] == D3DSHADE_FLAT; // The last stage *always* writes to current. if (idx >= 1) @@ -6828,7 +7174,7 @@ namespace dxvk { &cShaders = m_ffModules ](DxvkContext* ctx) { auto shader = cShaders.GetShaderModule(this, cKey); - ctx->bindShader(VK_SHADER_STAGE_FRAGMENT_BIT, shader.GetShader()); + ctx->bindShader(shader.GetShader()); }); } @@ -6837,18 +7183,10 @@ namespace dxvk { if (m_flags.test(D3D9DeviceFlag::DirtyFFPixelData)) { m_flags.clr(D3D9DeviceFlag::DirtyFFPixelData); - DxvkBufferSliceHandle slice = m_psFixedFunction->allocSlice(); - - EmitCs([ - cBuffer = m_psFixedFunction, - cSlice = slice - ] (DxvkContext* ctx) { - ctx->invalidateBuffer(cBuffer, cSlice); - }); - + auto mapPtr = m_psFixedFunction.AllocSlice(); auto& rs = m_state.renderStates; - D3D9FixedFunctionPS* data = reinterpret_cast(slice.mapPtr); + D3D9FixedFunctionPS* data = reinterpret_cast(mapPtr); DecodeD3DCOLOR((D3DCOLOR)rs[D3DRS_TEXTUREFACTOR], data->textureFactor.data); } } @@ -6866,66 +7204,6 @@ namespace dxvk { } - void D3D9DeviceEx::UpdateBoolSpecConstantVertex(uint32_t value) { - if (value == m_lastBoolSpecConstantVertex) - return; - - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::VertexShaderBools, cBitfield); - }); - - m_lastBoolSpecConstantVertex = value; - } - - - void D3D9DeviceEx::UpdateBoolSpecConstantPixel(uint32_t value) { - if (value == m_lastBoolSpecConstantPixel) - return; - - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::PixelShaderBools, cBitfield); - }); - - m_lastBoolSpecConstantPixel = value; - } - - - void D3D9DeviceEx::UpdateSamplerSpecConsant(uint32_t value) { - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::SamplerType, cBitfield); - }); - - m_lastSamplerTypes = value; - } - - - void D3D9DeviceEx::UpdateProjectionSpecConstant(uint32_t value) { - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::ProjectionType, cBitfield); - }); - - m_lastProjectionBitfield = value; - } - - - void D3D9DeviceEx::UpdateFetch4SpecConstant(uint32_t value) { - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::Fetch4, cBitfield); - }); - - m_lastFetch4 = value; - } - - - void D3D9DeviceEx::UpdateSamplerDepthModeSpecConstant(uint32_t value) { - EmitCs([cBitfield = value](DxvkContext* ctx) { - ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, D3D9SpecConstantId::SamplerDepthMode, cBitfield); - }); - - m_lastSamplerDepthMode = value; - } - - void D3D9DeviceEx::ApplyPrimitiveType( DxvkContext* pContext, D3DPRIMITIVETYPE PrimType) { @@ -6952,7 +7230,7 @@ namespace dxvk { const D3D9_COMMON_TEXTURE_DESC* dstDesc = dstTextureInfo->Desc(); VkSampleCountFlagBits dstSampleCount; - DecodeMultiSampleType(dstDesc->MultiSample, dstDesc->MultisampleQuality, &dstSampleCount); + DecodeMultiSampleType(m_dxvkDevice, dstDesc->MultiSample, dstDesc->MultisampleQuality, &dstSampleCount); if (unlikely(dstSampleCount != VK_SAMPLE_COUNT_1_BIT)) { Logger::warn("D3D9DeviceEx::ResolveZ: dstSampleCount != 1. Discarding."); @@ -6962,8 +7240,8 @@ namespace dxvk { const D3D9_VK_FORMAT_MAPPING srcFormatInfo = LookupFormat(srcDesc->Format); const D3D9_VK_FORMAT_MAPPING dstFormatInfo = LookupFormat(dstDesc->Format); - auto srcVulkanFormatInfo = imageFormatInfo(srcFormatInfo.FormatColor); - auto dstVulkanFormatInfo = imageFormatInfo(dstFormatInfo.FormatColor); + auto srcVulkanFormatInfo = lookupFormatInfo(srcFormatInfo.FormatColor); + auto dstVulkanFormatInfo = lookupFormatInfo(dstFormatInfo.FormatColor); const VkImageSubresource dstSubresource = dstTextureInfo->GetSubresourceFromIndex( @@ -6984,7 +7262,7 @@ namespace dxvk { srcSubresource.arrayLayer, 1 }; VkSampleCountFlagBits srcSampleCount; - DecodeMultiSampleType(srcDesc->MultiSample, srcDesc->MultisampleQuality, &srcSampleCount); + DecodeMultiSampleType(m_dxvkDevice, srcDesc->MultiSample, srcDesc->MultisampleQuality, &srcSampleCount); if (srcSampleCount == VK_SAMPLE_COUNT_1_BIT) { EmitCs([ @@ -7008,7 +7286,7 @@ namespace dxvk { // We should resolve using the first sample according to // http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/Advanced-DX9-Capabilities-for-ATI-Radeon-Cards_v2.pdf // "The resolve operation copies the depth value from the *first sample only* into the resolved depth stencil texture." - constexpr auto resolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR; + constexpr auto resolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT; VkImageResolve region; region.srcSubresource = cSrcSubres; @@ -7054,12 +7332,11 @@ namespace dxvk { } - HRESULT D3D9DeviceEx::ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters) { - if (!pPresentationParameters->EnableAutoDepthStencil) - SetDepthStencilSurface(nullptr); + void D3D9DeviceEx::ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters) { + SetDepthStencilSurface(nullptr); - for (uint32_t i = 1; i < caps::MaxSimultaneousRenderTargets; i++) - SetRenderTarget(i, nullptr); + for (uint32_t i = 0; i < caps::MaxSimultaneousRenderTargets; i++) + SetRenderTargetInternal(i, nullptr); auto& rs = m_state.renderStates; @@ -7168,7 +7445,7 @@ namespace dxvk { UpdatePushConstant(); UpdatePushConstant(); m_flags.set(D3D9DeviceFlag::DirtyPointScale); - UpdatePointMode(); + UpdatePointMode(false); rs[D3DRS_SRGBWRITEENABLE] = 0; @@ -7242,23 +7519,27 @@ namespace dxvk { for (uint32_t i = 0; i < caps::MaxStreams; i++) m_state.streamFreq[i] = 1; - for (uint32_t i = 0; i < m_state.textures.size(); i++) - TextureChangePrivate(m_state.textures[i], nullptr); + for (uint32_t i = 0; i < m_state.textures->size(); i++) { + SetStateTexture(i, nullptr); + } EmitCs([ - cSize = m_state.textures.size() + cSize = m_state.textures->size() ](DxvkContext* ctx) { + VkShaderStageFlags stage = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT; + for (uint32_t i = 0; i < cSize; i++) { auto samplerInfo = RemapStateSamplerShader(DWORD(i)); uint32_t slot = computeResourceSlotId(samplerInfo.first, DxsoBindingType::Image, uint32_t(samplerInfo.second)); - ctx->bindResourceView(slot, nullptr, nullptr); + ctx->bindResourceImageView(stage, slot, nullptr); } }); m_dirtyTextures = 0; m_depthTextures = 0; + m_cubeTextures = 0; - auto& ss = m_state.samplerStates; + auto& ss = m_state.samplerStates.get(); for (uint32_t i = 0; i < ss.size(); i++) { auto& state = ss[i]; state[D3DSAMP_ADDRESSU] = D3DTADDRESS_WRAP; @@ -7288,17 +7569,26 @@ namespace dxvk { // We should do this... m_flags.set(D3D9DeviceFlag::DirtyInputLayout); - UpdateSamplerSpecConsant(0u); - UpdateBoolSpecConstantVertex(0u); - UpdateBoolSpecConstantPixel(0u); - UpdateSamplerDepthModeSpecConstant(0u); + UpdatePixelShaderSamplerSpec(0u, 0u, 0u); + UpdateVertexBoolSpec(0u); + UpdatePixelBoolSpec(0u); + UpdateCommonSamplerSpec(0u, 0u, 0u); - return D3D_OK; + UpdateAnyColorWrites<0>(true); + UpdateAnyColorWrites<1>(true); + UpdateAnyColorWrites<2>(true); + UpdateAnyColorWrites<3>(true); + + SetIndices(nullptr); + for (uint32_t i = 0; i < caps::MaxStreams; i++) { + SetStreamSource(i, nullptr, 0, 0); + } } HRESULT D3D9DeviceEx::ResetSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode) { D3D9Format backBufferFmt = EnumerateFormat(pPresentationParameters->BackBufferFormat); + bool unlockedFormats = m_implicitSwapchain != nullptr && m_implicitSwapchain->HasFormatsUnlocked(); Logger::info(str::format( "D3D9DeviceEx::ResetSwapChain:\n", @@ -7308,9 +7598,10 @@ namespace dxvk { " - Format: ", backBufferFmt, "\n" " - Auto Depth Stencil: ", pPresentationParameters->EnableAutoDepthStencil ? "true" : "false", "\n", " ^ Format: ", EnumerateFormat(pPresentationParameters->AutoDepthStencilFormat), "\n", - " - Windowed: ", pPresentationParameters->Windowed ? "true" : "false", "\n")); + " - Windowed: ", pPresentationParameters->Windowed ? "true" : "false", "\n", + " - Swap effect: ", pPresentationParameters->SwapEffect, "\n")); - if (backBufferFmt != D3D9Format::Unknown) { + if (backBufferFmt != D3D9Format::Unknown && !unlockedFormats) { if (!IsSupportedBackBufferFormat(backBufferFmt)) { Logger::err(str::format("D3D9DeviceEx::ResetSwapChain: Unsupported backbuffer format: ", EnumerateFormat(pPresentationParameters->BackBufferFormat))); @@ -7319,8 +7610,9 @@ namespace dxvk { } if (m_implicitSwapchain != nullptr) { - if (FAILED(m_implicitSwapchain->Reset(pPresentationParameters, pFullscreenDisplayMode))) - return D3DERR_INVALIDCALL; + HRESULT hr = m_implicitSwapchain->Reset(pPresentationParameters, pFullscreenDisplayMode); + if (FAILED(hr)) + return hr; } else m_implicitSwapchain = new D3D9SwapChainEx(this, pPresentationParameters, pFullscreenDisplayMode); @@ -7340,6 +7632,8 @@ namespace dxvk { desc.MultisampleQuality = pPresentationParameters->MultiSampleQuality; desc.IsBackBuffer = FALSE; desc.IsAttachmentOnly = TRUE; + // Docs: Also note that - unlike textures - swap chain back buffers, render targets [..] can be locked + desc.IsLockable = TRUE; if (FAILED(D3D9CommonTexture::NormalizeTextureProperties(this, &desc))) return D3DERR_NOTAVAILABLE; @@ -7347,6 +7641,7 @@ namespace dxvk { m_autoDepthStencil = new D3D9Surface(this, &desc, nullptr, nullptr); m_initializer->InitTexture(m_autoDepthStencil->GetCommonTexture()); SetDepthStencilSurface(m_autoDepthStencil.ptr()); + m_losableResourceCounter++; } SetRenderTarget(0, m_implicitSwapchain->GetBackBuffer(0)); @@ -7359,11 +7654,9 @@ namespace dxvk { HRESULT D3D9DeviceEx::InitialReset(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode) { - HRESULT hr = ResetSwapChain(pPresentationParameters, pFullscreenDisplayMode); - if (FAILED(hr)) - return hr; + ResetState(pPresentationParameters); - hr = ResetState(pPresentationParameters); + HRESULT hr = ResetSwapChain(pPresentationParameters, pFullscreenDisplayMode); if (FAILED(hr)) return hr; @@ -7393,4 +7686,178 @@ namespace dxvk { return m_csChunk->empty() ? m_csSeqNum : m_csSeqNum + 1; } + + void* D3D9DeviceEx::MapTexture(D3D9CommonTexture* pTexture, UINT Subresource) { + // Will only be called inside the device lock + void *ptr = pTexture->GetData(Subresource); + +#ifdef D3D9_ALLOW_UNMAPPING + if (likely(pTexture->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE)) { + m_mappedTextures.insert(pTexture); + } +#endif + + return ptr; + } + + void D3D9DeviceEx::TouchMappedTexture(D3D9CommonTexture* pTexture) { +#ifdef D3D9_ALLOW_UNMAPPING + if (pTexture->GetMapMode() != D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE) + return; + + D3D9DeviceLock lock = LockDevice(); + m_mappedTextures.touch(pTexture); +#endif + } + + void D3D9DeviceEx::RemoveMappedTexture(D3D9CommonTexture* pTexture) { +#ifdef D3D9_ALLOW_UNMAPPING + if (pTexture->GetMapMode() != D3D9_COMMON_TEXTURE_MAP_MODE_UNMAPPABLE) + return; + + D3D9DeviceLock lock = LockDevice(); + m_mappedTextures.remove(pTexture); +#endif + } + + void D3D9DeviceEx::UnmapTextures() { + // Will only be called inside the device lock + +#ifdef D3D9_ALLOW_UNMAPPING + uint32_t mappedMemory = m_memoryAllocator.MappedMemory(); + if (likely(mappedMemory < uint32_t(m_d3d9Options.textureMemory))) + return; + + uint32_t threshold = (m_d3d9Options.textureMemory / 4) * 3; + + auto iter = m_mappedTextures.leastRecentlyUsedIter(); + while (m_memoryAllocator.MappedMemory() >= threshold && iter != m_mappedTextures.leastRecentlyUsedEndIter()) { + if (unlikely((*iter)->IsAnySubresourceLocked() != 0)) { + iter++; + continue; + } + (*iter)->UnmapData(); + + iter = m_mappedTextures.remove(iter); + } +#endif + } + + //////////////////////////////////// + // D3D9 Device Lost + //////////////////////////////////// + + void D3D9DeviceEx::NotifyFullscreen(HWND window, bool fullscreen) { + D3D9DeviceLock lock = LockDevice(); + + if (fullscreen) { + if (unlikely(window != m_fullscreenWindow && m_fullscreenWindow != NULL)) { + Logger::warn("Multiple fullscreen windows detected."); + } + m_fullscreenWindow = window; + } else { + if (unlikely(m_fullscreenWindow != window)) { + Logger::warn("Window was not fullscreen in the first place."); + } else { + m_fullscreenWindow = 0; + } + } + } + + void D3D9DeviceEx::NotifyWindowActivated(HWND window, bool activated) { + D3D9DeviceLock lock = LockDevice(); + + if (likely(!m_d3d9Options.deviceLossOnFocusLoss || IsExtended())) + return; + + if (activated && m_deviceLostState == D3D9DeviceLostState::Lost) { + Logger::info("Device not reset"); + m_deviceLostState = D3D9DeviceLostState::NotReset; + } else if (!activated && m_deviceLostState != D3D9DeviceLostState::Lost && m_fullscreenWindow == window) { + Logger::info("Device lost"); + m_deviceLostState = D3D9DeviceLostState::Lost; + m_fullscreenWindow = NULL; + } + } + + //////////////////////////////////// + // D3D9 Device Specialization State + //////////////////////////////////// + + void D3D9DeviceEx::UpdateAlphaTestSpec(VkCompareOp alphaOp, uint32_t precision) { + bool dirty = m_specInfo.set(uint32_t(alphaOp)); + dirty |= m_specInfo.set(precision); + + if (dirty) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdateVertexBoolSpec(uint32_t value) { + if (m_specInfo.set(value)) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdatePixelBoolSpec(uint32_t value) { + if (m_specInfo.set(value)) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdatePixelShaderSamplerSpec(uint32_t types, uint32_t projections, uint32_t fetch4) { + bool dirty = m_specInfo.set(types); + dirty |= m_specInfo.set(projections); + dirty |= m_specInfo.set(fetch4); + + if (dirty) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdateCommonSamplerSpec(uint32_t nullMask, uint32_t depthMask, uint32_t drefMask) { + bool dirty = m_specInfo.set(depthMask); + dirty |= m_specInfo.set(nullMask); + dirty |= m_specInfo.set(drefMask); + + if (dirty) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdatePointModeSpec(uint32_t mode) { + if (m_specInfo.set(mode)) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::UpdateFogModeSpec(bool fogEnabled, D3DFOGMODE vertexFogMode, D3DFOGMODE pixelFogMode) { + bool dirty = m_specInfo.set(fogEnabled); + dirty |= m_specInfo.set(vertexFogMode); + dirty |= m_specInfo.set(pixelFogMode); + + if (dirty) + m_flags.set(D3D9DeviceFlag::DirtySpecializationEntries); + } + + + void D3D9DeviceEx::BindSpecConstants() { + if (!m_flags.test(D3D9DeviceFlag::DirtySpecializationEntries)) + return; + + EmitCs([cSpecInfo = m_specInfo](DxvkContext* ctx) { + for (size_t i = 0; i < cSpecInfo.data.size(); i++) + ctx->setSpecConstant(VK_PIPELINE_BIND_POINT_GRAPHICS, i, cSpecInfo.data[i]); + }); + + if (m_usingGraphicsPipelines) { + // TODO: Make uploading specialization information less naive. + auto mapPtr = m_specBuffer.AllocSlice(); + auto dst = reinterpret_cast(mapPtr); + *dst = m_specInfo; + } + + m_flags.clr(D3D9DeviceFlag::DirtySpecializationEntries); + } + } diff --git a/src/d3d9/d3d9_device.h b/src/d3d9/d3d9_device.h index cec48291..8b979106 100644 --- a/src/d3d9/d3d9_device.h +++ b/src/d3d9/d3d9_device.h @@ -2,13 +2,16 @@ #include "../dxvk/dxvk_device.h" #include "../dxvk/dxvk_cs.h" +#include "../dxvk/dxvk_staging.h" #include "d3d9_include.h" #include "d3d9_cursor.h" #include "d3d9_format.h" #include "d3d9_multithread.h" #include "d3d9_adapter.h" +#include "d3d9_constant_buffer.h" #include "d3d9_constant_set.h" +#include "d3d9_mem.h" #include "d3d9_state.h" @@ -23,12 +26,21 @@ #include "d3d9_fixed_function.h" #include "d3d9_swvp_emu.h" -#include "d3d9_shader_permutations.h" +#include "d3d9_spec_constants.h" +#include "d3d9_interop.h" +#include "d3d9_on_12.h" + +#include +#include +#include "d3d9_bridge.h" #include #include #include +#include "../util/util_flush.h" +#include "../util/util_lru.h" + namespace dxvk { class D3D9InterfaceEx; @@ -74,10 +86,18 @@ namespace dxvk { DirtyPointScale, InScene, + + DirtySpecializationEntries, }; using D3D9DeviceFlags = Flags; + enum class D3D9DeviceLostState { + Ok = 0, + Lost = 1, + NotReset = 2, + }; + struct D3D9DrawInfo { uint32_t vertexCount; uint32_t instanceCount; @@ -88,6 +108,13 @@ namespace dxvk { void* mapPtr = nullptr; }; + struct D3D9StagingBufferMarkerPayload { + uint64_t sequenceNumber; + VkDeviceSize allocated; + }; + + using D3D9StagingBufferMarker = DxvkMarker; + class D3D9DeviceEx final : public ComObjectClamp { constexpr static uint32_t DefaultFrameLatency = 3; constexpr static uint32_t MaxFrameLatency = 20; @@ -98,8 +125,14 @@ namespace dxvk { constexpr static uint32_t NullStreamIdx = caps::MaxStreams; + constexpr static VkDeviceSize StagingBufferSize = 4ull << 20; + friend class D3D9SwapChainEx; + friend struct D3D9WindowContext; + friend class D3D9ConstantBuffer; friend class D3D9UserDefinedAnnotation; + friend class DxvkD3D8Bridge; + friend D3D9VkInteropDevice; public: D3D9DeviceEx( @@ -652,7 +685,7 @@ namespace dxvk { HWND GetWindow(); - Rc GetDXVKDevice() { + const Rc& GetDXVKDevice() { return m_dxvkDevice; } @@ -735,22 +768,21 @@ namespace dxvk { int64_t DetermineInitialTextureMemory(); - Rc CreateConstantBuffer( - bool SSBO, - VkDeviceSize Size, - DxsoProgramType ShaderStage, - DxsoConstantBuffers BufferType); - void CreateConstantBuffers(); void SynchronizeCsThread(uint64_t SequenceNumber); void Flush(); + void EndFrame(); + void UpdateBoundRTs(uint32_t index); void UpdateActiveRTs(uint32_t index); + template + void UpdateAnyColorWrites(bool has); + void UpdateActiveTextures(uint32_t index, DWORD combinedUsage); void UpdateActiveHazardsRT(uint32_t rtMask); @@ -759,6 +791,8 @@ namespace dxvk { void MarkRenderHazards(); + void UpdateActiveFetch4(uint32_t stateSampler); + void UploadManagedTexture(D3D9CommonTexture* pResource); void UploadManagedTextures(uint32_t mask); @@ -771,8 +805,7 @@ namespace dxvk { void MarkTextureUploaded(D3D9CommonTexture* pResource); - template - void UpdatePointMode(); + void UpdatePointMode(bool pointList); void UpdateFog(); @@ -821,11 +854,9 @@ namespace dxvk { void BindDepthBias(); - void BindAlphaTestState(); - inline void UploadSoftwareConstantSet(const D3D9ShaderConstantsVSSoftware& Src, const D3D9ConstantLayout& Layout); - inline DxvkBufferSliceHandle CopySoftwareConstants(DxsoConstantBuffers cBufferTarget, Rc& dstBuffer, const void* src, uint32_t copySize, bool useSSBO); + inline void* CopySoftwareConstants(D3D9ConstantBuffer& dstBuffer, const void* src, uint32_t size); template inline void UploadConstantSet(const SoftwareLayoutType& Src, const D3D9ConstantLayout& Layout, const ShaderType& Shader); @@ -853,6 +884,10 @@ namespace dxvk { void MarkTextureBindingDirty(IDirect3DBaseTexture9* texture); + HRESULT STDMETHODCALLTYPE SetRenderTargetInternal( + DWORD RenderTargetIndex, + IDirect3DSurface9* pRenderTarget); + D3D9DrawInfo GenerateDrawInfo( D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, @@ -864,8 +899,7 @@ namespace dxvk { template void BindShader( - const D3D9CommonShader* pShaderModule, - D3D9ShaderPermutation Permutation); + const D3D9CommonShader* pShaderModule); void BindInputLayout(); @@ -895,7 +929,7 @@ namespace dxvk { void SetVertexBoolBitfield(uint32_t idx, uint32_t mask, uint32_t bits); void SetPixelBoolBitfield (uint32_t idx, uint32_t mask, uint32_t bits); - void FlushImplicit(BOOL StrongHint); + void ConsiderFlush(GpuFlushType FlushType); bool ChangeReportedMemory(int64_t delta) { if (IsExtended()) @@ -919,7 +953,7 @@ namespace dxvk { const D3D9ConstantLayout& GetVertexConstantLayout() { return m_vsLayout; } const D3D9ConstantLayout& GetPixelConstantLayout() { return m_psLayout; } - HRESULT ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters); + void ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters); HRESULT ResetSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode); HRESULT InitialReset(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode); @@ -928,6 +962,34 @@ namespace dxvk { return m_samplerCount.load(); } + D3D9MemoryAllocator* GetAllocator() { + return &m_memoryAllocator; + } + + void* MapTexture(D3D9CommonTexture* pTexture, UINT Subresource); + void TouchMappedTexture(D3D9CommonTexture* pTexture); + void RemoveMappedTexture(D3D9CommonTexture* pTexture); + + // Device Lost + bool IsDeviceLost() const { + return m_deviceLostState != D3D9DeviceLostState::Ok; + } + + void NotifyFullscreen(HWND window, bool fullscreen); + void NotifyWindowActivated(HWND window, bool activated); + + void IncrementLosableCounter() { + m_losableResourceCounter++; + } + + void DecrementLosableCounter() { + m_losableResourceCounter--; + } + + bool CanOnlySWVP() const { + return m_behaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING; + } + private: DxvkCsChunkRef AllocCsChunk() { @@ -935,12 +997,15 @@ namespace dxvk { return DxvkCsChunkRef(chunk, &m_csChunkPool); } - template + template void EmitCs(Cmd&& command) { if (unlikely(!m_csChunk->push(command))) { EmitCsChunk(std::move(m_csChunk)); - m_csChunk = AllocCsChunk(); + + if constexpr (AllowFlush) + ConsiderFlush(GpuFlushType::ImplicitWeakHint); + m_csChunk->push(command); } } @@ -954,30 +1019,24 @@ namespace dxvk { } } - bool CanSWVP() { + bool CanSWVP() const { return m_behaviorFlags & (D3DCREATE_MIXED_VERTEXPROCESSING | D3DCREATE_SOFTWARE_VERTEXPROCESSING); } - - inline constexpr D3D9ShaderPermutation GetVertexShaderPermutation() { - return D3D9ShaderPermutations::None; - } - - inline D3D9ShaderPermutation GetPixelShaderPermutation() { - if (unlikely(m_state.renderStates[D3DRS_SHADEMODE] == D3DSHADE_FLAT)) - return D3D9ShaderPermutations::FlatShade; - - return D3D9ShaderPermutations::None; - } - void DetermineConstantLayouts(bool canSWVP); - template - D3D9BufferSlice AllocTempBuffer(VkDeviceSize size); + D3D9BufferSlice AllocUPBuffer(VkDeviceSize size); + + D3D9BufferSlice AllocStagingBuffer(VkDeviceSize size); + + void EmitStagingBufferMarker(); + + void WaitStagingBuffer(); bool ShouldRecord(); HRESULT CreateShaderModule( D3D9CommonShader* pShaderModule, + uint32_t* pLength, VkShaderStageFlagBits ShaderStage, const DWORD* pShaderBytecode, const DxsoModuleInfo* pModuleInfo); @@ -1076,13 +1135,13 @@ namespace dxvk { return D3DERR_INVALIDCALL; if constexpr (ConstantType == D3D9ConstantType::Float) { - const float* source = set.fConsts[StartRegister].data; + const float* source = set->fConsts[StartRegister].data; const size_t size = Count * sizeof(Vector4); std::memcpy(pConstantData, source, size); } else if constexpr (ConstantType == D3D9ConstantType::Int) { - const int* source = set.iConsts[StartRegister].data; + const int* source = set->iConsts[StartRegister].data; const size_t size = Count * sizeof(Vector4i); std::memcpy(pConstantData, source, size); @@ -1095,7 +1154,7 @@ namespace dxvk { const uint32_t bit = (1u << bitIdx); - bool constValue = set.bConsts[arrayIdx] & bit; + bool constValue = set->bConsts[arrayIdx] & bit; pConstantData[i] = constValue ? TRUE : FALSE; } } @@ -1120,17 +1179,19 @@ namespace dxvk { bool UseProgrammablePS(); - void UpdateBoolSpecConstantVertex(uint32_t value); + uint32_t GetAlphaTestPrecision(); - void UpdateBoolSpecConstantPixel(uint32_t value); + void BindAlphaTestState(); - void UpdateSamplerSpecConsant(uint32_t value); + void UpdateAlphaTestSpec(VkCompareOp alphaOp, uint32_t precision); + void UpdateVertexBoolSpec(uint32_t value); + void UpdatePixelBoolSpec(uint32_t value); + void UpdatePixelShaderSamplerSpec(uint32_t types, uint32_t projections, uint32_t fetch4); + void UpdateCommonSamplerSpec(uint32_t boundMask, uint32_t depthMask, uint32_t drefMask); + void UpdatePointModeSpec(uint32_t mode); + void UpdateFogModeSpec(bool fogEnabled, D3DFOGMODE vertexFogMode, D3DFOGMODE pixelFogMode); - void UpdateProjectionSpecConstant(uint32_t value); - - void UpdateFetch4SpecConstant(uint32_t value); - - void UpdateSamplerDepthModeSpecConstant(uint32_t value); + void BindSpecConstants(); void TrackBufferMappingBufferSequenceNumber( D3D9CommonBuffer* pResource); @@ -1139,17 +1200,25 @@ namespace dxvk { D3D9CommonTexture* pResource, UINT Subresource); + void UnmapTextures(); + uint64_t GetCurrentSequenceNumber(); Com m_parent; D3DDEVTYPE m_deviceType; HWND m_window; WORD m_behaviorFlags; - D3DPRESENT_PARAMETERS m_presentParams; D3D9Adapter* m_adapter; Rc m_dxvkDevice; + D3D9MemoryAllocator m_memoryAllocator; + + // Second memory allocator used for D3D9 shader bytecode. + // Most games never access the stored bytecode, so putting that + // into the same chunks as texture memory would waste address space. + D3D9MemoryAllocator m_shaderAllocator; + uint32_t m_frameLatency = DefaultFrameLatency; D3D9Initializer* m_initializer = nullptr; @@ -1162,15 +1231,23 @@ namespace dxvk { Rc m_shaderModules; - Rc m_vsClipPlanes; + D3D9ConstantBuffer m_vsClipPlanes; - Rc m_vsFixedFunction; - Rc m_vsVertexBlend; - Rc m_psFixedFunction; - Rc m_psShared; + D3D9ConstantBuffer m_vsFixedFunction; + D3D9ConstantBuffer m_vsVertexBlend; + D3D9ConstantBuffer m_psFixedFunction; + D3D9ConstantBuffer m_psShared; + D3D9ConstantBuffer m_specBuffer; - D3D9BufferSlice m_upBuffer; - D3D9BufferSlice m_managedUploadBuffer; + Rc m_upBuffer; + VkDeviceSize m_upBufferOffset = 0ull; + void* m_upBufferMapPtr = nullptr; + + DxvkStagingBuffer m_stagingBuffer; + VkDeviceSize m_stagingBufferAllocated = 0ull; + VkDeviceSize m_stagingBufferLastAllocated = 0ull; + VkDeviceSize m_stagingBufferLastSignaled = 0ull; + std::queue> m_stagingBufferMarkers; D3D9Cursor m_cursor; @@ -1201,37 +1278,42 @@ namespace dxvk { uint32_t m_instancedData = 0; uint32_t m_depthTextures = 0; + uint32_t m_drefClamp = 0; + uint32_t m_cubeTextures = 0; uint32_t m_textureTypes = 0; uint32_t m_projectionBitfield = 0; uint32_t m_dirtySamplerStates = 0; uint32_t m_dirtyTextures = 0; - uint32_t m_boundRTs = 0; + uint32_t m_boundRTs : 4; + uint32_t m_anyColorWrites : 4; + uint32_t m_activeRTsWhichAreTextures : 4; + uint32_t m_alphaSwizzleRTs : 4; + uint32_t m_lastHazardsRT : 4; - uint32_t m_activeRTs = 0; - uint32_t m_activeRTTextures = 0; - uint32_t m_activeDSTextures = 0; + uint32_t m_activeTextureRTs = 0; + uint32_t m_activeTextureDSs = 0; uint32_t m_activeHazardsRT = 0; uint32_t m_activeHazardsDS = 0; - uint32_t m_alphaSwizzleRTs = 0; uint32_t m_activeTextures = 0; uint32_t m_activeTexturesToUpload = 0; uint32_t m_activeTexturesToGen = 0; + // m_fetch4Enabled is whether fetch4 is currently enabled + // from the application. + // + // m_fetch4 is whether it should be enabled in the shader + // ie. are we in a correct state to use it + // (enabled + texture supports it + point sampled) uint32_t m_fetch4Enabled = 0; uint32_t m_fetch4 = 0; - uint32_t m_lastBoolSpecConstantVertex = 0; - uint32_t m_lastBoolSpecConstantPixel = 0; - uint32_t m_lastSamplerDepthMode = 0; - uint32_t m_lastProjectionBitfield = 0; - uint32_t m_lastSamplerTypes = 0; - uint32_t m_lastPointMode = 0; - uint32_t m_lastFetch4 = 0; uint32_t m_lastHazardsDS = 0; uint32_t m_lastSamplerTypesFF = 0; + D3D9SpecializationInfo m_specInfo = D3D9SpecializationInfo(); + D3D9ShaderMasks m_vsShaderMasks = D3D9ShaderMasks(); D3D9ShaderMasks m_psShaderMasks = FixedFunctionMask; @@ -1239,7 +1321,12 @@ namespace dxvk { bool m_amdATOC = false; bool m_nvATOC = false; bool m_ffZTest = false; + + VkImageLayout m_hazardLayout = VK_IMAGE_LAYOUT_GENERAL; + bool m_usingGraphicsPipelines = false; + + DxvkDepthBiasRepresentation m_depthBiasRepresentation = { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, false }; float m_depthBiasScale = 0.0f; uint32_t m_robustSSBOAlignment = 1; @@ -1261,18 +1348,33 @@ namespace dxvk { D3D9ViewportInfo m_viewportInfo; DxvkCsChunkPool m_csChunkPool; - dxvk::high_resolution_clock::time_point m_lastFlush - = dxvk::high_resolution_clock::now(); DxvkCsThread m_csThread; DxvkCsChunkRef m_csChunk; uint64_t m_csSeqNum = 0ull; - bool m_csIsBusy = false; + + Rc m_submissionFence; + uint64_t m_submissionId = 0ull; + uint64_t m_flushSeqNum = 0ull; + GpuFlushTracker m_flushTracker; std::atomic m_availableMemory = { 0 }; std::atomic m_samplerCount = { 0 }; + D3D9DeviceLostState m_deviceLostState = D3D9DeviceLostState::Ok; + HWND m_fullscreenWindow = NULL; + std::atomic m_losableResourceCounter = { 0 }; + +#ifdef D3D9_ALLOW_UNMAPPING + lru_list m_mappedTextures; +#endif + + // m_state should be declared last (i.e. freed first), because it + // references objects that can call back into the device when freed. Direct3DState9 m_state; + D3D9VkInteropDevice m_d3d9Interop; + D3D9On12 m_d3d9On12; + DxvkD3D8Bridge m_d3d8Bridge; }; } diff --git a/src/d3d9/d3d9_fixed_function.cpp b/src/d3d9/d3d9_fixed_function.cpp index 37f6e1ab..5581bfa1 100644 --- a/src/d3d9/d3d9_fixed_function.cpp +++ b/src/d3d9/d3d9_fixed_function.cpp @@ -5,7 +5,6 @@ #include "d3d9_spec_constants.h" #include "../dxvk/dxvk_hash.h" -#include "../dxvk/dxvk_spec_const.h" #include "../spirv/spirv_module.h" @@ -15,11 +14,11 @@ namespace dxvk { D3D9FixedFunctionOptions::D3D9FixedFunctionOptions(const D3D9Options* options) { invariantPosition = options->invariantPosition; + forceSampleRateShading = options->forceSampleRateShading; } - uint32_t DoFixedFunctionFog(SpirvModule& spvModule, const D3D9FogContext& fogCtx) { + uint32_t DoFixedFunctionFog(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, const D3D9FogContext& fogCtx) { uint32_t floatType = spvModule.defFloatType(32); - uint32_t uint32Type = spvModule.defIntType(32, 0); uint32_t vec3Type = spvModule.defVectorType(floatType, 3); uint32_t vec4Type = spvModule.defVectorType(floatType, 4); uint32_t floatPtr = spvModule.defPointerType(floatType, spv::StorageClassPushConstant); @@ -41,20 +40,12 @@ namespace dxvk { uint32_t fogDensity = spvModule.opLoad(floatType, spvModule.opAccessChain(floatPtr, fogCtx.RenderState, 1, &fogDensityMember)); - uint32_t fogMode = spvModule.specConst32(uint32Type, 0); + uint32_t fogMode = spec.get( + spvModule, fogCtx.SpecUBO, + fogCtx.IsPixel ? SpecPixelFogMode : SpecVertexFogMode); - if (!fogCtx.IsPixel) { - spvModule.setDebugName(fogMode, "vertex_fog_mode"); - spvModule.decorateSpecId(fogMode, getSpecId(D3D9SpecConstantId::VertexFogMode)); - } - else { - spvModule.setDebugName(fogMode, "pixel_fog_mode"); - spvModule.decorateSpecId(fogMode, getSpecId(D3D9SpecConstantId::PixelFogMode)); - } - - uint32_t fogEnabled = spvModule.specConstBool(false); - spvModule.setDebugName(fogEnabled, "fog_enabled"); - spvModule.decorateSpecId(fogEnabled, getSpecId(D3D9SpecConstantId::FogEnabled)); + uint32_t fogEnabled = spec.get(spvModule, fogCtx.SpecUBO, SpecFogEnabled); + fogEnabled = spvModule.opINotEqual(spvModule.defBoolType(), fogEnabled, spvModule.constu32(0)); uint32_t doFog = spvModule.allocateId(); uint32_t skipFog = spvModule.allocateId(); @@ -199,8 +190,155 @@ namespace dxvk { } + void DoFixedFunctionAlphaTest(SpirvModule& spvModule, const D3D9AlphaTestContext& ctx) { + // Labels for the alpha test + std::array atestCaseLabels = {{ + { uint32_t(VK_COMPARE_OP_NEVER), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_LESS), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_EQUAL), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_LESS_OR_EQUAL), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_GREATER), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_NOT_EQUAL), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_GREATER_OR_EQUAL), spvModule.allocateId() }, + { uint32_t(VK_COMPARE_OP_ALWAYS), spvModule.allocateId() }, + }}; + + uint32_t atestBeginLabel = spvModule.allocateId(); + uint32_t atestTestLabel = spvModule.allocateId(); + uint32_t atestDiscardLabel = spvModule.allocateId(); + uint32_t atestKeepLabel = spvModule.allocateId(); + uint32_t atestSkipLabel = spvModule.allocateId(); + + // if (alpha_func != ALWAYS) { ... } + uint32_t boolType = spvModule.defBoolType(); + uint32_t isNotAlways = spvModule.opINotEqual(boolType, ctx.alphaFuncId, spvModule.constu32(VK_COMPARE_OP_ALWAYS)); + spvModule.opSelectionMerge(atestSkipLabel, spv::SelectionControlMaskNone); + spvModule.opBranchConditional(isNotAlways, atestBeginLabel, atestSkipLabel); + spvModule.opLabel(atestBeginLabel); + + // The lower 8 bits of the alpha ref contain the actual reference value + // from the API, the upper bits store the accuracy bit count minus 8. + // So if we want 12 bits of accuracy (i.e. 0-4095), that value will be 4. + uint32_t uintType = spvModule.defIntType(32, 0); + + // Check if the given bit precision is supported + uint32_t precisionIntLabel = spvModule.allocateId(); + uint32_t precisionFloatLabel = spvModule.allocateId(); + uint32_t precisionEndLabel = spvModule.allocateId(); + + uint32_t useIntPrecision = spvModule.opULessThanEqual(boolType, + ctx.alphaPrecisionId, spvModule.constu32(8)); + + spvModule.opSelectionMerge(precisionEndLabel, spv::SelectionControlMaskNone); + spvModule.opBranchConditional(useIntPrecision, precisionIntLabel, precisionFloatLabel); + spvModule.opLabel(precisionIntLabel); + + // Adjust alpha ref to the given range + uint32_t alphaRefIdInt = spvModule.opBitwiseOr(uintType, + spvModule.opShiftLeftLogical(uintType, ctx.alphaRefId, ctx.alphaPrecisionId), + spvModule.opShiftRightLogical(uintType, ctx.alphaRefId, + spvModule.opISub(uintType, spvModule.constu32(8), ctx.alphaPrecisionId))); + + // Convert alpha ref to float since we'll do the comparison based on that + uint32_t floatType = spvModule.defFloatType(32); + alphaRefIdInt = spvModule.opConvertUtoF(floatType, alphaRefIdInt); + + // Adjust alpha to the given range and round + uint32_t alphaFactorId = spvModule.opISub(uintType, + spvModule.opShiftLeftLogical(uintType, spvModule.constu32(256), ctx.alphaPrecisionId), + spvModule.constu32(1)); + alphaFactorId = spvModule.opConvertUtoF(floatType, alphaFactorId); + + uint32_t alphaIdInt = spvModule.opRoundEven(floatType, + spvModule.opFMul(floatType, ctx.alphaId, alphaFactorId)); + + spvModule.opBranch(precisionEndLabel); + spvModule.opLabel(precisionFloatLabel); + + // If we're not using integer precision, normalize the alpha ref + uint32_t alphaRefIdFloat = spvModule.opFDiv(floatType, + spvModule.opConvertUtoF(floatType, ctx.alphaRefId), + spvModule.constf32(255.0f)); + + spvModule.opBranch(precisionEndLabel); + spvModule.opLabel(precisionEndLabel); + + std::array alphaRefLabels = { + SpirvPhiLabel { alphaRefIdInt, precisionIntLabel }, + SpirvPhiLabel { alphaRefIdFloat, precisionFloatLabel }, + }; + + uint32_t alphaRefId = spvModule.opPhi(floatType, + alphaRefLabels.size(), + alphaRefLabels.data()); + + std::array alphaIdLabels = { + SpirvPhiLabel { alphaIdInt, precisionIntLabel }, + SpirvPhiLabel { ctx.alphaId, precisionFloatLabel }, + }; + + uint32_t alphaId = spvModule.opPhi(floatType, + alphaIdLabels.size(), + alphaIdLabels.data()); + + // switch (alpha_func) { ... } + spvModule.opSelectionMerge(atestTestLabel, spv::SelectionControlMaskNone); + spvModule.opSwitch(ctx.alphaFuncId, + atestCaseLabels[uint32_t(VK_COMPARE_OP_ALWAYS)].labelId, + atestCaseLabels.size(), + atestCaseLabels.data()); + + std::array atestVariables; + + for (uint32_t i = 0; i < atestCaseLabels.size(); i++) { + spvModule.opLabel(atestCaseLabels[i].labelId); + + atestVariables[i].labelId = atestCaseLabels[i].labelId; + atestVariables[i].varId = [&] { + switch (VkCompareOp(atestCaseLabels[i].literal)) { + case VK_COMPARE_OP_NEVER: return spvModule.constBool(false); + case VK_COMPARE_OP_LESS: return spvModule.opFOrdLessThan (boolType, alphaId, alphaRefId); + case VK_COMPARE_OP_EQUAL: return spvModule.opFOrdEqual (boolType, alphaId, alphaRefId); + case VK_COMPARE_OP_LESS_OR_EQUAL: return spvModule.opFOrdLessThanEqual (boolType, alphaId, alphaRefId); + case VK_COMPARE_OP_GREATER: return spvModule.opFOrdGreaterThan (boolType, alphaId, alphaRefId); + case VK_COMPARE_OP_NOT_EQUAL: return spvModule.opFOrdNotEqual (boolType, alphaId, alphaRefId); + case VK_COMPARE_OP_GREATER_OR_EQUAL: return spvModule.opFOrdGreaterThanEqual(boolType, alphaId, alphaRefId); + default: + case VK_COMPARE_OP_ALWAYS: return spvModule.constBool(true); + } + }(); + + spvModule.opBranch(atestTestLabel); + } + + // end switch + spvModule.opLabel(atestTestLabel); + + uint32_t atestResult = spvModule.opPhi(boolType, + atestVariables.size(), + atestVariables.data()); + uint32_t atestDiscard = spvModule.opLogicalNot(boolType, atestResult); + + // if (do_discard) { ... } + spvModule.opSelectionMerge(atestKeepLabel, spv::SelectionControlMaskNone); + spvModule.opBranchConditional(atestDiscard, atestDiscardLabel, atestKeepLabel); + + spvModule.opLabel(atestDiscardLabel); + spvModule.opDemoteToHelperInvocation(); + spvModule.opBranch(atestKeepLabel); + + // end if (do_discard) + spvModule.opLabel(atestKeepLabel); + spvModule.opBranch(atestSkipLabel); + + // end if (alpha_test) + spvModule.opLabel(atestSkipLabel); + } + + uint32_t SetupRenderStateBlock(SpirvModule& spvModule, uint32_t count) { uint32_t floatType = spvModule.defFloatType(32); + uint32_t uintType = spvModule.defIntType(32, 0); uint32_t vec3Type = spvModule.defVectorType(floatType, 3); std::array rsMembers = {{ @@ -208,7 +346,8 @@ namespace dxvk { floatType, floatType, floatType, - floatType, + + uintType, floatType, floatType, @@ -254,7 +393,44 @@ namespace dxvk { } - D3D9PointSizeInfoVS GetPointSizeInfoVS(SpirvModule& spvModule, uint32_t vPos, uint32_t vtx, uint32_t perVertPointSize, uint32_t rsBlock, bool isFixedFunction) { + uint32_t SetupSpecUBO(SpirvModule& spvModule, std::vector& bindings) { + uint32_t uintType = spvModule.defIntType(32, 0); + + std::array specMembers; + for (auto& x : specMembers) + x = uintType; + + uint32_t specStruct = spvModule.defStructTypeUnique(uint32_t(specMembers.size()), specMembers.data()); + + spvModule.setDebugName (specStruct, "spec_state_t"); + spvModule.decorate (specStruct, spv::DecorationBlock); + + for (uint32_t i = 0; i < SpecConstantCount; i++) { + std::string name = str::format("dword", i); + spvModule.setDebugMemberName (specStruct, i, name.c_str()); + spvModule.memberDecorateOffset (specStruct, i, sizeof(uint32_t) * i); + } + + uint32_t specBlock = spvModule.newVar( + spvModule.defPointerType(specStruct, spv::StorageClassUniform), + spv::StorageClassUniform); + + spvModule.setDebugName (specBlock, "spec_state"); + spvModule.decorateDescriptorSet(specBlock, 0); + spvModule.decorateBinding (specBlock, getSpecConstantBufferSlot()); + + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }; + binding.resourceBinding = getSpecConstantBufferSlot(); + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_UNIFORM_READ_BIT; + binding.uboSet = VK_TRUE; + bindings.push_back(binding); + + return specBlock; + } + + + D3D9PointSizeInfoVS GetPointSizeInfoVS(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, uint32_t vPos, uint32_t vtx, uint32_t perVertPointSize, uint32_t rsBlock, uint32_t specUbo, bool isFixedFunction) { uint32_t floatType = spvModule.defFloatType(32); uint32_t floatPtr = spvModule.defPointerType(floatType, spv::StorageClassPushConstant); uint32_t vec3Type = spvModule.defVectorType(floatType, 3); @@ -270,9 +446,7 @@ namespace dxvk { uint32_t value = perVertPointSize != 0 ? perVertPointSize : LoadFloat(D3D9RenderStateItem::PointSize); if (isFixedFunction) { - uint32_t pointMode = spvModule.specConst32(uint32Type, 0); - spvModule.setDebugName(pointMode, "point_mode"); - spvModule.decorateSpecId(pointMode, getSpecId(D3D9SpecConstantId::PointMode)); + uint32_t pointMode = spec.get(spvModule, specUbo, SpecPointMode); uint32_t scaleBit = spvModule.opBitFieldUExtract(uint32Type, pointMode, spvModule.consti32(0), spvModule.consti32(1)); uint32_t isScale = spvModule.opIEqual(boolType, scaleBit, spvModule.constu32(1)); @@ -318,14 +492,12 @@ namespace dxvk { } - D3D9PointSizeInfoPS GetPointSizeInfoPS(SpirvModule& spvModule, uint32_t rsBlock) { + D3D9PointSizeInfoPS GetPointSizeInfoPS(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, uint32_t rsBlock, uint32_t specUbo) { uint32_t uint32Type = spvModule.defIntType(32, 0); uint32_t boolType = spvModule.defBoolType(); uint32_t boolVec4 = spvModule.defVectorType(boolType, 4); - uint32_t pointMode = spvModule.specConst32(uint32Type, 0); - spvModule.setDebugName(pointMode, "point_mode"); - spvModule.decorateSpecId(pointMode, getSpecId(D3D9SpecConstantId::PointMode)); + uint32_t pointMode = spec.get(spvModule, specUbo, SpecPointMode); uint32_t spriteBit = spvModule.opBitFieldUExtract(uint32Type, pointMode, spvModule.consti32(1), spvModule.consti32(1)); uint32_t isSprite = spvModule.opIEqual(boolType, spriteBit, spvModule.constu32(1)); @@ -343,7 +515,7 @@ namespace dxvk { } - uint32_t GetPointCoord(SpirvModule& spvModule, std::vector& entryPointInterfaces) { + uint32_t GetPointCoord(SpirvModule& spvModule) { uint32_t floatType = spvModule.defFloatType(32); uint32_t vec2Type = spvModule.defVectorType(floatType, 2); uint32_t vec4Type = spvModule.defVectorType(floatType, 4); @@ -352,7 +524,6 @@ namespace dxvk { uint32_t pointCoordPtr = spvModule.newVar(vec2Ptr, spv::StorageClassInput); spvModule.decorateBuiltIn(pointCoordPtr, spv::BuiltInPointCoord); - entryPointInterfaces.push_back(pointCoordPtr); uint32_t pointCoord = spvModule.opLoad(vec2Type, pointCoordPtr); @@ -540,7 +711,6 @@ namespace dxvk { uint32_t texcoordCnt; uint32_t typeId; uint32_t varId; - uint32_t bound; } samplers[8]; struct { @@ -596,6 +766,9 @@ namespace dxvk { void alphaTestPS(); + uint32_t emitMatrixTimesVector(uint32_t rowCount, uint32_t colCount, uint32_t matrix, uint32_t vector); + uint32_t emitVectorTimesMatrix(uint32_t rowCount, uint32_t colCount, uint32_t vector, uint32_t matrix); + bool isVS() { return m_programType == DxsoProgramType::VertexShader; } bool isPS() { return !isVS(); } @@ -603,11 +776,11 @@ namespace dxvk { SpirvModule m_module; std::vector - m_resourceSlots; - std::vector m_entryPointInterfaces; + m_bindings; uint32_t m_inputMask = 0u; uint32_t m_outputMask = 0u; + uint32_t m_flatShadingMask = 0u; uint32_t m_pushConstOffset = 0u; uint32_t m_pushConstSize = 0u; @@ -632,9 +805,12 @@ namespace dxvk { uint32_t m_entryPointId; uint32_t m_rsBlock; + uint32_t m_specUbo; uint32_t m_mainFuncLabel; D3D9FixedFunctionOptions m_options; + + D3D9ShaderSpecConstantManager m_spec; }; D3D9FFShaderCompiler::D3D9FFShaderCompiler( @@ -706,19 +882,18 @@ namespace dxvk { // Declare the entry point, we now have all the // information we need, including the interfaces m_module.addEntryPoint(m_entryPointId, - isVS() ? spv::ExecutionModelVertex : spv::ExecutionModelFragment, "main", - m_entryPointInterfaces.size(), - m_entryPointInterfaces.data()); + isVS() ? spv::ExecutionModelVertex : spv::ExecutionModelFragment, "main"); // Create the shader module object DxvkShaderCreateInfo info; info.stage = isVS() ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_FRAGMENT_BIT; - info.resourceSlotCount = m_resourceSlots.size(); - info.resourceSlots = m_resourceSlots.data(); + info.bindingCount = m_bindings.size(); + info.bindings = m_bindings.data(); info.inputMask = m_inputMask; info.outputMask = m_outputMask; + info.flatShadingInputs = m_flatShadingMask; info.pushConstOffset = m_pushConstOffset; - info.pushConstSize = m_pushConstOffset; + info.pushConstSize = m_pushConstSize; return new DxvkShader(info, m_module.compile()); } @@ -760,22 +935,26 @@ namespace dxvk { uint32_t ptr = m_module.newVar(ptrType, storageClass); - if (builtin == spv::BuiltInMax) + if (builtin == spv::BuiltInMax) { m_module.decorateLocation(ptr, slot); - else + + if (isPS() && input && m_options.forceSampleRateShading) { + m_module.enableCapability(spv::CapabilitySampleRateShading); + m_module.decorate(ptr, spv::DecorationSample); + } + } else { m_module.decorateBuiltIn(ptr, builtin); + } bool diffuseOrSpec = semantic == DxsoSemantic{ DxsoUsage::Color, 0 } || semantic == DxsoSemantic{ DxsoUsage::Color, 1 }; - if (diffuseOrSpec && m_fsKey.Stages[0].Contents.GlobalFlatShade) - m_module.decorate(ptr, spv::DecorationFlat); + if (diffuseOrSpec && input) + m_flatShadingMask |= 1u << slot; std::string name = str::format(input ? "in_" : "out_", semantic.usage, semantic.usageIndex); m_module.setDebugName(ptr, name.c_str()); - m_entryPointInterfaces.push_back(ptr); - if (input) return m_module.opLoad(type, ptr); @@ -805,8 +984,8 @@ namespace dxvk { if (!m_vsKey.Data.Contents.HasPositionT) { if (m_vsKey.Data.Contents.VertexBlendMode == D3D9FF_VertexBlendMode_Normal) { uint32_t blendWeightRemaining = m_module.constf32(1); - uint32_t vtxSum = m_module.constvec4f32(0, 0, 0, 0); - uint32_t nrmSum = m_module.constvec3f32(0, 0, 0); + uint32_t vtxSum = 0; + uint32_t nrmSum = 0; for (uint32_t i = 0; i <= m_vsKey.Data.Contents.VertexBlendCount; i++) { std::array arrayIndices; @@ -833,7 +1012,7 @@ namespace dxvk { } nrmMtx = m_module.opCompositeConstruct(m_mat3Type, mtxIndices.size(), mtxIndices.data()); - uint32_t vtxResult = m_module.opVectorTimesMatrix(m_vec4Type, vtx, worldview); + uint32_t vtxResult = emitVectorTimesMatrix(4, 4, vtx, worldview); uint32_t nrmResult = m_module.opVectorTimesMatrix(m_vec3Type, normal, nrmMtx); uint32_t weight; @@ -844,18 +1023,26 @@ namespace dxvk { else weight = blendWeightRemaining; - vtxResult = m_module.opVectorTimesScalar(m_vec4Type, vtxResult, weight); - nrmResult = m_module.opVectorTimesScalar(m_vec3Type, nrmResult, weight); + std::array weightIds = { weight, weight, weight, weight }; + uint32_t weightVec4 = m_module.opCompositeConstruct(m_vec4Type, 4, weightIds.data()); + uint32_t weightVec3 = m_module.opCompositeConstruct(m_vec3Type, 3, weightIds.data()); - vtxSum = m_module.opFAdd(m_vec4Type, vtxSum, vtxResult); - nrmSum = m_module.opFAdd(m_vec3Type, nrmSum, nrmResult); + vtxSum = vtxSum + ? m_module.opFFma(m_vec4Type, vtxResult, weightVec4, vtxSum) + : m_module.opFMul(m_vec4Type, vtxResult, weightVec4); + + nrmSum = nrmSum + ? m_module.opFFma(m_vec3Type, nrmResult, weightVec3, nrmSum) + : m_module.opFMul(m_vec3Type, nrmResult, weightVec3); + + m_module.decorate(vtxSum, spv::DecorationNoContraction); } vtx = vtxSum; normal = nrmSum; } else { - vtx = m_module.opVectorTimesMatrix(m_vec4Type, vtx, m_vs.constants.worldview); + vtx = emitVectorTimesMatrix(4, 4, vtx, m_vs.constants.worldview); uint32_t nrmMtx = m_vs.constants.normal; @@ -883,7 +1070,7 @@ namespace dxvk { normal = m_module.opSelect(m_vec3Type, isZeroNormal3, m_module.constvec3f32(0.0f, 0.0f, 0.0f), normal); } - gl_Position = m_module.opVectorTimesMatrix(m_vec4Type, vtx, m_vs.constants.proj); + gl_Position = emitVectorTimesMatrix(4, 4, vtx, m_vs.constants.proj); } else { gl_Position = m_module.opFMul(m_vec4Type, gl_Position, m_vs.constants.invExtent); gl_Position = m_module.opFAdd(m_vec4Type, gl_Position, m_vs.constants.invOffset); @@ -915,19 +1102,30 @@ namespace dxvk { m_module.opStore(m_vs.out.NORMAL, outNrm); for (uint32_t i = 0; i < caps::TextureStageCount; i++) { - uint32_t inputIndex = (m_vsKey.Data.Contents.TexcoordIndices >> (i * 3)) & 0b111; - uint32_t inputFlags = (m_vsKey.Data.Contents.TexcoordFlags >> (i * 3)) & 0b111; + uint32_t inputIndex = (m_vsKey.Data.Contents.TexcoordIndices >> (i * 3)) & 0b111; + uint32_t inputFlags = (m_vsKey.Data.Contents.TexcoordFlags >> (i * 3)) & 0b111; + uint32_t texcoordCount = (m_vsKey.Data.Contents.TexcoordDeclMask >> (inputIndex * 3)) & 0b111; uint32_t transformed; const uint32_t wIndex = 3; uint32_t flags = (m_vsKey.Data.Contents.TransformFlags >> (i * 3)) & 0b111; - uint32_t count = flags; + uint32_t count; switch (inputFlags) { default: case (DXVK_TSS_TCI_PASSTHRU >> TCIOffset): transformed = m_vs.in.TEXCOORD[inputIndex & 0xFF]; + // flags is actually the number of elements that get passed + // to the rasterizer. + count = flags; + if (texcoordCount) { + // Clamp by the number of elements in the texcoord input. + if (!count || count > texcoordCount) + count = texcoordCount; + } + else + flags = D3DTTFF_DISABLE; break; case (DXVK_TSS_TCI_CAMERASPACENORMAL >> TCIOffset): @@ -1172,9 +1370,10 @@ namespace dxvk { fogCtx.IsPositionT = m_vsKey.Data.Contents.HasPositionT; fogCtx.HasSpecular = m_vsKey.Data.Contents.HasColor1; fogCtx.Specular = m_vs.in.COLOR[1]; - m_module.opStore(m_vs.out.FOG, DoFixedFunctionFog(m_module, fogCtx)); + fogCtx.SpecUBO = m_specUbo; + m_module.opStore(m_vs.out.FOG, DoFixedFunctionFog(m_spec, m_module, fogCtx)); - auto pointInfo = GetPointSizeInfoVS(m_module, 0, vtx, m_vs.in.POINTSIZE, m_rsBlock, true); + auto pointInfo = GetPointSizeInfoVS(m_spec, m_module, 0, vtx, m_vs.in.POINTSIZE, m_rsBlock, m_specUbo, true); uint32_t pointSize = m_module.opFClamp(m_floatType, pointInfo.defaultValue, pointInfo.min, pointInfo.max); m_module.opStore(m_vs.out.POINTSIZE, pointSize); @@ -1386,12 +1585,12 @@ namespace dxvk { m_module.decorateDescriptorSet(m_vs.constantBuffer, 0); m_module.decorateBinding(m_vs.constantBuffer, bindingId); - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - resource.view = VK_IMAGE_VIEW_TYPE_MAX_ENUM; - resource.access = VK_ACCESS_UNIFORM_READ_BIT; - m_resourceSlots.push_back(resource); + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }; + binding.resourceBinding = bindingId; + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_UNIFORM_READ_BIT; + binding.uboSet = VK_TRUE; + m_bindings.push_back(binding); } @@ -1426,17 +1625,18 @@ namespace dxvk { m_module.decorate(m_vs.vertexBlendData, spv::DecorationNonWritable); - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - resource.view = VK_IMAGE_VIEW_TYPE_MAX_ENUM; - resource.access = VK_ACCESS_SHADER_READ_BIT; - m_resourceSlots.push_back(resource); + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_STORAGE_BUFFER }; + binding.resourceBinding = bindingId; + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_SHADER_READ_BIT; + binding.uboSet = VK_TRUE; + m_bindings.push_back(binding); } void D3D9FFShaderCompiler::setupVS() { setupRenderStateInfo(); + m_specUbo = SetupSpecUBO(m_module, m_bindings); // VS Caps m_module.enableCapability(spv::CapabilityClipDistance); @@ -1554,9 +1754,11 @@ namespace dxvk { uint32_t current = diffuse; // Temp starts off as equal to vec4(0) uint32_t temp = m_module.constvec4f32(0.0f, 0.0f, 0.0f, 0.0f); - + uint32_t texture = m_module.constvec4f32(0.0f, 0.0f, 0.0f, 1.0f); + uint32_t unboundTextureConstId = m_module.constvec4f32(0.0f, 0.0f, 0.0f, 1.0f); + for (uint32_t i = 0; i < caps::TextureStageCount; i++) { const auto& stage = m_fsKey.Stages[i].Contents; @@ -1607,10 +1809,9 @@ namespace dxvk { texcoord, texcoord, texcoordCnt, indices.data()); uint32_t projIdx = m_fsKey.Stages[i].Contents.ProjectedCount; - if (projIdx == 0) + if (projIdx == 0 || projIdx > texcoordCnt) projIdx = texcoordCnt; - else - projIdx--; + --projIdx; uint32_t projValue = 0; @@ -1659,12 +1860,6 @@ namespace dxvk { texture = m_module.opVectorTimesScalar(m_vec4Type, texture, scale); } - - uint32_t bool_t = m_module.defBoolType(); - uint32_t bvec4_t = m_module.defVectorType(bool_t, 4); - std::array boundIndices = { m_ps.samplers[i].bound, m_ps.samplers[i].bound, m_ps.samplers[i].bound, m_ps.samplers[i].bound }; - uint32_t bound4 = m_module.opCompositeConstruct(bvec4_t, boundIndices.size(), boundIndices.data()); - texture = m_module.opSelect(m_vec4Type, bound4, texture, m_module.constvec4f32(0.0f, 0.0f, 0.0f, 1.0f)); } processedTexture = true; @@ -1721,7 +1916,11 @@ namespace dxvk { reg = temp; break; case D3DTA_TEXTURE: - reg = GetTexture(); + if (stage.TextureBound != 0) { + reg = GetTexture(); + } else { + reg = unboundTextureConstId; + } break; case D3DTA_TFACTOR: reg = m_ps.constants.textureFactor; @@ -1967,7 +2166,8 @@ namespace dxvk { fogCtx.IsPositionT = false; fogCtx.HasSpecular = false; fogCtx.Specular = 0; - current = DoFixedFunctionFog(m_module, fogCtx); + fogCtx.SpecUBO = m_specUbo; + current = DoFixedFunctionFog(m_spec, m_module, fogCtx); m_module.opStore(m_ps.out.COLOR, current); @@ -1976,15 +2176,18 @@ namespace dxvk { void D3D9FFShaderCompiler::setupPS() { setupRenderStateInfo(); + m_specUbo = SetupSpecUBO(m_module, m_bindings); // PS Caps + m_module.enableExtension("SPV_EXT_demote_to_helper_invocation"); + m_module.enableCapability(spv::CapabilityDemoteToHelperInvocationEXT); m_module.enableCapability(spv::CapabilityDerivativeControl); m_module.setExecutionMode(m_entryPointId, spv::ExecutionModeOriginUpperLeft); - uint32_t pointCoord = GetPointCoord(m_module, m_entryPointInterfaces); - auto pointInfo = GetPointSizeInfoPS(m_module, m_rsBlock); + uint32_t pointCoord = GetPointCoord(m_module); + auto pointInfo = GetPointSizeInfoPS(m_spec, m_module, m_rsBlock, m_specUbo); // We need to replace TEXCOORD inputs with gl_PointCoord // if D3DRS_POINTSPRITEENABLE is set. @@ -2033,12 +2236,12 @@ namespace dxvk { m_module.decorateDescriptorSet(m_ps.constantBuffer, 0); m_module.decorateBinding(m_ps.constantBuffer, bindingId); - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - resource.view = VK_IMAGE_VIEW_TYPE_MAX_ENUM; - resource.access = VK_ACCESS_UNIFORM_READ_BIT; - m_resourceSlots.push_back(resource); + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }; + binding.resourceBinding = bindingId; + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_UNIFORM_READ_BIT; + binding.uboSet = VK_TRUE; + m_bindings.push_back(binding); // Load constants auto LoadConstant = [&](uint32_t type, uint32_t idx) { @@ -2096,21 +2299,15 @@ namespace dxvk { const uint32_t bindingId = computeResourceSlotId(DxsoProgramType::PixelShader, DxsoBindingType::Image, i); - sampler.bound = m_module.specConstBool(true); - m_module.decorateSpecId(sampler.bound, bindingId); - m_module.setDebugName(sampler.bound, - str::format("s", i, "_bound").c_str()); - m_module.decorateDescriptorSet(sampler.varId, 0); m_module.decorateBinding(sampler.varId, bindingId); // Store descriptor info for the shader interface - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - resource.view = viewType; - resource.access = VK_ACCESS_SHADER_READ_BIT; - m_resourceSlots.push_back(resource); + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER }; + binding.resourceBinding = bindingId; + binding.viewType = viewType; + binding.access = VK_ACCESS_SHADER_READ_BIT; + m_bindings.push_back(binding); } emitPsSharedConstants(); @@ -2127,17 +2324,17 @@ namespace dxvk { m_module.decorateDescriptorSet(m_ps.sharedState, 0); m_module.decorateBinding(m_ps.sharedState, bindingId); - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - resource.view = VK_IMAGE_VIEW_TYPE_MAX_ENUM; - resource.access = VK_ACCESS_UNIFORM_READ_BIT; - m_resourceSlots.push_back(resource); + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }; + binding.resourceBinding = bindingId; + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_UNIFORM_READ_BIT; + binding.uboSet = VK_TRUE; + m_bindings.push_back(binding); } void D3D9FFShaderCompiler::emitVsClipping(uint32_t vtx) { - uint32_t worldPos = m_module.opMatrixTimesVector(m_vec4Type, m_vs.constants.inverseView, vtx); + uint32_t worldPos = emitMatrixTimesVector(4, 4, m_vs.constants.inverseView, vtx); uint32_t clipPlaneCountId = m_module.constu32(caps::MaxClipPlanes); @@ -2167,13 +2364,13 @@ namespace dxvk { m_module.decorateDescriptorSet(clipPlaneBlock, 0); m_module.decorateBinding (clipPlaneBlock, bindingId); - DxvkResourceSlot resource; - resource.slot = bindingId; - resource.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - resource.view = VK_IMAGE_VIEW_TYPE_MAX_ENUM; - resource.access = VK_ACCESS_UNIFORM_READ_BIT; - m_resourceSlots.push_back(resource); - + DxvkBindingInfo binding = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER }; + binding.resourceBinding = bindingId; + binding.viewType = VK_IMAGE_VIEW_TYPE_MAX_ENUM; + binding.access = VK_ACCESS_UNIFORM_READ_BIT; + binding.uboSet = VK_TRUE; + m_bindings.push_back(binding); + // Declare output array for clip distances uint32_t clipDistArray = m_module.newVar( m_module.defPointerType( @@ -2182,7 +2379,6 @@ namespace dxvk { spv::StorageClassOutput); m_module.decorateBuiltIn(clipDistArray, spv::BuiltInClipDistance); - m_entryPointInterfaces.push_back(clipDistArray); // Compute clip distances for (uint32_t i = 0; i < caps::MaxClipPlanes; i++) { @@ -2208,103 +2404,55 @@ namespace dxvk { void D3D9FFShaderCompiler::alphaTestPS() { - // Alpha testing - uint32_t boolType = m_module.defBoolType(); - uint32_t floatPtr = m_module.defPointerType(m_floatType, spv::StorageClassPushConstant); + uint32_t uintPtr = m_module.defPointerType(m_uint32Type, spv::StorageClassPushConstant); - // Declare spec constants for render states - uint32_t alphaFuncId = m_module.specConst32(m_module.defIntType(32, 0), 0); - m_module.setDebugName(alphaFuncId, "alpha_func"); - m_module.decorateSpecId(alphaFuncId, getSpecId(D3D9SpecConstantId::AlphaCompareOp)); - - // Implement alpha test auto oC0 = m_ps.out.COLOR; - // Labels for the alpha test - std::array atestCaseLabels = { { - { uint32_t(VK_COMPARE_OP_NEVER), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_LESS), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_EQUAL), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_LESS_OR_EQUAL), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_GREATER), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_NOT_EQUAL), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_GREATER_OR_EQUAL), m_module.allocateId() }, - { uint32_t(VK_COMPARE_OP_ALWAYS), m_module.allocateId() }, - } }; - uint32_t atestBeginLabel = m_module.allocateId(); - uint32_t atestTestLabel = m_module.allocateId(); - uint32_t atestDiscardLabel = m_module.allocateId(); - uint32_t atestKeepLabel = m_module.allocateId(); - uint32_t atestSkipLabel = m_module.allocateId(); - - // if (alpha_test) { ... } - uint32_t isNotAlways = m_module.opINotEqual(boolType, alphaFuncId, m_module.constu32(VK_COMPARE_OP_ALWAYS)); - m_module.opSelectionMerge(atestSkipLabel, spv::SelectionControlMaskNone); - m_module.opBranchConditional(isNotAlways, atestBeginLabel, atestSkipLabel); - m_module.opLabel(atestBeginLabel); - - // Load alpha component uint32_t alphaComponentId = 3; - uint32_t alphaId = m_module.opCompositeExtract(m_floatType, + uint32_t alphaRefMember = m_module.constu32(uint32_t(D3D9RenderStateItem::AlphaRef)); + + D3D9AlphaTestContext alphaTestContext; + alphaTestContext.alphaFuncId = m_spec.get(m_module, m_specUbo, SpecAlphaCompareOp); + alphaTestContext.alphaPrecisionId = m_spec.get(m_module, m_specUbo, SpecAlphaPrecisionBits); + alphaTestContext.alphaRefId = m_module.opLoad(m_uint32Type, + m_module.opAccessChain(uintPtr, m_rsBlock, 1, &alphaRefMember)); + alphaTestContext.alphaId = m_module.opCompositeExtract(m_floatType, m_module.opLoad(m_vec4Type, oC0), 1, &alphaComponentId); - // Load alpha reference - uint32_t alphaRefMember = m_module.constu32(uint32_t(D3D9RenderStateItem::AlphaRef)); - uint32_t alphaRefId = m_module.opLoad(m_floatType, - m_module.opAccessChain(floatPtr, m_rsBlock, 1, &alphaRefMember)); + DoFixedFunctionAlphaTest(m_module, alphaTestContext); + } - // switch (alpha_func) { ... } - m_module.opSelectionMerge(atestTestLabel, spv::SelectionControlMaskNone); - m_module.opSwitch(alphaFuncId, - atestCaseLabels[uint32_t(VK_COMPARE_OP_ALWAYS)].labelId, - atestCaseLabels.size(), - atestCaseLabels.data()); - std::array atestVariables; + uint32_t D3D9FFShaderCompiler::emitMatrixTimesVector(uint32_t rowCount, uint32_t colCount, uint32_t matrix, uint32_t vector) { + uint32_t f32Type = m_module.defFloatType(32); + uint32_t vecType = m_module.defVectorType(f32Type, rowCount); + uint32_t accum = 0; - for (uint32_t i = 0; i < atestCaseLabels.size(); i++) { - m_module.opLabel(atestCaseLabels[i].labelId); + for (uint32_t i = 0; i < colCount; i++) { + std::array indices = { i, i, i, i }; - atestVariables[i].labelId = atestCaseLabels[i].labelId; - atestVariables[i].varId = [&] { - switch (VkCompareOp(atestCaseLabels[i].literal)) { - case VK_COMPARE_OP_NEVER: return m_module.constBool(false); - case VK_COMPARE_OP_LESS: return m_module.opFOrdLessThan(boolType, alphaId, alphaRefId); - case VK_COMPARE_OP_EQUAL: return m_module.opFOrdEqual(boolType, alphaId, alphaRefId); - case VK_COMPARE_OP_LESS_OR_EQUAL: return m_module.opFOrdLessThanEqual(boolType, alphaId, alphaRefId); - case VK_COMPARE_OP_GREATER: return m_module.opFOrdGreaterThan(boolType, alphaId, alphaRefId); - case VK_COMPARE_OP_NOT_EQUAL: return m_module.opFOrdNotEqual(boolType, alphaId, alphaRefId); - case VK_COMPARE_OP_GREATER_OR_EQUAL: return m_module.opFOrdGreaterThanEqual(boolType, alphaId, alphaRefId); - default: - case VK_COMPARE_OP_ALWAYS: return m_module.constBool(true); - } - }(); + uint32_t a = m_module.opVectorShuffle(vecType, vector, vector, rowCount, indices.data()); + uint32_t b = m_module.opCompositeExtract(vecType, matrix, 1, &i); - m_module.opBranch(atestTestLabel); + accum = accum + ? m_module.opFFma(vecType, a, b, accum) + : m_module.opFMul(vecType, a, b); + + m_module.decorate(accum, spv::DecorationNoContraction); } - // end switch - m_module.opLabel(atestTestLabel); + return accum; + } - uint32_t atestResult = m_module.opPhi(boolType, - atestVariables.size(), - atestVariables.data()); - uint32_t atestDiscard = m_module.opLogicalNot(boolType, atestResult); - // if (do_discard) { ... } - m_module.opSelectionMerge(atestKeepLabel, spv::SelectionControlMaskNone); - m_module.opBranchConditional(atestDiscard, atestDiscardLabel, atestKeepLabel); + uint32_t D3D9FFShaderCompiler::emitVectorTimesMatrix(uint32_t rowCount, uint32_t colCount, uint32_t vector, uint32_t matrix) { + uint32_t f32Type = m_module.defFloatType(32); + uint32_t vecType = m_module.defVectorType(f32Type, colCount); + uint32_t matType = m_module.defMatrixType(vecType, rowCount); - m_module.opLabel(atestDiscardLabel); - m_module.opKill(); - - // end if (do_discard) - m_module.opLabel(atestKeepLabel); - m_module.opBranch(atestSkipLabel); - - // end if (alpha_test) - m_module.opLabel(atestSkipLabel); + matrix = m_module.opTranspose(matType, matrix); + return emitMatrixTimesVector(colCount, rowCount, matrix, vector); } @@ -2324,7 +2472,7 @@ namespace dxvk { m_shader = compiler.compile(); m_isgn = compiler.isgn(); - Dump(Key, name); + Dump(pDevice, Key, name); m_shader->setShaderKey(shaderKey); pDevice->GetDXVKDevice()->registerShader(m_shader); @@ -2347,19 +2495,19 @@ namespace dxvk { m_shader = compiler.compile(); m_isgn = compiler.isgn(); - Dump(Key, name); + Dump(pDevice, Key, name); m_shader->setShaderKey(shaderKey); pDevice->GetDXVKDevice()->registerShader(m_shader); } template - void D3D9FFShader::Dump(const T& Key, const std::string& Name) { - const std::string dumpPath = env::getEnvVar("DXVK_SHADER_DUMP_PATH"); + void D3D9FFShader::Dump(D3D9DeviceEx* pDevice, const T& Key, const std::string& Name) { + const std::string& dumpPath = pDevice->GetOptions()->shaderDumpPath; if (dumpPath.size() != 0) { std::ofstream dumpStream( - str::tows(str::format(dumpPath, "/", Name, ".spv").c_str()).c_str(), + str::topath(str::format(dumpPath, "/", Name, ".spv").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc); m_shader->dump(dumpStream); diff --git a/src/d3d9/d3d9_fixed_function.h b/src/d3d9/d3d9_fixed_function.h index 8e312aa2..104f044c 100644 --- a/src/d3d9/d3d9_fixed_function.h +++ b/src/d3d9/d3d9_fixed_function.h @@ -17,6 +17,7 @@ namespace dxvk { class SpirvModule; struct D3D9Options; + class D3D9ShaderSpecConstantManager; struct D3D9FogContext { // General inputs... @@ -34,17 +35,28 @@ namespace dxvk { bool IsPositionT; bool HasSpecular; uint32_t Specular; + uint32_t SpecUBO; + }; + + struct D3D9AlphaTestContext { + uint32_t alphaId; + uint32_t alphaPrecisionId; + uint32_t alphaFuncId; + uint32_t alphaRefId; }; struct D3D9FixedFunctionOptions { D3D9FixedFunctionOptions(const D3D9Options* options); bool invariantPosition; + bool forceSampleRateShading; }; // Returns new oFog if VS // Returns new oColor if PS - uint32_t DoFixedFunctionFog(SpirvModule& spvModule, const D3D9FogContext& fogCtx); + uint32_t DoFixedFunctionFog(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, const D3D9FogContext& fogCtx); + + void DoFixedFunctionAlphaTest(SpirvModule& spvModule, const D3D9AlphaTestContext& ctx); // Returns a render state block uint32_t SetupRenderStateBlock(SpirvModule& spvModule, uint32_t count); @@ -56,18 +68,20 @@ namespace dxvk { }; // Default point size and point scale magic! - D3D9PointSizeInfoVS GetPointSizeInfoVS(SpirvModule& spvModule, uint32_t vPos, uint32_t vtx, uint32_t perVertPointSize, uint32_t rsBlock, bool isFixedFunction); + D3D9PointSizeInfoVS GetPointSizeInfoVS(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, uint32_t vPos, uint32_t vtx, uint32_t perVertPointSize, uint32_t rsBlock, uint32_t specUbo, bool isFixedFunction); struct D3D9PointSizeInfoPS { uint32_t isSprite; }; - D3D9PointSizeInfoPS GetPointSizeInfoPS(SpirvModule& spvModule, uint32_t rsBlock); + D3D9PointSizeInfoPS GetPointSizeInfoPS(D3D9ShaderSpecConstantManager& spec, SpirvModule& spvModule, uint32_t rsBlock, uint32_t specUbo); - uint32_t GetPointCoord(SpirvModule& spvModule, std::vector& entryPointInterfaces); + uint32_t GetPointCoord(SpirvModule& spvModule); uint32_t GetSharedConstants(SpirvModule& spvModule); + uint32_t SetupSpecUBO(SpirvModule& spvModule, std::vector& bindings); + constexpr uint32_t TCIOffset = 16; constexpr uint32_t TCIMask = 0b111 << TCIOffset; @@ -150,10 +164,11 @@ namespace dxvk { uint32_t ProjectedCount : 3; + uint32_t TextureBound : 1; + // Included in here, read from Stage 0 for packing reasons // Affects all stages. uint32_t GlobalSpecularEnable : 1; - uint32_t GlobalFlatShade : 1; } Contents; uint32_t Primitive[2]; @@ -203,7 +218,7 @@ namespace dxvk { const D3D9FFShaderKeyFS& Key); template - void Dump(const T& Key, const std::string& Name); + void Dump(D3D9DeviceEx* pDevice, const T& Key, const std::string& Name); Rc GetShader() const { return m_shader; diff --git a/src/d3d9/d3d9_format.cpp b/src/d3d9/d3d9_format.cpp index 5654337d..87431a87 100644 --- a/src/d3d9/d3d9_format.cpp +++ b/src/d3d9/d3d9_format.cpp @@ -39,7 +39,7 @@ namespace dxvk { VK_IMAGE_ASPECT_COLOR_BIT }; case D3D9Format::A4R4G4B4: return { - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, + VK_FORMAT_A4R4G4B4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT }; @@ -55,7 +55,7 @@ namespace dxvk { case D3D9Format::A8R3G3B2: return {}; // Unsupported case D3D9Format::X4R4G4B4: return { - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, + VK_FORMAT_A4R4G4B4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT }; @@ -132,7 +132,7 @@ namespace dxvk { VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }, - { D3D9ConversionFormat_L6V5U5, 1u, + { D3D9ConversionFormat_L6V5U5, // Convert -> float (this is a mixed snorm and unorm type) VK_FORMAT_R16G16B16A16_SFLOAT } }; @@ -142,7 +142,7 @@ namespace dxvk { VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_ONE }, - { D3D9ConversionFormat_X8L8V8U8, 1u, + { D3D9ConversionFormat_X8L8V8U8, // Convert -> float (this is a mixed snorm and unorm type) VK_FORMAT_R16G16B16A16_SFLOAT } }; @@ -164,17 +164,27 @@ namespace dxvk { VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }, - { D3D9ConversionFormat_A2W10V10U10, 1u, + { D3D9ConversionFormat_A2W10V10U10, // Convert -> float (this is a mixed snorm and unorm type) VK_FORMAT_R16G16B16A16_SFLOAT } }; + case D3D9Format::W11V11U10: return { + VK_FORMAT_B10G11R11_UFLOAT_PACK32, + VK_FORMAT_UNDEFINED, + VK_IMAGE_ASPECT_COLOR_BIT, + { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, + VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_ONE }, + { D3D9ConversionFormat_W11V11U10, + // can't use B10G11R11 bc this is a snorm type + VK_FORMAT_R16G16B16A16_SNORM } }; + case D3D9Format::UYVY: return { - VK_FORMAT_B8G8R8A8_UNORM, + VK_FORMAT_G8B8G8R8_422_UNORM, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }, - { D3D9ConversionFormat_UYVY, 1u } + { D3D9ConversionFormat_UYVY, VK_FORMAT_B8G8R8A8_UNORM } }; case D3D9Format::R8G8_B8G8: return { @@ -183,12 +193,12 @@ namespace dxvk { VK_IMAGE_ASPECT_COLOR_BIT }; case D3D9Format::YUY2: return { - VK_FORMAT_B8G8R8A8_UNORM, + VK_FORMAT_G8B8G8R8_422_UNORM, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }, - { D3D9ConversionFormat_YUY2, 1u } + { D3D9ConversionFormat_YUY2, VK_FORMAT_B8G8R8A8_UNORM } }; case D3D9Format::G8R8_G8B8: return { @@ -400,21 +410,21 @@ namespace dxvk { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_R }}; case D3D9Format::NV12: return { - VK_FORMAT_R8_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }, - { D3D9ConversionFormat_NV12, 2u, VK_FORMAT_B8G8R8A8_UNORM } + { D3D9ConversionFormat_NV12, VK_FORMAT_B8G8R8A8_UNORM } }; case D3D9Format::YV12: return { - VK_FORMAT_R8_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_FORMAT_UNDEFINED, VK_IMAGE_ASPECT_COLOR_BIT, { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }, - { D3D9ConversionFormat_YV12, 3u, VK_FORMAT_B8G8R8A8_UNORM } + { D3D9ConversionFormat_YV12, VK_FORMAT_B8G8R8A8_UNORM } }; case D3D9Format::RAWZ: return {}; // Unsupported @@ -434,19 +444,16 @@ namespace dxvk { // AMD do not support 24-bit depth buffers on Vulkan, // so we have to fall back to a 32-bit depth format. - m_d24s8Support = CheckImageFormatSupport(adapter, VK_FORMAT_D24_UNORM_S8_UINT, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); + m_d24s8Support = !options.useD32forD24 && + CheckImageFormatSupport(adapter, VK_FORMAT_D24_UNORM_S8_UINT, + VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT); // NVIDIA do not support 16-bit depth buffers with stencil on Vulkan, // so we have to fall back to a 32-bit depth format. m_d16s8Support = CheckImageFormatSupport(adapter, VK_FORMAT_D16_UNORM_S8_UINT, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); - - // VK_EXT_4444_formats - m_a4r4g4b4Support = CheckImageFormatSupport(adapter, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); + VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT); if (!m_d24s8Support) Logger::info("D3D9: VK_FORMAT_D24_UNORM_S8_UINT -> VK_FORMAT_D32_SFLOAT_S8_UINT"); @@ -457,9 +464,6 @@ namespace dxvk { else Logger::info("D3D9: VK_FORMAT_D16_UNORM_S8_UINT -> VK_FORMAT_D32_SFLOAT_S8_UINT"); } - - if (!m_a4r4g4b4Support) - Logger::warn("D3D9: VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT -> VK_FORMAT_B4G4R4A4_UNORM_PACK16"); } D3D9_VK_FORMAT_MAPPING D3D9VkFormatTable::GetFormatMapping( @@ -479,22 +483,11 @@ namespace dxvk { return D3D9_VK_FORMAT_MAPPING(); if (!m_d24s8Support && mapping.FormatColor == VK_FORMAT_D24_UNORM_S8_UINT) - mapping.FormatColor = VK_FORMAT_D32_SFLOAT_S8_UINT; + mapping.FormatColor = mapping.Aspect & VK_IMAGE_ASPECT_STENCIL_BIT ? VK_FORMAT_D32_SFLOAT_S8_UINT : VK_FORMAT_D32_SFLOAT; if (!m_d16s8Support && mapping.FormatColor == VK_FORMAT_D16_UNORM_S8_UINT) mapping.FormatColor = m_d24s8Support ? VK_FORMAT_D24_UNORM_S8_UINT : VK_FORMAT_D32_SFLOAT_S8_UINT; - if (!m_a4r4g4b4Support && mapping.FormatColor == VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT) { - VkComponentSwizzle alphaSwizzle = Format == D3D9Format::A4R4G4B4 - ? VK_COMPONENT_SWIZZLE_B - : VK_COMPONENT_SWIZZLE_ONE; - - mapping.FormatColor = VK_FORMAT_B4G4R4A4_UNORM_PACK16; - mapping.Swizzle = { - VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_R, - VK_COMPONENT_SWIZZLE_A, alphaSwizzle }; - } - return mapping; } @@ -555,11 +548,11 @@ namespace dxvk { bool D3D9VkFormatTable::CheckImageFormatSupport( const Rc& Adapter, VkFormat Format, - VkFormatFeatureFlags Features) const { - VkFormatProperties supported = Adapter->formatProperties(Format); + VkFormatFeatureFlags2 Features) const { + DxvkFormatFeatures supported = Adapter->getFormatFeatures(Format); - return (supported.linearTilingFeatures & Features) == Features - || (supported.optimalTilingFeatures & Features) == Features; + return (supported.linear & Features) == Features + || (supported.optimal & Features) == Features; } } \ No newline at end of file diff --git a/src/d3d9/d3d9_format.h b/src/d3d9/d3d9_format.h index 0c9ab168..6054717d 100644 --- a/src/d3d9/d3d9_format.h +++ b/src/d3d9/d3d9_format.h @@ -40,6 +40,7 @@ namespace dxvk { X8L8V8U8 = 62, Q8W8V8U8 = 63, V16U16 = 64, + W11V11U10 = 65, A2W10V10U10 = 67, UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'), @@ -134,6 +135,7 @@ namespace dxvk { D3D9ConversionFormat_L6V5U5, D3D9ConversionFormat_X8L8V8U8, D3D9ConversionFormat_A2W10V10U10, + D3D9ConversionFormat_W11V11U10, D3D9ConversionFormat_NV12, D3D9ConversionFormat_YV12, D3D9ConversionFormat_Count @@ -141,7 +143,6 @@ namespace dxvk { struct D3D9_CONVERSION_FORMAT_INFO { D3D9ConversionFormat FormatType = D3D9ConversionFormat_None; - uint32_t PlaneCount = 1; VkFormat FormatColor = VK_FORMAT_UNDEFINED; VkFormat FormatSrgb = VK_FORMAT_UNDEFINED; }; @@ -209,9 +210,8 @@ namespace dxvk { bool CheckImageFormatSupport( const Rc& Adapter, VkFormat Format, - VkFormatFeatureFlags Features) const; + VkFormatFeatureFlags2 Features) const; - bool m_a4r4g4b4Support; bool m_d24s8Support; bool m_d16s8Support; @@ -220,4 +220,22 @@ namespace dxvk { bool m_d32supportFinal; }; + inline bool IsFourCCFormat(D3D9Format format) { + // BINARYBUFFER is the largest non-fourcc format + return format > D3D9Format::BINARYBUFFER; + } + + inline bool IsVendorFormat(D3D9Format format) { + return IsFourCCFormat(format) + && format != D3D9Format::MULTI2_ARGB8 + && format != D3D9Format::UYVY + && format != D3D9Format::R8G8_B8G8 + && format != D3D9Format::G8R8_G8B8 + && format != D3D9Format::DXT1 + && format != D3D9Format::DXT2 + && format != D3D9Format::DXT3 + && format != D3D9Format::DXT4 + && format != D3D9Format::DXT5; + } + } diff --git a/src/d3d9/d3d9_format_helpers.cpp b/src/d3d9/d3d9_format_helpers.cpp index e528f90c..f0cdd2b6 100644 --- a/src/d3d9/d3d9_format_helpers.cpp +++ b/src/d3d9/d3d9_format_helpers.cpp @@ -4,13 +4,14 @@ #include #include #include +#include #include #include namespace dxvk { D3D9FormatHelper::D3D9FormatHelper(const Rc& device) - : m_device(device), m_context(m_device->createContext()) { + : m_device(device), m_context(m_device->createContext(DxvkContextType::Supplementary)) { m_context->beginRecording( m_device->createCommandList()); @@ -57,6 +58,10 @@ namespace dxvk { ConvertGenericFormat(conversionFormat, dstImage, dstSubresource, srcSlice, VK_FORMAT_R32_UINT, 0, { 1u, 1u }); break; + case D3D9ConversionFormat_W11V11U10: + ConvertGenericFormat(conversionFormat, dstImage, dstSubresource, srcSlice, VK_FORMAT_R32_UINT, 0, { 1u, 1u }); + break; + default: Logger::warn("Unimplemented format conversion"); } @@ -93,22 +98,16 @@ namespace dxvk { bufferViewInfo.rangeLength = srcSlice.length(); auto tmpBufferView = m_device->createBufferView(srcSlice.buffer(), bufferViewInfo); - if (specConstantValue) - m_context->setSpecConstant(VK_PIPELINE_BIND_POINT_COMPUTE, 0, specConstantValue); - - m_context->bindResourceView(BindingIds::Image, tmpImageView, nullptr); - m_context->bindResourceView(BindingIds::Buffer, nullptr, tmpBufferView); - m_context->bindShader(VK_SHADER_STAGE_COMPUTE_BIT, m_shaders[videoFormat.FormatType]); + m_context->setSpecConstant(VK_PIPELINE_BIND_POINT_COMPUTE, 0, specConstantValue); + m_context->bindResourceImageView(VK_SHADER_STAGE_COMPUTE_BIT, BindingIds::Image, std::move(tmpImageView)); + m_context->bindResourceBufferView(VK_SHADER_STAGE_COMPUTE_BIT, BindingIds::Buffer, std::move(tmpBufferView)); + m_context->bindShader(Rc(m_shaders[videoFormat.FormatType])); m_context->pushConstants(0, sizeof(VkExtent2D), &imageExtent); m_context->dispatch( (imageExtent.width / 8) + (imageExtent.width % 8), (imageExtent.height / 8) + (imageExtent.height % 8), 1); - // Reset the spec constants used... - if (specConstantValue) - m_context->setSpecConstant(VK_PIPELINE_BIND_POINT_COMPUTE, 0, 0); - m_transferCommands += 1; } @@ -119,21 +118,22 @@ namespace dxvk { m_shaders[D3D9ConversionFormat_L6V5U5] = InitShader(d3d9_convert_l6v5u5); m_shaders[D3D9ConversionFormat_X8L8V8U8] = InitShader(d3d9_convert_x8l8v8u8); m_shaders[D3D9ConversionFormat_A2W10V10U10] = InitShader(d3d9_convert_a2w10v10u10); + m_shaders[D3D9ConversionFormat_W11V11U10] = InitShader(d3d9_convert_w11v11u10); m_shaders[D3D9ConversionFormat_NV12] = InitShader(d3d9_convert_nv12); m_shaders[D3D9ConversionFormat_YV12] = InitShader(d3d9_convert_yv12); } Rc D3D9FormatHelper::InitShader(SpirvCodeBuffer code) { - const std::array resourceSlots = { { - { BindingIds::Image, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_IMAGE_VIEW_TYPE_2D }, - { BindingIds::Buffer, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_IMAGE_VIEW_TYPE_1D }, + const std::array bindings = { { + { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, BindingIds::Image, VK_IMAGE_VIEW_TYPE_2D, VK_SHADER_STAGE_COMPUTE_BIT, VK_ACCESS_SHADER_WRITE_BIT }, + { VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, BindingIds::Buffer, VK_IMAGE_VIEW_TYPE_1D, VK_SHADER_STAGE_COMPUTE_BIT, VK_ACCESS_SHADER_READ_BIT }, } }; DxvkShaderCreateInfo info; info.stage = VK_SHADER_STAGE_COMPUTE_BIT; - info.resourceSlotCount = resourceSlots.size(); - info.resourceSlots = resourceSlots.data(); + info.bindingCount = bindings.size(); + info.bindings = bindings.data(); info.pushConstOffset = 0; info.pushConstSize = sizeof(VkExtent2D); @@ -142,7 +142,7 @@ namespace dxvk { void D3D9FormatHelper::FlushInternal() { - m_context->flushCommandList(); + m_context->flushCommandList(nullptr); m_transferCommands = 0; } diff --git a/src/d3d9/d3d9_hud.cpp b/src/d3d9/d3d9_hud.cpp index e37a5a0e..b9ab5f43 100644 --- a/src/d3d9/d3d9_hud.cpp +++ b/src/d3d9/d3d9_hud.cpp @@ -33,4 +33,63 @@ namespace dxvk::hud { return position; } + HudTextureMemory::HudTextureMemory(D3D9DeviceEx* device) + : m_device (device) + , m_allocatedString ("") + , m_mappedString ("") {} + + + void HudTextureMemory::update(dxvk::high_resolution_clock::time_point time) { + D3D9MemoryAllocator* allocator = m_device->GetAllocator(); + + m_maxAllocated = std::max(m_maxAllocated, allocator->AllocatedMemory()); + m_maxUsed = std::max(m_maxUsed, allocator->UsedMemory()); + m_maxMapped = std::max(m_maxMapped, allocator->MappedMemory()); + + auto elapsed = std::chrono::duration_cast(time - m_lastUpdate); + + if (elapsed.count() < UpdateInterval) + return; + + m_allocatedString = str::format(m_maxAllocated >> 20, " MB (Used: ", m_maxUsed >> 20, " MB)"); + m_mappedString = str::format(m_maxMapped >> 20, " MB"); + m_maxAllocated = 0; + m_maxUsed = 0; + m_maxMapped = 0; + m_lastUpdate = time; + } + + + HudPos HudTextureMemory::render( + HudRenderer& renderer, + HudPos position) { + position.y += 16.0f; + + renderer.drawText(16.0f, + { position.x, position.y }, + { 0.0f, 1.0f, 0.75f, 1.0f }, + "Mappable:"); + + renderer.drawText(16.0f, + { position.x + 120.0f, position.y }, + { 1.0f, 1.0f, 1.0f, 1.0f }, + m_allocatedString); + + position.y += 24.0f; + + renderer.drawText(16.0f, + { position.x, position.y }, + { 0.0f, 1.0f, 0.75f, 1.0f }, + "Mapped:"); + + renderer.drawText(16.0f, + { position.x + 120.0f, position.y }, + { 1.0f, 1.0f, 1.0f, 1.0f }, + m_mappedString); + + position.y += 8.0f; + + return position; + } + } \ No newline at end of file diff --git a/src/d3d9/d3d9_hud.h b/src/d3d9/d3d9_hud.h index b500e48b..b0060ef3 100644 --- a/src/d3d9/d3d9_hud.h +++ b/src/d3d9/d3d9_hud.h @@ -6,7 +6,7 @@ namespace dxvk::hud { /** - * \brief HUD item to display DXVK version + * \brief HUD item to display sampler count */ class HudSamplerCount : public HudItem { @@ -28,4 +28,36 @@ namespace dxvk::hud { }; + /** + * \brief HUD item to display unmappable memory + */ + class HudTextureMemory : public HudItem { + constexpr static int64_t UpdateInterval = 500'000; + + public: + + HudTextureMemory(D3D9DeviceEx* device); + + void update(dxvk::high_resolution_clock::time_point time); + + HudPos render( + HudRenderer& renderer, + HudPos position); + + private: + + D3D9DeviceEx* m_device; + + uint32_t m_maxAllocated = 0; + uint32_t m_maxUsed = 0; + uint32_t m_maxMapped = 0; + + dxvk::high_resolution_clock::time_point m_lastUpdate + = dxvk::high_resolution_clock::now(); + + std::string m_allocatedString; + std::string m_mappedString; + + }; + } \ No newline at end of file diff --git a/src/d3d9/d3d9_include.h b/src/d3d9/d3d9_include.h index 8762265a..9e67e577 100644 --- a/src/d3d9/d3d9_include.h +++ b/src/d3d9/d3d9_include.h @@ -11,10 +11,10 @@ #include //for some reason we need to specify __declspec(dllexport) for MinGW -#if defined(__WINE__) -#define DLLEXPORT __attribute__((visibility("default"))) +#if defined(__WINE__) || !defined(_WIN32) + #define DLLEXPORT __attribute__((visibility("default"))) #else -#define DLLEXPORT + #define DLLEXPORT #endif @@ -36,60 +36,74 @@ #include "../util/util_flags.h" #include "../util/util_likely.h" #include "../util/util_math.h" -#include "../util/util_monitor.h" #include "../util/util_string.h" // Missed definitions in Wine/MinGW. -#ifndef D3DPRESENT_BACK_BUFFERS_MAX_EX -#define D3DPRESENT_BACK_BUFFERS_MAX_EX 30 -#endif - -#ifndef D3DSI_OPCODE_MASK -#define D3DSI_OPCODE_MASK 0x0000FFFF -#endif - -#ifndef D3DSP_TEXTURETYPE_MASK -#define D3DSP_TEXTURETYPE_MASK 0x78000000 -#endif - -#ifndef D3DUSAGE_AUTOGENMIPMAP -#define D3DUSAGE_AUTOGENMIPMAP 0x00000400L -#endif - -#ifndef D3DSP_DCL_USAGE_MASK -#define D3DSP_DCL_USAGE_MASK 0x0000000f -#endif - -#ifndef D3DSP_OPCODESPECIFICCONTROL_MASK -#define D3DSP_OPCODESPECIFICCONTROL_MASK 0x00ff0000 -#endif - -#ifndef D3DSP_OPCODESPECIFICCONTROL_SHIFT -#define D3DSP_OPCODESPECIFICCONTROL_SHIFT 16 -#endif - -#ifndef D3DCURSOR_IMMEDIATE_UPDATE -#define D3DCURSOR_IMMEDIATE_UPDATE 0x00000001L -#endif - #ifndef D3DPRESENT_FORCEIMMEDIATE #define D3DPRESENT_FORCEIMMEDIATE 0x00000100L #endif +#ifndef D3DSWAPEFFECT_COPY_VSYNC +#define D3DSWAPEFFECT_COPY_VSYNC 4 +#endif + // MinGW headers are broken. Who'dve guessed? #ifndef _MSC_VER typedef struct _D3DDEVINFO_RESOURCEMANAGER { char dummy; } D3DDEVINFO_RESOURCEMANAGER, * LPD3DDEVINFO_RESOURCEMANAGER; - -#ifndef __WINE__ -extern "C" WINUSERAPI WINBOOL WINAPI SetProcessDPIAware(VOID); -#endif #endif // This is the managed pool on D3D9Ex, it's just hidden! #define D3DPOOL_MANAGED_EX D3DPOOL(6) using D3D9VertexElements = std::vector; + +///////////////////// +// D3D9On12 content +///////////////////// + +#include + +#define MAX_D3D9ON12_QUEUES 2 + +struct D3D9ON12_ARGS { + BOOL Enable9On12; + IUnknown* pD3D12Device; + IUnknown* ppD3D12Queues[MAX_D3D9ON12_QUEUES]; + UINT NumQueues; + UINT NodeMask; +}; + +extern "C" { + + // Ordinal 20 + typedef IDirect3D9* (WINAPI* PFN_Direct3DCreate9On12)(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count); + IDirect3D9* WINAPI Direct3DCreate9On12(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count); + + // Ordinal 21 + typedef HRESULT(WINAPI* PFN_Direct3DCreate9On12Ex)(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count, IDirect3D9Ex** output); + HRESULT WINAPI Direct3DCreate9On12Ex(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count, IDirect3D9Ex** output); + +} + +MIDL_INTERFACE("e7fda234-b589-4049-940d-8878977531c8") +IDirect3DDevice9On12 : public IUnknown { + + virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** object) = 0; + virtual ULONG STDMETHODCALLTYPE AddRef() = 0; + virtual ULONG STDMETHODCALLTYPE Release() = 0; + + virtual HRESULT STDMETHODCALLTYPE GetD3D12Device(REFIID riid, void** object) = 0; + virtual HRESULT STDMETHODCALLTYPE UnwrapUnderlyingResource(IDirect3DResource9* resource, ID3D12CommandQueue* command_queue, REFIID riid, void** object) = 0; + virtual HRESULT STDMETHODCALLTYPE ReturnUnderlyingResource(IDirect3DResource9* resource, UINT num_sync, UINT64* signal_values, ID3D12Fence** fences) = 0; +}; + +#ifdef _MSC_VER +struct __declspec(uuid("e7fda234-b589-4049-940d-8878977531c8")) IDirect3DDevice9On12; +#else +__CRT_UUID_DECL(IDirect3DDevice9On12, 0xe7fda234,0xb589,0x4049,0x94,0x0d,0x88,0x78,0x97,0x75,0x31,0xc8); +#endif + diff --git a/src/d3d9/d3d9_initializer.cpp b/src/d3d9/d3d9_initializer.cpp index 22088c9b..26dae412 100644 --- a/src/d3d9/d3d9_initializer.cpp +++ b/src/d3d9/d3d9_initializer.cpp @@ -6,7 +6,7 @@ namespace dxvk { D3D9Initializer::D3D9Initializer( const Rc& Device) - : m_device(Device), m_context(m_device->createContext()) { + : m_device(Device), m_context(m_device->createContext(DxvkContextType::Supplementary)) { m_context->beginRecording( m_device->createCommandList()); } @@ -40,13 +40,15 @@ namespace dxvk { void D3D9Initializer::InitTexture( D3D9CommonTexture* pTexture, - void* pInitialData) { + void* pInitialData) { if (pTexture->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_NONE) return; - (pTexture->GetMapMode() == D3D9_COMMON_TEXTURE_MAP_MODE_BACKED) - ? InitDeviceLocalTexture(pTexture) - : InitHostVisibleTexture(pTexture, pInitialData); + if (pTexture->GetImage() != nullptr) + InitDeviceLocalTexture(pTexture); + + if (pTexture->Desc()->Pool != D3DPOOL_DEFAULT) + InitHostVisibleTexture(pTexture, pInitialData); } @@ -82,7 +84,7 @@ namespace dxvk { if (image == nullptr) return; - auto formatInfo = imageFormatInfo(image->info().format); + auto formatInfo = lookupFormatInfo(image->info().format); m_transferCommands += 1; @@ -111,38 +113,35 @@ namespace dxvk { // If the buffer is mapped, we can write data directly // to the mapped memory region instead of doing it on // the GPU. Same goes for zero-initialization. - const D3D9_COMMON_TEXTURE_DESC* desc = pTexture->Desc(); - for (uint32_t a = 0; a < desc->ArraySize; a++) { - for (uint32_t m = 0; m < desc->MipLevels; m++) { - uint32_t subresource = pTexture->CalcSubresource(a, m); - DxvkBufferSliceHandle mapSlice = pTexture->GetBuffer(subresource)->getSliceHandle(); + void* mapPtr = pTexture->GetData(0); + if (pInitialData) { + // Initial data is only supported for textures with 1 subresource + VkExtent3D mipExtent = pTexture->GetExtentMip(0); + const DxvkFormatInfo* formatInfo = lookupFormatInfo(pTexture->GetFormatMapping().FormatColor); + VkExtent3D blockCount = util::computeBlockCount(mipExtent, formatInfo->blockSize); + uint32_t pitch = blockCount.width * formatInfo->elementSize; + uint32_t alignedPitch = align(pitch, 4); - if (pInitialData != nullptr) { - VkExtent3D mipExtent = pTexture->GetExtentMip(m); - const DxvkFormatInfo* formatInfo = imageFormatInfo(pTexture->GetFormatMapping().FormatColor); - VkExtent3D blockCount = util::computeBlockCount(mipExtent, formatInfo->blockSize); - uint32_t pitch = blockCount.width * formatInfo->elementSize; - uint32_t alignedPitch = align(pitch, 4); - - util::packImageData( - mapSlice.mapPtr, - pInitialData, - pitch, - pitch * blockCount.height, - alignedPitch, - alignedPitch * blockCount.height, - D3D9CommonTexture::GetImageTypeFromResourceType(pTexture->GetType()), - mipExtent, - pTexture->Desc()->ArraySize, - formatInfo, - VK_IMAGE_ASPECT_COLOR_BIT); - } else { - std::memset( - mapSlice.mapPtr, 0, - mapSlice.length); - } - } + util::packImageData( + mapPtr, + pInitialData, + pitch, + pitch * blockCount.height, + alignedPitch, + alignedPitch * blockCount.height, + D3D9CommonTexture::GetImageTypeFromResourceType(pTexture->GetType()), + mipExtent, + pTexture->Desc()->ArraySize, + formatInfo, + VK_IMAGE_ASPECT_COLOR_BIT); + } else { + // All subresources are allocated in one chunk of memory. + // So we can just get the pointer for subresource 0 and memset all of them at once. + std::memset( + mapPtr, 0, + pTexture->GetTotalSize()); } + pTexture->UnmapData(); } @@ -154,7 +153,7 @@ namespace dxvk { void D3D9Initializer::FlushInternal() { - m_context->flushCommandList(); + m_context->flushCommandList(nullptr); m_transferCommands = 0; m_transferMemory = 0; diff --git a/src/d3d9/d3d9_interface.cpp b/src/d3d9/d3d9_interface.cpp index 43f14e89..690e16d1 100644 --- a/src/d3d9/d3d9_interface.cpp +++ b/src/d3d9/d3d9_interface.cpp @@ -3,15 +3,22 @@ #include "d3d9_monitor.h" #include "d3d9_caps.h" #include "d3d9_device.h" +#include "d3d9_bridge.h" + +#include "../util/util_singleton.h" #include namespace dxvk { + Singleton g_dxvkInstance; + D3D9InterfaceEx::D3D9InterfaceEx(bool bExtended) - : m_instance ( new DxvkInstance() ) + : m_instance ( g_dxvkInstance.acquire() ) + , m_d3d8Bridge ( this ) , m_extended ( bExtended ) - , m_d3d9Options ( nullptr, m_instance->config() ) { + , m_d3d9Options ( nullptr, m_instance->config() ) + , m_d3d9Interop ( this ) { // D3D9 doesn't enumerate adapters like physical adapters... // only as connected displays. @@ -20,6 +27,7 @@ namespace dxvk { // If we run out of adapters, then we'll just make repeats of the first one. // We can't match up by names on Linux/Wine as they don't match at all // like on Windows, so this is our best option. +#ifdef _WIN32 if (m_d3d9Options.enumerateByDisplays) { DISPLAY_DEVICEA device = { }; device.cb = sizeof(device); @@ -44,6 +52,7 @@ namespace dxvk { } } else +#endif { const uint32_t adapterCount = m_instance->adapterCount(); m_adapters.reserve(adapterCount); @@ -52,10 +61,17 @@ namespace dxvk { m_adapters.emplace_back(this, m_instance->enumAdapters(i), i, 0); } +#ifdef _WIN32 if (m_d3d9Options.dpiAware) { Logger::info("Process set as DPI aware"); SetProcessDPIAware(); } +#endif + } + + + D3D9InterfaceEx::~D3D9InterfaceEx() { + g_dxvkInstance.release(); } @@ -72,8 +88,21 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D9InterfaceEx::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (riid == __uuidof(IDxvkD3D8InterfaceBridge)) { + *ppvObject = ref(&m_d3d8Bridge); + return S_OK; + } + + if (riid == __uuidof(ID3D9VkInteropInterface)) { + *ppvObject = ref(&m_d3d9Interop); + return S_OK; + } + + if (logQueryInterfaceError(__uuidof(IDirect3D9), riid)) { + Logger::warn("D3D9InterfaceEx::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } diff --git a/src/d3d9/d3d9_interface.h b/src/d3d9/d3d9_interface.h index 85cc5a03..43046f73 100644 --- a/src/d3d9/d3d9_interface.h +++ b/src/d3d9/d3d9_interface.h @@ -1,6 +1,8 @@ #pragma once #include "d3d9_adapter.h" +#include "d3d9_bridge.h" +#include "d3d9_interop.h" #include "../dxvk/dxvk_instance.h" @@ -19,6 +21,8 @@ namespace dxvk { D3D9InterfaceEx(bool bExtended); + ~D3D9InterfaceEx(); + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject); HRESULT STDMETHODCALLTYPE RegisterSoftwareDevice(void* pInitializeFunction); @@ -137,12 +141,16 @@ namespace dxvk { Rc m_instance; + DxvkD3D8InterfaceBridge m_d3d8Bridge; + bool m_extended; D3D9Options m_d3d9Options; std::vector m_adapters; + D3D9VkInteropInterface m_d3d9Interop; + }; } \ No newline at end of file diff --git a/src/d3d9/d3d9_interfaces.h b/src/d3d9/d3d9_interfaces.h new file mode 100644 index 00000000..09fbcfa4 --- /dev/null +++ b/src/d3d9/d3d9_interfaces.h @@ -0,0 +1,242 @@ +#pragma once + +#include "d3d9_include.h" +#include "../vulkan/vulkan_loader.h" + +/** + * \brief D3D9 interface for Vulkan interop + * + * Provides access to the instance and physical device + * handles for the given D3D9 interface and adapter ordinals. + */ +MIDL_INTERFACE("3461a81b-ce41-485b-b6b5-fcf08ba6a6bd") +ID3D9VkInteropInterface : public IUnknown { + /** + * \brief Queries Vulkan handles used by DXVK + * + * \param [out] pInstance The Vulkan instance + */ + virtual void STDMETHODCALLTYPE GetInstanceHandle( + VkInstance* pInstance) = 0; + + /** + * \brief Queries Vulkan handles used by DXVK + * + * \param [in] Adapter Adapter ordinal + * \param [out] pInstance The Vulkan instance + */ + virtual void STDMETHODCALLTYPE GetPhysicalDeviceHandle( + UINT Adapter, + VkPhysicalDevice* pPhysicalDevice) = 0; +}; + +/** + * \brief D3D9 texture interface for Vulkan interop + * + * Provides access to the backing resource of a + * D3D9 texture. + */ +MIDL_INTERFACE("d56344f5-8d35-46fd-806d-94c351b472c1") +ID3D9VkInteropTexture : public IUnknown { + /** + * \brief Retrieves Vulkan image info + * + * Retrieves both the image handle as well as the image's + * properties. Any of the given pointers may be \c nullptr. + * + * If \c pInfo is not \c nullptr, the following rules apply: + * - \c pInfo->sType \e must be \c VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO + * - \c pInfo->pNext \e must be \c nullptr or point to a supported + * extension-specific structure (currently none) + * - \c pInfo->queueFamilyIndexCount must be the length of the + * \c pInfo->pQueueFamilyIndices array, in \c uint32_t units. + * - \c pInfo->pQueueFamilyIndices must point to a pre-allocated + * array of \c uint32_t of size \c pInfo->pQueueFamilyIndices. + * + * \note As of now, the sharing mode will always be + * \c VK_SHARING_MODE_EXCLUSIVE and no queue + * family indices will be written to the array. + * + * After the call, the structure pointed to by \c pInfo can + * be used to create an image with identical properties. + * + * If \c pLayout is not \c nullptr, it will receive the + * layout that the image will be in after flushing any + * outstanding commands on the device. + * \param [out] pHandle The image handle + * \param [out] pLayout Image layout + * \param [out] pInfo Image properties + * \returns \c S_OK on success, or \c D3DERR_INVALIDCALL + */ + virtual HRESULT STDMETHODCALLTYPE GetVulkanImageInfo( + VkImage* pHandle, + VkImageLayout* pLayout, + VkImageCreateInfo* pInfo) = 0; +}; + +/** + * \brief D3D9 device interface for Vulkan interop + * + * Provides access to the device and instance handles + * as well as the queue that is used for rendering. + */ +MIDL_INTERFACE("2eaa4b89-0107-4bdb-87f7-0f541c493ce0") +ID3D9VkInteropDevice : public IUnknown { + /** + * \brief Queries Vulkan handles used by DXVK + * + * \param [out] pInstance The Vulkan instance + * \param [out] pPhysDev The physical device + * \param [out] pDevide The device handle + */ + virtual void STDMETHODCALLTYPE GetVulkanHandles( + VkInstance* pInstance, + VkPhysicalDevice* pPhysDev, + VkDevice* pDevice) = 0; + + /** + * \brief Queries the rendering queue used by DXVK + * + * \param [out] pQueue The Vulkan queue handle + * \param [out] pQueueIndex Queue index + * \param [out] pQueueFamilyIndex Queue family index + */ + virtual void STDMETHODCALLTYPE GetSubmissionQueue( + VkQueue* pQueue, + uint32_t* pQueueIndex, + uint32_t* pQueueFamilyIndex) = 0; + + /** + * \brief Transitions a Texture to a given layout + * + * Executes an explicit image layout transition on the + * D3D device. Note that the image subresources \e must + * be transitioned back to its original layout before + * using it again from D3D9. + * Synchronization is left up to the caller. + * This function merely emits a call to transition the + * texture on the DXVK internal command stream. + * \param [in] pTexture The image to transform + * \param [in] pSubresources Subresources to transform + * \param [in] OldLayout Current image layout + * \param [in] NewLayout Desired image layout + */ + virtual void STDMETHODCALLTYPE TransitionTextureLayout( + ID3D9VkInteropTexture* pTexture, + const VkImageSubresourceRange* pSubresources, + VkImageLayout OldLayout, + VkImageLayout NewLayout) = 0; + + /** + * \brief Flushes outstanding D3D rendering commands + * + * Must be called before submitting Vulkan commands + * to the rendering queue if those commands use the + * backing resource of a D3D9 object. + */ + virtual void STDMETHODCALLTYPE FlushRenderingCommands() = 0; + + /** + * \brief Locks submission queue + * + * Should be called immediately before submitting + * Vulkan commands to the rendering queue in order + * to prevent DXVK from using the queue. + * + * While the submission queue is locked, no D3D9 + * methods must be called from the locking thread, + * or otherwise a deadlock might occur. + */ + virtual void STDMETHODCALLTYPE LockSubmissionQueue() = 0; + + /** + * \brief Releases submission queue + * + * Should be called immediately after submitting + * Vulkan commands to the rendering queue in order + * to allow DXVK to submit new commands. + */ + virtual void STDMETHODCALLTYPE ReleaseSubmissionQueue() = 0; + + /** + * \brief Locks the device + * + * Can be called to ensure no D3D9 device methods + * can be executed until UnlockDevice has been called. + * + * This will do nothing if the D3DCREATE_MULTITHREADED + * is not set. + */ + virtual void STDMETHODCALLTYPE LockDevice() = 0; + + /** + * \brief Unlocks the device + * + * Must only be called after a call to LockDevice. + */ + virtual void STDMETHODCALLTYPE UnlockDevice() = 0; + + /** + * \brief Wait for a resource to finish being used + * + * Waits for the GPU resource associated with the + * resource to finish being used by the GPU. + * + * Valid D3DLOCK flags: + * - D3DLOCK_READONLY: Only waits for writes + * - D3DLOCK_DONOTWAIT: Does not wait for the resource (may flush) + * + * \param [in] pResource Resource to be waited upon + * \param [in] MapFlags D3DLOCK flags + * \returns true if the resource is ready to use, + * false if the resource is till in use + */ + virtual bool STDMETHODCALLTYPE WaitForResource( + IDirect3DResource9* pResource, + DWORD MapFlags) = 0; +}; + +/** + * \brief D3D9 current output metadata + */ +struct D3D9VkExtOutputMetadata { + float RedPrimary[2]; + float GreenPrimary[2]; + float BluePrimary[2]; + float WhitePoint[2]; + float MinLuminance; + float MaxLuminance; + float MaxFullFrameLuminance; +}; + +/** + * \brief D3D9 extended swapchain + */ +MIDL_INTERFACE("13776e93-4aa9-430a-a4ec-fe9e281181d5") +ID3D9VkExtSwapchain : public IUnknown { + virtual BOOL STDMETHODCALLTYPE CheckColorSpaceSupport( + VkColorSpaceKHR ColorSpace) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetColorSpace( + VkColorSpaceKHR ColorSpace) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetHDRMetaData( + const VkHdrMetadataEXT *pHDRMetadata) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentOutputDesc( + D3D9VkExtOutputMetadata *pOutputDesc) = 0; + + virtual void STDMETHODCALLTYPE UnlockAdditionalFormats() = 0; +}; + +#ifdef _MSC_VER +struct __declspec(uuid("3461a81b-ce41-485b-b6b5-fcf08ba6a6bd")) ID3D9VkInteropInterface; +struct __declspec(uuid("d56344f5-8d35-46fd-806d-94c351b472c1")) ID3D9VkInteropTexture; +struct __declspec(uuid("2eaa4b89-0107-4bdb-87f7-0f541c493ce0")) ID3D9VkInteropDevice; +struct __declspec(uuid("13776e93-4aa9-430a-a4ec-fe9e281181d5")) ID3D9VkExtSwapchain; +#else +__CRT_UUID_DECL(ID3D9VkInteropInterface, 0x3461a81b,0xce41,0x485b,0xb6,0xb5,0xfc,0xf0,0x8b,0xa6,0xa6,0xbd); +__CRT_UUID_DECL(ID3D9VkInteropTexture, 0xd56344f5,0x8d35,0x46fd,0x80,0x6d,0x94,0xc3,0x51,0xb4,0x72,0xc1); +__CRT_UUID_DECL(ID3D9VkInteropDevice, 0x2eaa4b89,0x0107,0x4bdb,0x87,0xf7,0x0f,0x54,0x1c,0x49,0x3c,0xe0); +__CRT_UUID_DECL(ID3D9VkExtSwapchain, 0x13776e93,0x4aa9,0x430a,0xa4,0xec,0xfe,0x9e,0x28,0x11,0x81,0xd5); +#endif diff --git a/src/d3d9/d3d9_interop.cpp b/src/d3d9/d3d9_interop.cpp new file mode 100644 index 00000000..6f072f62 --- /dev/null +++ b/src/d3d9/d3d9_interop.cpp @@ -0,0 +1,242 @@ +#include "d3d9_interop.h" +#include "d3d9_interface.h" +#include "d3d9_common_texture.h" +#include "d3d9_device.h" +#include "d3d9_texture.h" +#include "d3d9_buffer.h" + +namespace dxvk { + + //////////////////////////////// + // Interface Interop + /////////////////////////////// + + D3D9VkInteropInterface::D3D9VkInteropInterface( + D3D9InterfaceEx* pInterface) + : m_interface(pInterface) { + + } + + D3D9VkInteropInterface::~D3D9VkInteropInterface() { + + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropInterface::AddRef() { + return m_interface->AddRef(); + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropInterface::Release() { + return m_interface->Release(); + } + + HRESULT STDMETHODCALLTYPE D3D9VkInteropInterface::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_interface->QueryInterface(riid, ppvObject); + } + + void STDMETHODCALLTYPE D3D9VkInteropInterface::GetInstanceHandle( + VkInstance* pInstance) { + if (pInstance != nullptr) + *pInstance = m_interface->GetInstance()->handle(); + } + + void STDMETHODCALLTYPE D3D9VkInteropInterface::GetPhysicalDeviceHandle( + UINT Adapter, + VkPhysicalDevice* pPhysicalDevice) { + if (pPhysicalDevice != nullptr) { + D3D9Adapter* adapter = m_interface->GetAdapter(Adapter); + *pPhysicalDevice = adapter ? adapter->GetDXVKAdapter()->handle() : nullptr; + } + } + + //////////////////////////////// + // Texture Interop + /////////////////////////////// + + D3D9VkInteropTexture::D3D9VkInteropTexture( + IUnknown* pInterface, + D3D9CommonTexture* pTexture) + : m_interface(pInterface) + , m_texture (pTexture) { + + } + + D3D9VkInteropTexture::~D3D9VkInteropTexture() { + + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropTexture::AddRef() { + return m_interface->AddRef(); + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropTexture::Release() { + return m_interface->Release(); + } + + HRESULT STDMETHODCALLTYPE D3D9VkInteropTexture::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_interface->QueryInterface(riid, ppvObject); + } + + HRESULT STDMETHODCALLTYPE D3D9VkInteropTexture::GetVulkanImageInfo( + VkImage* pHandle, + VkImageLayout* pLayout, + VkImageCreateInfo* pInfo) { + const Rc image = m_texture->GetImage(); + const DxvkImageCreateInfo& info = image->info(); + + if (pHandle != nullptr) + *pHandle = image->handle(); + + if (pLayout != nullptr) + *pLayout = info.layout; + + if (pInfo != nullptr) { + // We currently don't support any extended structures + if (pInfo->sType != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO + || pInfo->pNext != nullptr) + return D3DERR_INVALIDCALL; + + pInfo->flags = 0; + pInfo->imageType = info.type; + pInfo->format = info.format; + pInfo->extent = info.extent; + pInfo->mipLevels = info.mipLevels; + pInfo->arrayLayers = info.numLayers; + pInfo->samples = info.sampleCount; + pInfo->tiling = info.tiling; + pInfo->usage = info.usage; + pInfo->sharingMode = VK_SHARING_MODE_EXCLUSIVE; + pInfo->queueFamilyIndexCount = 0; + pInfo->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + } + + return S_OK; + } + + //////////////////////////////// + // Device Interop + /////////////////////////////// + + D3D9VkInteropDevice::D3D9VkInteropDevice( + D3D9DeviceEx* pInterface) + : m_device(pInterface) { + + } + + D3D9VkInteropDevice::~D3D9VkInteropDevice() { + + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropDevice::AddRef() { + return m_device->AddRef(); + } + + ULONG STDMETHODCALLTYPE D3D9VkInteropDevice::Release() { + return m_device->Release(); + } + + HRESULT STDMETHODCALLTYPE D3D9VkInteropDevice::QueryInterface( + REFIID riid, + void** ppvObject) { + return m_device->QueryInterface(riid, ppvObject); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::GetVulkanHandles( + VkInstance* pInstance, + VkPhysicalDevice* pPhysDev, + VkDevice* pDevice) { + auto device = m_device->GetDXVKDevice(); + auto adapter = device->adapter(); + auto instance = device->instance(); + + if (pDevice != nullptr) + *pDevice = device->handle(); + + if (pPhysDev != nullptr) + *pPhysDev = adapter->handle(); + + if (pInstance != nullptr) + *pInstance = instance->handle(); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::GetSubmissionQueue( + VkQueue* pQueue, + uint32_t* pQueueIndex, + uint32_t* pQueueFamilyIndex) { + auto device = m_device->GetDXVKDevice(); + DxvkDeviceQueue queue = device->queues().graphics; + + if (pQueue != nullptr) + *pQueue = queue.queueHandle; + + if (pQueueIndex != nullptr) + *pQueueIndex = queue.queueIndex; + + if (pQueueFamilyIndex != nullptr) + *pQueueFamilyIndex = queue.queueFamily; + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::TransitionTextureLayout( + ID3D9VkInteropTexture* pTexture, + const VkImageSubresourceRange* pSubresources, + VkImageLayout OldLayout, + VkImageLayout NewLayout) { + auto texture = static_cast(pTexture)->GetCommonTexture(); + + m_device->EmitCs([ + cImage = texture->GetImage(), + cSubresources = *pSubresources, + cOldLayout = OldLayout, + cNewLayout = NewLayout + ] (DxvkContext* ctx) { + ctx->transformImage( + cImage, cSubresources, + cOldLayout, cNewLayout); + }); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::FlushRenderingCommands() { + m_device->Flush(); + m_device->SynchronizeCsThread(DxvkCsThread::SynchronizeAll); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::LockSubmissionQueue() { + m_device->GetDXVKDevice()->lockSubmission(); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::ReleaseSubmissionQueue() { + m_device->GetDXVKDevice()->unlockSubmission(); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::LockDevice() { + m_lock = m_device->LockDevice(); + } + + void STDMETHODCALLTYPE D3D9VkInteropDevice::UnlockDevice() { + m_lock = D3D9DeviceLock(); + } + + static Rc GetDxvkResource(IDirect3DResource9 *pResource) { + switch (pResource->GetType()) { + case D3DRTYPE_SURFACE: return static_cast (pResource)->GetCommonTexture()->GetImage(); + // Does not inherit from IDirect3DResource9... lol. + //case D3DRTYPE_VOLUME: return static_cast (pResource)->GetCommonTexture()->GetImage(); + case D3DRTYPE_TEXTURE: return static_cast (pResource)->GetCommonTexture()->GetImage(); + case D3DRTYPE_VOLUMETEXTURE: return static_cast (pResource)->GetCommonTexture()->GetImage(); + case D3DRTYPE_CUBETEXTURE: return static_cast (pResource)->GetCommonTexture()->GetImage(); + case D3DRTYPE_VERTEXBUFFER: return static_cast(pResource)->GetCommonBuffer()->GetBuffer(); + case D3DRTYPE_INDEXBUFFER: return static_cast (pResource)->GetCommonBuffer()->GetBuffer(); + default: return nullptr; + } + } + + bool STDMETHODCALLTYPE D3D9VkInteropDevice::WaitForResource( + IDirect3DResource9* pResource, + DWORD MapFlags) { + return m_device->WaitForResource(GetDxvkResource(pResource), DxvkCsThread::SynchronizeAll, MapFlags); + } + +} diff --git a/src/d3d9/d3d9_interop.h b/src/d3d9/d3d9_interop.h new file mode 100644 index 00000000..742f69a9 --- /dev/null +++ b/src/d3d9/d3d9_interop.h @@ -0,0 +1,128 @@ +#pragma once + +#include "d3d9_interfaces.h" +#include "d3d9_multithread.h" + +namespace dxvk { + + class D3D9InterfaceEx; + class D3D9CommonTexture; + class D3D9DeviceEx; + + class D3D9VkInteropInterface final : public ID3D9VkInteropInterface { + + public: + + D3D9VkInteropInterface( + D3D9InterfaceEx* pInterface); + + ~D3D9VkInteropInterface(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + void STDMETHODCALLTYPE GetInstanceHandle( + VkInstance* pInstance); + + void STDMETHODCALLTYPE GetPhysicalDeviceHandle( + UINT Adapter, + VkPhysicalDevice* pPhysicalDevice); + + private: + + D3D9InterfaceEx* m_interface; + + }; + + class D3D9VkInteropTexture final : public ID3D9VkInteropTexture { + + public: + + D3D9VkInteropTexture( + IUnknown* pInterface, + D3D9CommonTexture* pTexture); + + ~D3D9VkInteropTexture(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + HRESULT STDMETHODCALLTYPE GetVulkanImageInfo( + VkImage* pHandle, + VkImageLayout* pLayout, + VkImageCreateInfo* pInfo); + + D3D9CommonTexture* GetCommonTexture() { return m_texture; } + + private: + + IUnknown* m_interface; + D3D9CommonTexture* m_texture; + + }; + + class D3D9VkInteropDevice final : public ID3D9VkInteropDevice { + + public: + + D3D9VkInteropDevice( + D3D9DeviceEx* pInterface); + + ~D3D9VkInteropDevice(); + + ULONG STDMETHODCALLTYPE AddRef(); + + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE QueryInterface( + REFIID riid, + void** ppvObject); + + void STDMETHODCALLTYPE GetVulkanHandles( + VkInstance* pInstance, + VkPhysicalDevice* pPhysDev, + VkDevice* pDevice); + + void STDMETHODCALLTYPE GetSubmissionQueue( + VkQueue* pQueue, + uint32_t* pQueueIndex, + uint32_t* pQueueFamilyIndex); + + void STDMETHODCALLTYPE TransitionTextureLayout( + ID3D9VkInteropTexture* pTexture, + const VkImageSubresourceRange* pSubresources, + VkImageLayout OldLayout, + VkImageLayout NewLayout); + + void STDMETHODCALLTYPE FlushRenderingCommands(); + + void STDMETHODCALLTYPE LockSubmissionQueue(); + + void STDMETHODCALLTYPE ReleaseSubmissionQueue(); + + void STDMETHODCALLTYPE LockDevice(); + + void STDMETHODCALLTYPE UnlockDevice(); + + bool STDMETHODCALLTYPE WaitForResource( + IDirect3DResource9* pResource, + DWORD MapFlags); + + private: + + D3D9DeviceEx* m_device; + D3D9DeviceLock m_lock; + + }; + +} diff --git a/src/d3d9/d3d9_main.cpp b/src/d3d9/d3d9_main.cpp index 367dac9c..9e7aaa24 100644 --- a/src/d3d9/d3d9_main.cpp +++ b/src/d3d9/d3d9_main.cpp @@ -98,4 +98,17 @@ extern "C" { dxvk::D3D9GlobalAnnotationList::Instance().UnregisterAnnotator(annotation); } + DLLEXPORT void __stdcall Direct3D9ForceHybridEnumeration(UINT uHybrid) { + } + + DLLEXPORT IDirect3D9* __stdcall Direct3DCreate9On12(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count) { + dxvk::Logger::warn("Direct3DCreate9On12: 9On12 functionality is unimplemented."); + return Direct3DCreate9(sdk_version); + } + + DLLEXPORT HRESULT __stdcall Direct3DCreate9On12Ex(UINT sdk_version, D3D9ON12_ARGS* override_list, UINT override_entry_count, IDirect3D9Ex** output) { + dxvk::Logger::warn("Direct3DCreate9On12Ex: 9On12 functionality is unimplemented."); + return Direct3DCreate9Ex(sdk_version, output); + } + } diff --git a/src/d3d9/d3d9_mem.cpp b/src/d3d9/d3d9_mem.cpp new file mode 100644 index 00000000..ec256246 --- /dev/null +++ b/src/d3d9/d3d9_mem.cpp @@ -0,0 +1,347 @@ +#include "d3d9_mem.h" +#include "../util/util_string.h" +#include "../util/util_math.h" +#include "../util/log/log.h" +#include "../util/util_likely.h" +#include + +#ifdef D3D9_ALLOW_UNMAPPING +#include +#else +#include +#endif + +namespace dxvk { + +#ifdef D3D9_ALLOW_UNMAPPING + D3D9MemoryAllocator::D3D9MemoryAllocator() { + SYSTEM_INFO sysInfo; + GetSystemInfo(&sysInfo); + m_allocationGranularity = sysInfo.dwAllocationGranularity; + } + + D3D9Memory D3D9MemoryAllocator::Alloc(uint32_t Size) { + std::lock_guard lock(m_mutex); + + uint32_t alignedSize = align(Size, CACHE_LINE_SIZE); + for (auto& chunk : m_chunks) { + D3D9Memory memory = chunk->Alloc(alignedSize); + if (memory) { + m_usedMemory += memory.GetSize(); + return memory; + } + } + + uint32_t chunkSize = std::max(D3D9ChunkSize, alignedSize); + m_allocatedMemory += chunkSize; + + D3D9MemoryChunk* chunk = new D3D9MemoryChunk(this, chunkSize); + std::unique_ptr uniqueChunk(chunk); + D3D9Memory memory = uniqueChunk->Alloc(alignedSize); + m_usedMemory += memory.GetSize(); + + m_chunks.push_back(std::move(uniqueChunk)); + return memory; + } + + void D3D9MemoryAllocator::FreeChunk(D3D9MemoryChunk *Chunk) { + std::lock_guard lock(m_mutex); + + m_allocatedMemory -= Chunk->Size(); + + m_chunks.erase(std::remove_if(m_chunks.begin(), m_chunks.end(), [&](auto& item) { + return item.get() == Chunk; + }), m_chunks.end()); + } + + void D3D9MemoryAllocator::NotifyMapped(uint32_t Size) { + m_mappedMemory += Size; + } + + void D3D9MemoryAllocator::NotifyUnmapped(uint32_t Size) { + m_mappedMemory -= Size; + } + + void D3D9MemoryAllocator::NotifyFreed(uint32_t Size) { + m_usedMemory -= Size; + } + + uint32_t D3D9MemoryAllocator::MappedMemory() { + return m_mappedMemory.load(); + } + + uint32_t D3D9MemoryAllocator::UsedMemory() { + return m_usedMemory.load(); + } + + uint32_t D3D9MemoryAllocator::AllocatedMemory() { + return m_allocatedMemory.load(); + } + + D3D9MemoryChunk::D3D9MemoryChunk(D3D9MemoryAllocator* Allocator, uint32_t Size) + : m_allocator(Allocator), m_size(Size), m_mappingGranularity(m_allocator->MemoryGranularity() * 16) { + m_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE | SEC_COMMIT, 0, Size, nullptr); + m_freeRanges.push_back({ 0, Size }); + m_mappingRanges.resize(((Size + m_mappingGranularity - 1) / m_mappingGranularity)); + } + + D3D9MemoryChunk::~D3D9MemoryChunk() { + std::lock_guard lock(m_mutex); + + CloseHandle(m_mapping); + } + + void* D3D9MemoryChunk::Map(D3D9Memory* memory) { + std::lock_guard lock(m_mutex); + + uint32_t alignedOffset = alignDown(memory->GetOffset(), m_mappingGranularity); + uint32_t alignmentDelta = memory->GetOffset() - alignedOffset; + uint32_t alignedSize = memory->GetSize() + alignmentDelta; + if (alignedSize > m_mappingGranularity) { + // The allocation crosses the boundary of the internal mapping page it's a part of + // so we map it on it's own. + alignedOffset = alignDown(memory->GetOffset(), m_allocator->MemoryGranularity()); + alignmentDelta = memory->GetOffset() - alignedOffset; + alignedSize = memory->GetSize() + alignmentDelta; + + m_allocator->NotifyMapped(alignedSize); + uint8_t* basePtr = static_cast(MapViewOfFile(m_mapping, FILE_MAP_ALL_ACCESS, 0, alignedOffset, alignedSize)); + if (unlikely(basePtr == nullptr)) { + DWORD error = GetLastError(); + Logger::err(str::format("Mapping non-persisted file failed: ", error, ", Mapped memory: ", m_allocator->MappedMemory())); + return nullptr; + } + return basePtr + alignmentDelta; + } + + // For small allocations we map the entire mapping page to minimize the overhead from having the align the offset to 65k bytes. + // This should hopefully also reduce the amount of MapViewOfFile calls we do for tiny allocations. + auto& mappingRange = m_mappingRanges[memory->GetOffset() / m_mappingGranularity]; + if (unlikely(mappingRange.refCount == 0)) { + m_allocator->NotifyMapped(m_mappingGranularity); + mappingRange.ptr = static_cast(MapViewOfFile(m_mapping, FILE_MAP_ALL_ACCESS, 0, alignedOffset, m_mappingGranularity)); + if (unlikely(mappingRange.ptr == nullptr)) { + DWORD error = GetLastError(); + LPTSTR buffer = nullptr; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), (LPTSTR)&buffer, 0, nullptr); + Logger::err(str::format("Mapping non-persisted file failed: ", error, ", Mapped memory: ", m_allocator->MappedMemory(), ", Msg: ", buffer)); + if (buffer) { + LocalFree(buffer); + } + } + } + mappingRange.refCount++; + uint8_t* basePtr = static_cast(mappingRange.ptr); + return basePtr + alignmentDelta; + } + + void D3D9MemoryChunk::Unmap(D3D9Memory* memory) { + std::lock_guard lock(m_mutex); + + uint32_t alignedOffset = alignDown(memory->GetOffset(), m_mappingGranularity); + uint32_t alignmentDelta = memory->GetOffset() - alignedOffset; + uint32_t alignedSize = memory->GetSize() + alignmentDelta; + if (alignedSize > m_mappingGranularity) { + // Single use mapping + alignedOffset = alignDown(memory->GetOffset(), m_allocator->MemoryGranularity()); + alignmentDelta = memory->GetOffset() - alignedOffset; + alignedSize = memory->GetSize() + alignmentDelta; + + uint8_t* basePtr = static_cast(memory->Ptr()) - alignmentDelta; + UnmapViewOfFile(basePtr); + m_allocator->NotifyUnmapped(alignedSize); + return; + } + auto& mappingRange = m_mappingRanges[memory->GetOffset() / m_mappingGranularity]; + mappingRange.refCount--; + if (unlikely(mappingRange.refCount == 0)) { + UnmapViewOfFile(mappingRange.ptr); + mappingRange.ptr = nullptr; + m_allocator->NotifyUnmapped(m_mappingGranularity); + } + } + + D3D9Memory D3D9MemoryChunk::Alloc(uint32_t Size) { + std::lock_guard lock(m_mutex); + + uint32_t offset = 0; + uint32_t size = 0; + + for (auto range = m_freeRanges.begin(); range != m_freeRanges.end(); range++) { + if (range->length >= Size) { + offset = range->offset; + size = Size; + range->offset += Size; + range->length -= Size; + if (range->length < (4 << 10)) { + size += range->length; + m_freeRanges.erase(range); + } + break; + } + } + + if (size != 0) + return D3D9Memory(this, offset, Size); + + return {}; + } + + void D3D9MemoryChunk::Free(D3D9Memory *Memory) { + std::lock_guard lock(m_mutex); + + uint32_t offset = Memory->GetOffset(); + uint32_t size = Memory->GetSize(); + + auto curr = m_freeRanges.begin(); + + // shamelessly stolen from dxvk_memory.cpp + while (curr != m_freeRanges.end()) { + if (curr->offset == offset + size) { + size += curr->length; + curr = m_freeRanges.erase(curr); + } else if (curr->offset + curr->length == offset) { + offset -= curr->length; + size += curr->length; + curr = m_freeRanges.erase(curr); + } else { + curr++; + } + } + + m_freeRanges.push_back({ offset, size }); + m_allocator->NotifyFreed(Memory->GetSize()); + } + + bool D3D9MemoryChunk::IsEmpty() { + std::lock_guard lock(m_mutex); + + return m_freeRanges.size() == 1 + && m_freeRanges[0].length == m_size; + } + + D3D9MemoryAllocator* D3D9MemoryChunk::Allocator() const { + return m_allocator; + } + + HANDLE D3D9MemoryChunk::FileHandle() const { + return m_mapping; + } + + + D3D9Memory::D3D9Memory(D3D9MemoryChunk* Chunk, size_t Offset, size_t Size) + : m_chunk(Chunk), m_offset(Offset), m_size(Size) {} + + D3D9Memory::D3D9Memory(D3D9Memory&& other) + : m_chunk(std::exchange(other.m_chunk, nullptr)), + m_ptr(std::exchange(other.m_ptr, nullptr)), + m_offset(std::exchange(other.m_offset, 0)), + m_size(std::exchange(other.m_size, 0)) {} + + D3D9Memory::~D3D9Memory() { + this->Free(); + } + + D3D9Memory& D3D9Memory::operator = (D3D9Memory&& other) { + this->Free(); + + m_chunk = std::exchange(other.m_chunk, nullptr); + m_ptr = std::exchange(other.m_ptr, nullptr); + m_offset = std::exchange(other.m_offset, 0); + m_size = std::exchange(other.m_size, 0); + return *this; + } + + void D3D9Memory::Free() { + if (unlikely(m_chunk == nullptr)) + return; + + if (m_ptr != nullptr) + Unmap(); + + m_chunk->Free(this); + if (m_chunk->IsEmpty()) { + D3D9MemoryAllocator* allocator = m_chunk->Allocator(); + allocator->FreeChunk(m_chunk); + } + m_chunk = nullptr; + } + + void D3D9Memory::Map() { + if (unlikely(m_ptr != nullptr)) + return; + + if (unlikely(m_chunk == nullptr)) + return; + + m_ptr = m_chunk->Map(this); + } + + void D3D9Memory::Unmap() { + if (unlikely(m_ptr == nullptr)) + return; + + m_chunk->Unmap(this); + m_ptr = nullptr; + } + + void* D3D9Memory::Ptr() { + return m_ptr; + } + +#else + + D3D9Memory D3D9MemoryAllocator::Alloc(uint32_t Size) { + D3D9Memory memory(this, Size); + m_allocatedMemory += Size; + return memory; + } + + uint32_t D3D9MemoryAllocator::MappedMemory() { + return m_allocatedMemory.load(); + } + + uint32_t D3D9MemoryAllocator::UsedMemory() { + return m_allocatedMemory.load(); + } + + uint32_t D3D9MemoryAllocator::AllocatedMemory() { + return m_allocatedMemory.load(); + } + + D3D9Memory::D3D9Memory(D3D9MemoryAllocator* pAllocator, size_t Size) + : m_allocator (pAllocator), + m_ptr (malloc(Size)), + m_size (Size) {} + + D3D9Memory::D3D9Memory(D3D9Memory&& other) + : m_allocator(std::exchange(other.m_allocator, nullptr)), + m_ptr(std::exchange(other.m_ptr, nullptr)), + m_size(std::exchange(other.m_size, 0)) {} + + D3D9Memory::~D3D9Memory() { + this->Free(); + } + + D3D9Memory& D3D9Memory::operator = (D3D9Memory&& other) { + this->Free(); + + m_allocator = std::exchange(other.m_allocator, nullptr); + m_ptr = std::exchange(other.m_ptr, nullptr); + m_size = std::exchange(other.m_size, 0); + return *this; + } + + void D3D9Memory::Free() { + if (m_ptr == nullptr) + return; + + free(m_ptr); + m_ptr = nullptr; + m_allocator->NotifyFreed(m_size); + } + + +#endif + +} diff --git a/src/d3d9/d3d9_mem.h b/src/d3d9/d3d9_mem.h new file mode 100644 index 00000000..1da86265 --- /dev/null +++ b/src/d3d9/d3d9_mem.h @@ -0,0 +1,176 @@ + +#pragma once + +#include "../util/thread.h" + +#if defined(_WIN32) && !defined(_WIN64) + #define D3D9_ALLOW_UNMAPPING +#endif + +#ifdef D3D9_ALLOW_UNMAPPING + #define WIN32_LEAN_AND_MEAN + #include +#endif + +#include + +namespace dxvk { + + class D3D9MemoryAllocator; + class D3D9Memory; + +#ifdef D3D9_ALLOW_UNMAPPING + + class D3D9MemoryChunk; + + constexpr uint32_t D3D9ChunkSize = 64 << 20; + + struct D3D9MemoryRange { + uint32_t offset; + uint32_t length; + }; + + struct D3D9MappingRange { + uint32_t refCount = 0; + void* ptr = nullptr; + }; + + class D3D9MemoryChunk { + friend D3D9MemoryAllocator; + + public: + ~D3D9MemoryChunk(); + + D3D9MemoryChunk (const D3D9MemoryChunk&) = delete; + D3D9MemoryChunk& operator = (const D3D9MemoryChunk&) = delete; + + D3D9MemoryChunk (D3D9MemoryChunk&& other) = delete; + D3D9MemoryChunk& operator = (D3D9MemoryChunk&& other) = delete; + + D3D9Memory Alloc(uint32_t Size); + void Free(D3D9Memory* Memory); + bool IsEmpty(); + uint32_t Size() const { return m_size; } + D3D9MemoryAllocator* Allocator() const; + HANDLE FileHandle() const; + void* Map(D3D9Memory* memory); + void Unmap(D3D9Memory* memory); + + private: + D3D9MemoryChunk(D3D9MemoryAllocator* Allocator, uint32_t Size); + + dxvk::mutex m_mutex; + D3D9MemoryAllocator* m_allocator; + HANDLE m_mapping; + uint32_t m_size; + uint32_t m_mappingGranularity; + std::vector m_freeRanges; + std::vector m_mappingRanges; + }; + + class D3D9Memory { + friend D3D9MemoryChunk; + + public: + D3D9Memory() {} + ~D3D9Memory(); + + D3D9Memory (const D3D9Memory&) = delete; + D3D9Memory& operator = (const D3D9Memory&) = delete; + + D3D9Memory (D3D9Memory&& other); + D3D9Memory& operator = (D3D9Memory&& other); + + operator bool() const { return m_chunk != nullptr; } + + void Map(); + void Unmap(); + void* Ptr(); + D3D9MemoryChunk* GetChunk() const { return m_chunk; } + size_t GetOffset() const { return m_offset; } + size_t GetSize() const { return m_size; } + + private: + D3D9Memory(D3D9MemoryChunk* Chunk, size_t Offset, size_t Size); + void Free(); + + D3D9MemoryChunk* m_chunk = nullptr; + void* m_ptr = nullptr; + size_t m_offset = 0; + size_t m_size = 0; + }; + + class D3D9MemoryAllocator { + friend D3D9MemoryChunk; + + public: + D3D9MemoryAllocator(); + ~D3D9MemoryAllocator() = default; + D3D9Memory Alloc(uint32_t Size); + void FreeChunk(D3D9MemoryChunk* Chunk); + void NotifyMapped(uint32_t Size); + void NotifyUnmapped(uint32_t Size); + void NotifyFreed(uint32_t Size); + uint32_t MappedMemory(); + uint32_t UsedMemory(); + uint32_t AllocatedMemory(); + uint32_t MemoryGranularity() { return m_allocationGranularity; } + + private: + dxvk::mutex m_mutex; + std::vector> m_chunks; + std::atomic m_mappedMemory = 0; + std::atomic m_allocatedMemory = 0; + std::atomic m_usedMemory = 0; + uint32_t m_allocationGranularity; + }; + +#else + class D3D9Memory { + friend D3D9MemoryAllocator; + + public: + D3D9Memory() {} + ~D3D9Memory(); + + D3D9Memory (const D3D9Memory&) = delete; + D3D9Memory& operator = (const D3D9Memory&) = delete; + + D3D9Memory (D3D9Memory&& other); + D3D9Memory& operator = (D3D9Memory&& other); + + operator bool() const { return m_ptr != nullptr; } + + void Map() {} + void Unmap() {} + void* Ptr() { return m_ptr; } + size_t GetSize() const { return m_size; } + + private: + D3D9Memory(D3D9MemoryAllocator* pAllocator, size_t Size); + void Free(); + + D3D9MemoryAllocator* m_allocator = nullptr; + void* m_ptr = nullptr; + size_t m_size = 0; + }; + + class D3D9MemoryAllocator { + + public: + D3D9Memory Alloc(uint32_t Size); + uint32_t MappedMemory(); + uint32_t UsedMemory(); + uint32_t AllocatedMemory(); + void NotifyFreed(uint32_t Size) { + m_allocatedMemory -= Size; + } + + private: + std::atomic m_allocatedMemory = 0; + + }; + +#endif + +} diff --git a/src/d3d9/d3d9_monitor.cpp b/src/d3d9/d3d9_monitor.cpp index 8a5656cd..294ccbd9 100644 --- a/src/d3d9/d3d9_monitor.cpp +++ b/src/d3d9/d3d9_monitor.cpp @@ -27,9 +27,10 @@ namespace dxvk { bool IsSupportedAdapterFormat( D3D9Format Format) { + // D3D9Format::X1R5G5B5 is unsupported by native drivers and some apps, + // such as the BGE SettingsApplication, rely on it not being exposed. return Format == D3D9Format::A2R10G10B10 || Format == D3D9Format::X8R8G8B8 - || Format == D3D9Format::X1R5G5B5 || Format == D3D9Format::R5G6B5; } @@ -42,8 +43,6 @@ namespace dxvk { return (AdapterFormat == D3D9Format::A2R10G10B10 && BackBufferFormat == D3D9Format::A2R10G10B10) || (AdapterFormat == D3D9Format::X8R8G8B8 && BackBufferFormat == D3D9Format::X8R8G8B8) || (AdapterFormat == D3D9Format::X8R8G8B8 && BackBufferFormat == D3D9Format::A8R8G8B8) || - (AdapterFormat == D3D9Format::X1R5G5B5 && BackBufferFormat == D3D9Format::X1R5G5B5) || - (AdapterFormat == D3D9Format::X1R5G5B5 && BackBufferFormat == D3D9Format::A1R5G5B5) || (AdapterFormat == D3D9Format::R5G6B5 && BackBufferFormat == D3D9Format::R5G6B5); } @@ -55,9 +54,8 @@ namespace dxvk { return BackBufferFormat == D3D9Format::A2R10G10B10 || BackBufferFormat == D3D9Format::A8R8G8B8 || BackBufferFormat == D3D9Format::X8R8G8B8 - || BackBufferFormat == D3D9Format::A1R5G5B5 - || BackBufferFormat == D3D9Format::X1R5G5B5 - || BackBufferFormat == D3D9Format::R5G6B5; + || BackBufferFormat == D3D9Format::R5G6B5 + || BackBufferFormat == D3D9Format::Unknown; } } diff --git a/src/d3d9/d3d9_monitor.h b/src/d3d9/d3d9_monitor.h index 0a9d1a89..b3e7a7b7 100644 --- a/src/d3d9/d3d9_monitor.h +++ b/src/d3d9/d3d9_monitor.h @@ -4,6 +4,9 @@ #include "d3d9_format.h" +#include "../wsi/wsi_window.h" +#include "../wsi/wsi_monitor.h" + namespace dxvk { /** @@ -32,4 +35,27 @@ namespace dxvk { bool IsSupportedBackBufferFormat( D3D9Format BackBufferFormat); + + inline wsi::WsiMode ConvertDisplayMode(const D3DDISPLAYMODEEX& mode) { + wsi::WsiMode wsiMode = { }; + wsiMode.width = mode.Width; + wsiMode.height = mode.Height; + wsiMode.refreshRate = wsi::WsiRational{ mode.RefreshRate, 1 }; + wsiMode.bitsPerPixel = GetMonitorFormatBpp(EnumerateFormat(mode.Format)); + wsiMode.interlaced = mode.ScanLineOrdering == D3DSCANLINEORDERING_INTERLACED; + return wsiMode; + } + + + inline D3DDISPLAYMODEEX ConvertDisplayMode(const wsi::WsiMode& wsiMode) { + D3DDISPLAYMODEEX d3d9Mode = { }; + d3d9Mode.Size = sizeof(D3DDISPLAYMODEEX); + d3d9Mode.Width = wsiMode.width; + d3d9Mode.Height = wsiMode.height; + d3d9Mode.RefreshRate = wsiMode.refreshRate.numerator / wsiMode.refreshRate.denominator; + d3d9Mode.Format = D3DFMT_X8R8G8B8; + d3d9Mode.ScanLineOrdering = wsiMode.interlaced ? D3DSCANLINEORDERING_INTERLACED : D3DSCANLINEORDERING_PROGRESSIVE; + return d3d9Mode; + } + } diff --git a/src/d3d9/d3d9_on_12.cpp b/src/d3d9/d3d9_on_12.cpp new file mode 100644 index 00000000..38885894 --- /dev/null +++ b/src/d3d9/d3d9_on_12.cpp @@ -0,0 +1,37 @@ +#include "d3d9_on_12.h" + +#include "d3d9_device.h" + +namespace dxvk { + + D3D9On12::D3D9On12(D3D9DeviceEx* device) + : m_device(device) { + + } + + HRESULT STDMETHODCALLTYPE D3D9On12::QueryInterface(REFIID riid, void** object) { + return m_device->QueryInterface(riid, object); + } + ULONG STDMETHODCALLTYPE D3D9On12::AddRef() { + return m_device->AddRef(); + } + ULONG STDMETHODCALLTYPE D3D9On12::Release() { + return m_device->Release(); + } + + HRESULT STDMETHODCALLTYPE D3D9On12::GetD3D12Device(REFIID riid, void** object) { + InitReturnPtr(object); + + Logger::err("D3D9On12::GetD3D12Device: Stub"); + return E_NOINTERFACE; + } + HRESULT STDMETHODCALLTYPE D3D9On12::UnwrapUnderlyingResource(IDirect3DResource9* resource, ID3D12CommandQueue* command_queue, REFIID riid, void** object) { + Logger::err("D3D9On12::GetD3D12Device: UnwrapUnderlyingResource: Stub"); + return E_NOINTERFACE; + } + HRESULT STDMETHODCALLTYPE D3D9On12::ReturnUnderlyingResource(IDirect3DResource9* resource, UINT num_sync, UINT64* signal_values, ID3D12Fence** fences) { + Logger::err("D3D9On12::GetD3D12Device: ReturnUnderlyingResource: Stub"); + return E_NOINTERFACE; + } + +} diff --git a/src/d3d9/d3d9_on_12.h b/src/d3d9/d3d9_on_12.h new file mode 100644 index 00000000..7af5c987 --- /dev/null +++ b/src/d3d9/d3d9_on_12.h @@ -0,0 +1,29 @@ +#pragma once + +#include "d3d9_include.h" + +namespace dxvk { + + class D3D9DeviceEx; + + class D3D9On12 final : public IDirect3DDevice9On12 { + + public: + + D3D9On12(D3D9DeviceEx* device); + + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** object); + ULONG STDMETHODCALLTYPE AddRef(); + ULONG STDMETHODCALLTYPE Release(); + + HRESULT STDMETHODCALLTYPE GetD3D12Device(REFIID riid, void** object); + HRESULT STDMETHODCALLTYPE UnwrapUnderlyingResource(IDirect3DResource9* resource, ID3D12CommandQueue* command_queue, REFIID riid, void** object); + HRESULT STDMETHODCALLTYPE ReturnUnderlyingResource(IDirect3DResource9* resource, UINT num_sync, UINT64* signal_values, ID3D12Fence** fences); + + private: + + D3D9DeviceEx* m_device; + + }; + +} diff --git a/src/d3d9/d3d9_options.cpp b/src/d3d9/d3d9_options.cpp index 6a4ff4d3..190ca29b 100644 --- a/src/d3d9/d3d9_options.cpp +++ b/src/d3d9/d3d9_options.cpp @@ -1,3 +1,5 @@ +#include "../util/util_math.h" + #include "d3d9_options.h" #include "d3d9_caps.h" @@ -43,19 +45,18 @@ namespace dxvk { this->maxFrameRate = config.getOption ("d3d9.maxFrameRate", 0); this->presentInterval = config.getOption ("d3d9.presentInterval", -1); this->shaderModel = config.getOption ("d3d9.shaderModel", 3); - this->evictManagedOnUnlock = config.getOption ("d3d9.evictManagedOnUnlock", false); this->dpiAware = config.getOption ("d3d9.dpiAware", true); this->strictConstantCopies = config.getOption ("d3d9.strictConstantCopies", false); this->strictPow = config.getOption ("d3d9.strictPow", true); this->lenientClear = config.getOption ("d3d9.lenientClear", false); this->numBackBuffers = config.getOption ("d3d9.numBackBuffers", 0); - this->noExplicitFrontBuffer = config.getOption ("d3d9.noExplicitFrontBuffer", false); this->deferSurfaceCreation = config.getOption ("d3d9.deferSurfaceCreation", false); this->samplerAnisotropy = config.getOption ("d3d9.samplerAnisotropy", -1); this->maxAvailableMemory = config.getOption ("d3d9.maxAvailableMemory", 4096); this->supportDFFormats = config.getOption ("d3d9.supportDFFormats", true); this->supportX4R4G4B4 = config.getOption ("d3d9.supportX4R4G4B4", true); this->supportD32 = config.getOption ("d3d9.supportD32", true); + this->useD32forD24 = config.getOption ("d3d9.useD32forD24", false); this->disableA8RT = config.getOption ("d3d9.disableA8RT", false); this->invariantPosition = config.getOption ("d3d9.invariantPosition", true); this->memoryTrackTest = config.getOption ("d3d9.memoryTrackTest", false); @@ -63,24 +64,21 @@ namespace dxvk { this->enableDialogMode = config.getOption ("d3d9.enableDialogMode", false); this->forceSamplerTypeSpecConstants = config.getOption ("d3d9.forceSamplerTypeSpecConstants", false); this->forceSwapchainMSAA = config.getOption ("d3d9.forceSwapchainMSAA", -1); + this->forceSampleRateShading = config.getOption ("d3d9.forceSampleRateShading", false); this->forceAspectRatio = config.getOption ("d3d9.forceAspectRatio", ""); - this->allowDoNotWait = config.getOption ("d3d9.allowDoNotWait", true); - this->allowDiscard = config.getOption ("d3d9.allowDiscard", true); this->enumerateByDisplays = config.getOption ("d3d9.enumerateByDisplays", true); this->longMad = config.getOption ("d3d9.longMad", false); - this->tearFree = config.getOption ("d3d9.tearFree", Tristate::Auto); - this->alphaTestWiggleRoom = config.getOption ("d3d9.alphaTestWiggleRoom", false); - this->apitraceMode = config.getOption ("d3d9.apitraceMode", false); + this->cachedDynamicBuffers = config.getOption ("d3d9.cachedDynamicBuffers", false); this->deviceLocalConstantBuffers = config.getOption ("d3d9.deviceLocalConstantBuffers", false); this->allowDirectBufferMapping = config.getOption ("d3d9.allowDirectBufferMapping", true); + this->seamlessCubes = config.getOption ("d3d9.seamlessCubes", false); + this->textureMemory = config.getOption ("d3d9.textureMemory", 100) << 20; + this->deviceLossOnFocusLoss = config.getOption ("d3d9.deviceLossOnFocusLoss", false); + this->samplerLodBias = config.getOption ("d3d9.samplerLodBias", 0.0f); + this->clampNegativeLodBias = config.getOption ("d3d9.clampNegativeLodBias", false); - // If we are not Nvidia, enable general hazards. - this->generalHazards = adapter != nullptr - && !adapter->matchesDriver( - DxvkGpuVendor::Nvidia, - VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR, - 0, 0); - applyTristate(this->generalHazards, config.getOption("d3d9.generalHazards", Tristate::Auto)); + // Clamp LOD bias so that people don't abuse this in unintended ways + this->samplerLodBias = dxvk::fclamp(this->samplerLodBias, -2.0f, 1.0f); std::string floatEmulation = Config::toLower(config.getOption("d3d9.floatEmulation", "auto")); if (floatEmulation == "strict") { @@ -91,12 +89,12 @@ namespace dxvk { d3d9FloatEmulation = D3D9FloatEmulation::Enabled; } else { bool hasMulz = adapter != nullptr - && adapter->matchesDriver(DxvkGpuVendor::Amd, - VK_DRIVER_ID_MESA_RADV, - VK_MAKE_VERSION(21, 99, 99), - 0); + && (adapter->matchesDriver(VK_DRIVER_ID_MESA_RADV, 0, 0) + || adapter->matchesDriver(VK_DRIVER_ID_MESA_NVK, 0, 0)); d3d9FloatEmulation = hasMulz ? D3D9FloatEmulation::Strict : D3D9FloatEmulation::Enabled; } + + this->shaderDumpPath = env::getEnvVar("DXVK_SHADER_DUMP_PATH"); } } \ No newline at end of file diff --git a/src/d3d9/d3d9_options.h b/src/d3d9/d3d9_options.h index 029fe54e..f5b1fce4 100644 --- a/src/d3d9/d3d9_options.h +++ b/src/d3d9/d3d9_options.h @@ -36,9 +36,6 @@ namespace dxvk { /// Set the max shader model the device can support in the caps. int32_t shaderModel; - /// Whether or not managed resources should stay in memory until unlock, or until manually evicted. - bool evictManagedOnUnlock; - /// Whether or not to set the process as DPI aware in Windows when the API interface is created. bool dpiAware; @@ -57,23 +54,9 @@ namespace dxvk { /// Overrides buffer count in present parameters. int32_t numBackBuffers; - /// Don't create an explicit front buffer in our own swapchain. The Vulkan swapchain is unaffected. - /// Some games don't handle front/backbuffer flipping very well because they don't always redraw - /// each frame completely, and rely on old pixel data from the previous frame to still be there. - /// When this option is set and a game only requests one backbuffer, there will be no flipping in - /// our own swapchain, so the game will always draw to the same buffer and can rely on old pixel - /// data to still be there after a Present call. - /// This means that D3D9SwapChainEx::GetFrontBufferData returns data from the backbuffer of the - /// previous frame, which is the same as the current backbuffer if only 1 backbuffer was requested. - bool noExplicitFrontBuffer; - /// Defer surface creation bool deferSurfaceCreation; - /// Whether to transition to general - /// for rendering hazards - bool generalHazards; - /// Anisotropic filter override /// /// Enforces anisotropic filtering with the @@ -98,6 +81,9 @@ namespace dxvk { /// Support D32 bool supportD32; + /// Use D32f for D24 + bool useD32forD24; + /// Disable D3DFMT_A8 for render targets. /// Specifically to work around a game /// bug in The Sims 2 that happens on native too! @@ -127,11 +113,8 @@ namespace dxvk { /// Forces an MSAA level on the swapchain int32_t forceSwapchainMSAA; - /// Allow D3DLOCK_DONOTWAIT - bool allowDoNotWait; - - /// Allow D3DLOCK_DISCARD - bool allowDiscard; + /// Forces sample rate shading + bool forceSampleRateShading; /// Enumerate adapters by displays bool enumerateByDisplays; @@ -141,22 +124,34 @@ namespace dxvk { /// don't match entirely to the regular vertex shader in this way. bool longMad; - /// Tear-free mode if vsync is disabled - /// Tearing mode if vsync is enabled - Tristate tearFree; - - /// Workaround for games using alpha test == 1.0, etc due to wonky interpolation or - /// misc. imprecision on some vendors - bool alphaTestWiggleRoom; - - /// Apitrace mode: Maps all buffers in cached memory. - bool apitraceMode; + /// Cached dynamic buffers: Maps all buffers in cached memory. + bool cachedDynamicBuffers; /// Use device local memory for constant buffers. bool deviceLocalConstantBuffers; /// Disable direct buffer mapping bool allowDirectBufferMapping; + + /// Don't use non seamless cube maps + bool seamlessCubes; + + /// Mipmap LOD bias + /// + /// Enforces the given LOD bias for all samplers. + float samplerLodBias; + + /// Clamps negative LOD bias + bool clampNegativeLodBias; + + /// How much virtual memory will be used for textures (in MB). + int32_t textureMemory; + + /// Shader dump path + std::string shaderDumpPath; + + /// Enable emulation of device loss when a fullscreen app loses focus + bool deviceLossOnFocusLoss; }; } diff --git a/src/d3d9/d3d9_query.cpp b/src/d3d9/d3d9_query.cpp index 7ce47cf9..5eebdb0d 100644 --- a/src/d3d9/d3d9_query.cpp +++ b/src/d3d9/d3d9_query.cpp @@ -64,8 +64,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D9Query::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(IDirect3DQuery9), riid)) { + Logger::warn("D3D9Query::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -101,8 +104,10 @@ namespace dxvk { if (dwIssueFlags == D3DISSUE_BEGIN) { if (QueryBeginnable(m_queryType)) { - if (m_state == D3D9_VK_QUERY_BEGUN && QueryEndable(m_queryType)) + if (m_state == D3D9_VK_QUERY_BEGUN && QueryEndable(m_queryType)) { + m_resetCtr.fetch_add(1, std::memory_order_acquire); m_parent->End(this); + } m_parent->Begin(this); @@ -127,6 +132,14 @@ namespace dxvk { HRESULT STDMETHODCALLTYPE D3D9Query::GetData(void* pData, DWORD dwSize, DWORD dwGetDataFlags) { + D3D9DeviceLock lock = m_parent->LockDevice(); + + bool flush = dwGetDataFlags & D3DGETDATA_FLUSH; + + if (unlikely(m_parent->IsDeviceLost())) { + return flush ? D3DERR_DEVICELOST : S_FALSE; + } + if (m_state == D3D9_VK_QUERY_CACHED) { // Query data was already retrieved once. // Use cached query data to prevent having to check the VK event @@ -143,13 +156,11 @@ namespace dxvk { HRESULT hr = this->GetQueryData(pData, dwSize); - bool flush = dwGetDataFlags & D3DGETDATA_FLUSH; - // If we get S_FALSE and it's not from the fact // they didn't call end, do some flushy stuff... if (flush && hr == S_FALSE && m_state != D3D9_VK_QUERY_BEGUN) { this->NotifyStall(); - m_parent->FlushImplicit(FALSE); + m_parent->ConsiderFlush(GpuFlushType::ImplicitSynchronization); } return hr; diff --git a/src/d3d9/d3d9_shader.cpp b/src/d3d9/d3d9_shader.cpp index 8b5bb8bd..a62ceee1 100644 --- a/src/d3d9/d3d9_shader.cpp +++ b/src/d3d9/d3d9_shader.cpp @@ -17,21 +17,19 @@ namespace dxvk { const DxsoAnalysisInfo& AnalysisInfo, DxsoModule* pModule) { const uint32_t bytecodeLength = AnalysisInfo.bytecodeByteLength; - m_bytecode.resize(bytecodeLength); - std::memcpy(m_bytecode.data(), pShaderBytecode, bytecodeLength); const std::string name = Key.toString(); Logger::debug(str::format("Compiling shader ", name)); // If requested by the user, dump both the raw DXBC // shader and the compiled SPIR-V module to a file. - const std::string dumpPath = env::getEnvVar("DXVK_SHADER_DUMP_PATH"); + const std::string& dumpPath = pDevice->GetOptions()->shaderDumpPath; if (dumpPath.size() != 0) { DxsoReader reader( reinterpret_cast(pShaderBytecode)); - reader.store(std::ofstream(str::tows(str::format(dumpPath, "/", name, ".dxso").c_str()).c_str(), + reader.store(std::ofstream(str::topath(str::format(dumpPath, "/", name, ".dxso").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc), bytecodeLength); char comment[2048]; @@ -43,7 +41,7 @@ namespace dxvk { &blob); if (SUCCEEDED(hr)) { - std::ofstream disassembledOut(str::tows(str::format(dumpPath, "/", name, ".dxso.dis").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc); + std::ofstream disassembledOut(str::topath(str::format(dumpPath, "/", name, ".dxso.dis").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc); disassembledOut.write( reinterpret_cast(blob->GetBufferPointer()), blob->GetBufferSize()); @@ -56,7 +54,7 @@ namespace dxvk { const D3D9ConstantLayout& constantLayout = ShaderStage == VK_SHADER_STAGE_VERTEX_BIT ? pDevice->GetVertexConstantLayout() : pDevice->GetPixelConstantLayout(); - m_shaders = pModule->compile(*pDxsoModuleInfo, name, AnalysisInfo, constantLayout); + m_shader = pModule->compile(*pDxsoModuleInfo, name, AnalysisInfo, constantLayout); m_isgn = pModule->isgn(); m_usedSamplers = pModule->usedSamplers(); @@ -73,31 +71,24 @@ namespace dxvk { m_constants = pModule->constants(); m_maxDefinedConst = pModule->maxDefinedConstant(); - m_shaders[0]->setShaderKey(Key); + m_shader->setShaderKey(Key); - if (m_shaders[1] != nullptr) { - // Lets lie about the shader key type for the state cache. - m_shaders[1]->setShaderKey({ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, Key.sha1() }); - } - if (dumpPath.size() != 0) { std::ofstream dumpStream( - str::tows(str::format(dumpPath, "/", name, ".spv").c_str()).c_str(), + str::topath(str::format(dumpPath, "/", name, ".spv").c_str()).c_str(), std::ios_base::binary | std::ios_base::trunc); - m_shaders[0]->dump(dumpStream); + m_shader->dump(dumpStream); } - pDevice->GetDXVKDevice()->registerShader(m_shaders[0]); - - if (m_shaders[1] != nullptr) - pDevice->GetDXVKDevice()->registerShader(m_shaders[1]); + pDevice->GetDXVKDevice()->registerShader(m_shader); } void D3D9ShaderModuleSet::GetShaderModule( D3D9DeviceEx* pDevice, D3D9CommonShader* pShaderModule, + uint32_t* pLength, VkShaderStageFlagBits ShaderStage, const DxsoModuleInfo* pDxbcModuleInfo, const void* pShaderBytecode) { @@ -113,6 +104,7 @@ namespace dxvk { throw DxvkError("GetShaderModule: Bytecode does not match shader stage"); DxsoAnalysisInfo info = module.analyze(); + *pLength = info.bytecodeByteLength; DxvkShaderKey lookupKey = DxvkShaderKey( ShaderStage, diff --git a/src/d3d9/d3d9_shader.h b/src/d3d9/d3d9_shader.h index d896f019..564c881a 100644 --- a/src/d3d9/d3d9_shader.h +++ b/src/d3d9/d3d9_shader.h @@ -2,8 +2,8 @@ #include "d3d9_resource.h" #include "../dxso/dxso_module.h" -#include "d3d9_shader_permutations.h" #include "d3d9_util.h" +#include "d3d9_mem.h" #include @@ -33,16 +33,12 @@ namespace dxvk { DxsoModule* pModule); - Rc GetShader(D3D9ShaderPermutation Permutation) const { - return m_shaders[Permutation]; + Rc GetShader() const { + return m_shader; } std::string GetName() const { - return m_shaders[D3D9ShaderPermutations::None]->debugName(); - } - - const std::vector& GetBytecode() const { - return m_bytecode; + return m_shader->debugName(); } const DxsoIsgn& GetIsgn() const { @@ -69,9 +65,7 @@ namespace dxvk { DxsoDefinedConstants m_constants; uint32_t m_maxDefinedConst; - DxsoPermutations m_shaders; - - std::vector m_bytecode; + Rc m_shader; }; @@ -88,10 +82,20 @@ namespace dxvk { public: D3D9Shader( - D3D9DeviceEx* pDevice, - const D3D9CommonShader& CommonShader) + D3D9DeviceEx* pDevice, + D3D9MemoryAllocator* pAllocator, + const D3D9CommonShader& CommonShader, + const void* pShaderBytecode, + uint32_t BytecodeLength) : D3D9DeviceChild( pDevice ) - , m_shader ( CommonShader ) { } + , m_shader ( CommonShader ) + , m_bytecodeLength ( BytecodeLength ) { + + m_bytecode = pAllocator->Alloc(BytecodeLength); + m_bytecode.Map(); + std::memcpy(m_bytecode.Ptr(), pShaderBytecode, BytecodeLength); + m_bytecode.Unmap(); + } HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) { if (ppvObject == nullptr) @@ -105,8 +109,11 @@ namespace dxvk { return S_OK; } - Logger::warn("D3D9Shader::QueryInterface: Unknown interface query"); - Logger::warn(str::format(riid)); + if (logQueryInterfaceError(__uuidof(Base), riid)) { + Logger::warn("D3D9Shader::QueryInterface: Unknown interface query"); + Logger::warn(str::format(riid)); + } + return E_NOINTERFACE; } @@ -114,15 +121,15 @@ namespace dxvk { if (pSizeOfData == nullptr) return D3DERR_INVALIDCALL; - const auto& bytecode = m_shader.GetBytecode(); - if (pOut == nullptr) { - *pSizeOfData = bytecode.size(); + *pSizeOfData = m_bytecodeLength; return D3D_OK; } - size_t copyAmount = std::min(size_t(*pSizeOfData), bytecode.size()); - std::memcpy(pOut, bytecode.data(), copyAmount); + m_bytecode.Map(); + uint32_t copyAmount = std::min(*pSizeOfData, m_bytecodeLength); + std::memcpy(pOut, m_bytecode.Ptr(), copyAmount); + m_bytecode.Unmap(); return D3D_OK; } @@ -135,6 +142,9 @@ namespace dxvk { D3D9CommonShader m_shader; + D3D9Memory m_bytecode; + uint32_t m_bytecodeLength; + }; // Needs their own classes and not usings for forward decl. @@ -144,9 +154,12 @@ namespace dxvk { public: D3D9VertexShader( - D3D9DeviceEx* pDevice, - const D3D9CommonShader& CommonShader) - : D3D9Shader( pDevice, CommonShader ) { } + D3D9DeviceEx* pDevice, + D3D9MemoryAllocator* pAllocator, + const D3D9CommonShader& CommonShader, + const void* pShaderBytecode, + uint32_t BytecodeLength) + : D3D9Shader( pDevice, pAllocator, CommonShader, pShaderBytecode, BytecodeLength ) { } }; @@ -155,9 +168,12 @@ namespace dxvk { public: D3D9PixelShader( - D3D9DeviceEx* pDevice, - const D3D9CommonShader& CommonShader) - : D3D9Shader( pDevice, CommonShader ) { } + D3D9DeviceEx* pDevice, + D3D9MemoryAllocator* pAllocator, + const D3D9CommonShader& CommonShader, + const void* pShaderBytecode, + uint32_t BytecodeLength) + : D3D9Shader( pDevice, pAllocator, CommonShader, pShaderBytecode, BytecodeLength ) { } }; @@ -176,6 +192,7 @@ namespace dxvk { void GetShaderModule( D3D9DeviceEx* pDevice, D3D9CommonShader* pShaderModule, + uint32_t* pLength, VkShaderStageFlagBits ShaderStage, const DxsoModuleInfo* pDxbcModuleInfo, const void* pShaderBytecode); diff --git a/src/d3d9/d3d9_shader_permutations.h b/src/d3d9/d3d9_shader_permutations.h deleted file mode 100644 index cf2301d2..00000000 --- a/src/d3d9/d3d9_shader_permutations.h +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -#include "d3d9_include.h" - -namespace dxvk { - - class DxvkShader; - - namespace D3D9ShaderPermutations { - enum D3D9ShaderPermutation { - None, - FlatShade, - Count - }; - } - using D3D9ShaderPermutation = D3D9ShaderPermutations::D3D9ShaderPermutation; - - using DxsoPermutations = std::array, D3D9ShaderPermutations::Count>; - -} \ No newline at end of file diff --git a/src/d3d9/d3d9_spec_constants.h b/src/d3d9/d3d9_spec_constants.h index 7a8a33d5..4ecf710c 100644 --- a/src/d3d9/d3d9_spec_constants.h +++ b/src/d3d9/d3d9_spec_constants.h @@ -1,24 +1,155 @@ #pragma once +#include + #include +#include "../spirv/spirv_module.h" + +class D3D9DeviceEx; + namespace dxvk { enum D3D9SpecConstantId : uint32_t { - AlphaCompareOp = 0, - SamplerType = 1, - FogEnabled = 2, - VertexFogMode = 3, - PixelFogMode = 4, + SpecSamplerType, // 2 bits for 16 PS samplers | Bits: 32 - PointMode = 5, - ProjectionType = 6, + SpecSamplerDepthMode, // 1 bit for 21 VS + PS samplers | Bits: 21 + SpecAlphaCompareOp, // Range: 0 -> 7 | Bits: 3 + SpecPointMode, // Range: 0 -> 3 | Bits: 2 + SpecVertexFogMode, // Range: 0 -> 3 | Bits: 2 + SpecPixelFogMode, // Range: 0 -> 3 | Bits: 2 + SpecFogEnabled, // Range: 0 -> 1 | Bits: 1 - VertexShaderBools = 7, - PixelShaderBools = 8, - Fetch4 = 9, + SpecSamplerNull, // 1 bit for 21 samplers | Bits: 21 + SpecProjectionType, // 1 bit for 6 PS 1.x samplers | Bits: 6 + SpecAlphaPrecisionBits, // Range: 0 -> 8 or 0xF | Bits: 4 - SamplerDepthMode = 10, + SpecVertexShaderBools, // 16 bools | Bits: 16 + SpecPixelShaderBools, // 16 bools | Bits: 16 + + SpecDrefClamp, // 1 bit for 16 PS samplers | Bits: 16 + SpecFetch4, // 1 bit for 16 PS samplers | Bits: 16 + + SpecConstantCount, + }; + + struct BitfieldPosition { + constexpr uint32_t mask() const { + return uint32_t((1ull << sizeInBits) - 1) << bitOffset; + } + + uint32_t dwordOffset; + uint32_t bitOffset; + uint32_t sizeInBits; + }; + + struct D3D9SpecializationInfo { + static constexpr uint32_t MaxSpecDwords = 5; + + static constexpr std::array Layout{{ + { 0, 0, 32 }, // SamplerType + + { 1, 0, 21 }, // SamplerDepthMode + { 1, 21, 3 }, // AlphaCompareOp + { 1, 24, 2 }, // PointMode + { 1, 26, 2 }, // VertexFogMode + { 1, 28, 2 }, // PixelFogMode + { 1, 30, 1 }, // FogEnabled + + { 2, 0, 21 }, // SamplerNull + { 2, 21, 6 }, // ProjectionType + { 2, 27, 4 }, // AlphaPrecisionBits + + { 3, 0, 16 }, // VertexShaderBools + { 3, 16, 16 }, // PixelShaderBools + + { 4, 0, 16 }, // DrefClamp + { 4, 16, 16 }, // Fetch4 + }}; + + template + bool set(const T& value) { + const uint32_t x = uint32_t(value); + if (get() == x) + return false; + + constexpr auto& layout = Layout[Id]; + + data[layout.dwordOffset] &= ~layout.mask(); + data[layout.dwordOffset] |= (x << layout.bitOffset) & layout.mask(); + + return true; + } + + template + uint32_t get() const { + constexpr auto& layout = Layout[Id]; + + return (data[layout.dwordOffset] & layout.mask()) >> layout.bitOffset; + } + + std::array data = {}; + }; + + class D3D9ShaderSpecConstantManager { + public: + uint32_t get(SpirvModule &module, uint32_t specUbo, D3D9SpecConstantId id) { + return get(module, specUbo, id, 0, 32); + } + + uint32_t get(SpirvModule &module, uint32_t specUbo, D3D9SpecConstantId id, uint32_t bitOffset, uint32_t bitCount) { + const auto &layout = D3D9SpecializationInfo::Layout[id]; + + uint32_t uintType = module.defIntType(32, 0); + uint32_t optimized = getOptimizedBool(module); + + uint32_t quickValue = getSpecUBODword(module, specUbo, layout.dwordOffset); + uint32_t optimizedValue = getSpecConstDword(module, layout.dwordOffset); + + uint32_t val = module.opSelect(uintType, optimized, optimizedValue, quickValue); + bitCount = std::min(bitCount, layout.sizeInBits - bitOffset); + + if (bitCount == 32) + return val; + + return module.opBitFieldUExtract( + module.defIntType(32, 0), val, + module.consti32(bitOffset + layout.bitOffset), + module.consti32(bitCount)); + } + + private: + uint32_t getSpecConstDword(SpirvModule &module, uint32_t idx) { + if (!m_specConstantIds[idx]) { + m_specConstantIds[idx] = module.specConst32(module.defIntType(32, 0), 0); + module.decorateSpecId(m_specConstantIds[idx], idx); + } + + return m_specConstantIds[idx]; + } + + uint32_t getSpecUBODword(SpirvModule& module, uint32_t specUbo, uint32_t idx) { + uint32_t uintType = module.defIntType(32, 0); + uint32_t uintPtr = module.defPointerType(uintType, spv::StorageClassUniform); + + uint32_t member = module.constu32(idx); + uint32_t dword = module.opLoad(uintType, module.opAccessChain(uintPtr, specUbo, 1, &member)); + + return dword; + } + + uint32_t getOptimizedBool(SpirvModule& module) { + uint32_t boolType = module.defBoolType(); + + // The spec constant at MaxNumSpecConstants is set to True + // when this is an optimized pipeline. + uint32_t optimized = getSpecConstDword(module, MaxNumSpecConstants); + optimized = module.opINotEqual(boolType, optimized, module.constu32(0)); + + return optimized; + } + + std::array m_specConstantIds = {}; }; } \ No newline at end of file diff --git a/src/d3d9/d3d9_state.cpp b/src/d3d9/d3d9_state.cpp index 2c32bef4..af749cf7 100644 --- a/src/d3d9/d3d9_state.cpp +++ b/src/d3d9/d3d9_state.cpp @@ -4,17 +4,25 @@ namespace dxvk { - D3D9CapturableState::D3D9CapturableState() { - for (uint32_t i = 0; i < streamFreq.size(); i++) - streamFreq[i] = 1; + template