diff -pruN 1.4.321.0-1/.github/workflows/ci.yml 1.4.328.1-1/.github/workflows/ci.yml --- 1.4.321.0-1/.github/workflows/ci.yml 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/.github/workflows/ci.yml 2025-09-26 14:34:45.000000000 +0000 @@ -22,16 +22,16 @@ jobs: config: [Debug, Release] os: [ ubuntu-22.04, ubuntu-24.04, windows-latest, macos-latest ] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - name: Set up Python 3.8 if: matrix.os != 'macos-latest' - uses: actions/setup-python@v5 + uses: actions/setup-python@v6 with: python-version: '3.8' # MacOS machine can run on arm64 and it doesn't support 3.8 - name: Set up Python 3.10.11 if: matrix.os == 'macos-latest' - uses: actions/setup-python@v5 + uses: actions/setup-python@v6 with: python-version: '3.10.11' - name: Test CMake Minimum @@ -51,7 +51,7 @@ jobs: env: CMAKE_GENERATOR: Ninja steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - uses: ilammy/msvc-dev-cmd@v1 with: arch: amd64_arm64 @@ -67,8 +67,8 @@ jobs: matrix: abi: [ armeabi-v7a, arm64-v8a ] steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v5 + - uses: actions/setup-python@v6 with: python-version: '3.8' - uses: lukka/get-cmake@latest @@ -90,7 +90,7 @@ jobs: reuse: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - name: REUSE Compliance Check uses: fsfe/reuse-action@v5 @@ -99,8 +99,8 @@ jobs: needs: generate_source runs-on: ubuntu-24.04 steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v5 + - uses: actions/setup-python@v6 with: python-version: '3.10' - name: Install WSI dependencies @@ -111,8 +111,8 @@ jobs: generate_source: runs-on: ubuntu-24.04 steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v5 + - uses: actions/setup-python@v6 with: python-version: '3.10' - name: Generate source diff -pruN 1.4.321.0-1/.github/workflows/format.yml 1.4.328.1-1/.github/workflows/format.yml --- 1.4.321.0-1/.github/workflows/format.yml 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/.github/workflows/format.yml 2025-09-26 14:34:45.000000000 +0000 @@ -17,7 +17,7 @@ permissions: jobs: clang-format: name: clang-format - runs-on: ubuntu-latest + runs-on: ubuntu-24.04 strategy: fail-fast: false matrix: @@ -26,9 +26,11 @@ jobs: - 'src' - 'tests' steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 + - name: clang-format version + run: clang-format --version - name: Run clang-format uses: jidicula/clang-format-action@v4.15.0 with: - clang-format-version: '14' + clang-format-version: '18' check-path: ${{ matrix.path }} diff -pruN 1.4.321.0-1/.reuse/dep5 1.4.328.1-1/.reuse/dep5 --- 1.4.321.0-1/.reuse/dep5 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/.reuse/dep5 2025-09-26 14:34:45.000000000 +0000 @@ -3,6 +3,6 @@ Upstream-Name: Vulkan Utility Libraries Source: https://github.com/KhronosGroup/Vulkan-Utility-Libraries # These files are routinely updated from another repo -Files: scripts/known_good.json scripts/update_deps.py scripts/CMakeLists.txt +Files: scripts/known_good.json scripts/update_deps.py scripts/CMakeLists.txt docs/Configuring-Vulkan-Layers-Whitepaper.pdf Copyright: 2023 The Khronos Group Inc. License: Apache-2.0 diff -pruN 1.4.321.0-1/CMakeLists.txt 1.4.328.1-1/CMakeLists.txt --- 1.4.321.0-1/CMakeLists.txt 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/CMakeLists.txt 2025-09-26 14:34:45.000000000 +0000 @@ -5,7 +5,8 @@ # SPDX-License-Identifier: Apache-2.0 cmake_minimum_required(VERSION 3.22.1) -project(VUL LANGUAGES CXX) +# The VERSION field is generated with the "--generated-version" flag in the generate_source.py script +project(VUL VERSION 1.4.327 LANGUAGES CXX) set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143 @@ -23,7 +24,7 @@ set(API_TYPE "vulkan") add_subdirectory(scripts) -find_package(VulkanHeaders CONFIG) +find_package(VulkanHeaders ${CMAKE_PROJECT_VERSION} CONFIG) option(VUL_ENABLE_ASAN "Use address sanitization") if (VUL_ENABLE_ASAN) diff -pruN 1.4.321.0-1/debian/changelog 1.4.328.1-1/debian/changelog --- 1.4.321.0-1/debian/changelog 2025-08-11 03:30:57.000000000 +0000 +++ 1.4.328.1-1/debian/changelog 2025-11-10 11:20:15.000000000 +0000 @@ -1,3 +1,10 @@ +vulkan-utility-libraries (1.4.328.1-1) unstable; urgency=medium + + * New upstream release. + * control: Bump libvulkan-dev build-dep. + + -- Timo Aaltonen Mon, 10 Nov 2025 13:20:15 +0200 + vulkan-utility-libraries (1.4.321.0-1) unstable; urgency=medium * New upstream release. diff -pruN 1.4.321.0-1/debian/control 1.4.328.1-1/debian/control --- 1.4.321.0-1/debian/control 2025-08-11 03:27:37.000000000 +0000 +++ 1.4.328.1-1/debian/control 2025-10-28 11:59:57.000000000 +0000 @@ -4,7 +4,7 @@ Maintainer: Debian X Strike Force Build-Depends: debhelper-compat (= 13), cmake, - libvulkan-dev (>= 1.4.321.0), + libvulkan-dev (>= 1.4.328.1), Standards-Version: 4.6.2 Section: libs Homepage: https://github.com/KhronosGroup/Vulkan-Utility-Libraries Binary files 1.4.321.0-1/docs/Configuring-Vulkan-Layers-Whitepaper.pdf and 1.4.328.1-1/docs/Configuring-Vulkan-Layers-Whitepaper.pdf differ diff -pruN 1.4.321.0-1/docs/layer_configuration.md 1.4.328.1-1/docs/layer_configuration.md --- 1.4.321.0-1/docs/layer_configuration.md 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/docs/layer_configuration.md 2025-09-26 14:34:45.000000000 +0000 @@ -38,7 +38,9 @@ Since a setting can be set via multiple 2. vk_layer_settings.txt 3. `VK_EXT_layer_settings` -**Guideline: Settings which are unknown by the layer will be ignored independently of the method. It's the responsibility of the layer developer to ensure backward compatibility with previous versions of the layer. This is to ensure the list of layer settings remain stable across versions and that the responsibility of handling layer backward compatibility doesn't fall on Vulkan application developers as this could quickly become untrackable.**. +For more information, read the [Vulkan Layers whitepaper](https://github.com/KhronosGroup/Vulkan-Profiles/tree/main/doc/Configuring-Vulkan-Layers-Whitepaper.pdf). + +Guideline: Settings which are unknown by the layer will be ignored independently of the method. It's the responsibility of the layer developer to ensure backward compatibility with previous versions of the layer. This is to ensure the list of layer settings remain stable across versions and that the responsibility of handling layer backward compatibility doesn't fall on Vulkan application developers as this could quickly become untrackable.. ## Configuring Vulkan Layers using the *Vulkan API* diff -pruN 1.4.321.0-1/include/vulkan/layer/vk_layer_settings.h 1.4.328.1-1/include/vulkan/layer/vk_layer_settings.h --- 1.4.321.0-1/include/vulkan/layer/vk_layer_settings.h 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/layer/vk_layer_settings.h 2025-09-26 14:34:45.000000000 +0000 @@ -70,12 +70,9 @@ const VkLayerSettingsCreateInfoEXT *vkuF const VkLayerSettingsCreateInfoEXT *vkuNextLayerSettingsCreateInfo(const VkLayerSettingsCreateInfoEXT *pCreateInfo); // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT -VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings, - uint32_t *pUnknownSettingCount, const char **pUnknownSettings); - -VkResult vkuGatherUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, - const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t *pUnknownSettingCount, - const char **pUnknownSettings); +VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, + const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t *pUnknownSettingCount, + const char **pUnknownSettings); #ifdef __cplusplus } diff -pruN 1.4.321.0-1/include/vulkan/layer/vk_layer_settings.hpp 1.4.328.1-1/include/vulkan/layer/vk_layer_settings.hpp --- 1.4.321.0-1/include/vulkan/layer/vk_layer_settings.hpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/layer/vk_layer_settings.hpp 2025-09-26 14:34:45.000000000 +0000 @@ -63,10 +63,6 @@ typedef std::pair Vk VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector &settingValues); -// Deprecated -VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings, - std::vector &unknownSettings); - // Return the list of Unknown setting in all VkLayerSettingsCreateInfoEXT VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, std::vector &unknownSettings); diff -pruN 1.4.321.0-1/include/vulkan/utility/vk_dispatch_table.h 1.4.328.1-1/include/vulkan/utility/vk_dispatch_table.h --- 1.4.321.0-1/include/vulkan/utility/vk_dispatch_table.h 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/utility/vk_dispatch_table.h 2025-09-26 14:34:45.000000000 +0000 @@ -501,6 +501,8 @@ typedef struct VkuDeviceDispatchTable_ { PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdPushDescriptorSetWithTemplate2KHR; PFN_vkCmdSetDescriptorBufferOffsets2EXT CmdSetDescriptorBufferOffsets2EXT; PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT CmdBindDescriptorBufferEmbeddedSamplers2EXT; + PFN_vkCmdCopyMemoryIndirectKHR CmdCopyMemoryIndirectKHR; + PFN_vkCmdCopyMemoryToImageIndirectKHR CmdCopyMemoryToImageIndirectKHR; PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT; PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBeginEXT; @@ -1174,6 +1176,8 @@ static inline void vkuInitDeviceDispatch table->CmdPushDescriptorSetWithTemplate2KHR = (PFN_vkCmdPushDescriptorSetWithTemplate2KHR)gdpa(device, "vkCmdPushDescriptorSetWithTemplate2KHR"); table->CmdSetDescriptorBufferOffsets2EXT = (PFN_vkCmdSetDescriptorBufferOffsets2EXT)gdpa(device, "vkCmdSetDescriptorBufferOffsets2EXT"); table->CmdBindDescriptorBufferEmbeddedSamplers2EXT = (PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)gdpa(device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"); + table->CmdCopyMemoryIndirectKHR = (PFN_vkCmdCopyMemoryIndirectKHR)gdpa(device, "vkCmdCopyMemoryIndirectKHR"); + table->CmdCopyMemoryToImageIndirectKHR = (PFN_vkCmdCopyMemoryToImageIndirectKHR)gdpa(device, "vkCmdCopyMemoryToImageIndirectKHR"); table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gdpa(device, "vkDebugMarkerSetObjectTagEXT"); table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gdpa(device, "vkDebugMarkerSetObjectNameEXT"); table->CmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)gdpa(device, "vkCmdDebugMarkerBeginEXT"); diff -pruN 1.4.321.0-1/include/vulkan/utility/vk_safe_struct.hpp 1.4.328.1-1/include/vulkan/utility/vk_safe_struct.hpp --- 1.4.321.0-1/include/vulkan/utility/vk_safe_struct.hpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/utility/vk_safe_struct.hpp 2025-09-26 14:34:45.000000000 +0000 @@ -4133,7 +4133,7 @@ struct safe_VkPhysicalDeviceSubgroupSize }; struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { VkStructureType sType; - void* pNext{}; + const void* pNext{}; uint32_t requiredSubgroupSize; safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, @@ -8465,6 +8465,27 @@ struct safe_VkPhysicalDeviceRayTracingMa return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 shaderUntypedPointers; + + safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& operator=( + const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& copy_src); + safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(); + ~safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(); + void initialize(const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { VkStructureType sType; void* pNext{}; @@ -9652,6 +9673,91 @@ struct safe_VkBindDescriptorBufferEmbedd return reinterpret_cast(this); } }; +struct safe_VkCopyMemoryIndirectInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAddressCopyFlagsKHR srcCopyFlags; + VkAddressCopyFlagsKHR dstCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; + + safe_VkCopyMemoryIndirectInfoKHR(const VkCopyMemoryIndirectInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyMemoryIndirectInfoKHR(const safe_VkCopyMemoryIndirectInfoKHR& copy_src); + safe_VkCopyMemoryIndirectInfoKHR& operator=(const safe_VkCopyMemoryIndirectInfoKHR& copy_src); + safe_VkCopyMemoryIndirectInfoKHR(); + ~safe_VkCopyMemoryIndirectInfoKHR(); + void initialize(const VkCopyMemoryIndirectInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryIndirectInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryIndirectInfoKHR* ptr() { return reinterpret_cast(this); } + VkCopyMemoryIndirectInfoKHR const* ptr() const { return reinterpret_cast(this); } +}; +struct safe_VkCopyMemoryToImageIndirectInfoKHR { + VkStructureType sType; + const void* pNext{}; + VkAddressCopyFlagsKHR srcCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; + VkImage dstImage; + VkImageLayout dstImageLayout; + const VkImageSubresourceLayers* pImageSubresources{}; + + safe_VkCopyMemoryToImageIndirectInfoKHR(const VkCopyMemoryToImageIndirectInfoKHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkCopyMemoryToImageIndirectInfoKHR(const safe_VkCopyMemoryToImageIndirectInfoKHR& copy_src); + safe_VkCopyMemoryToImageIndirectInfoKHR& operator=(const safe_VkCopyMemoryToImageIndirectInfoKHR& copy_src); + safe_VkCopyMemoryToImageIndirectInfoKHR(); + ~safe_VkCopyMemoryToImageIndirectInfoKHR(); + void initialize(const VkCopyMemoryToImageIndirectInfoKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkCopyMemoryToImageIndirectInfoKHR* copy_src, PNextCopyState* copy_state = {}); + VkCopyMemoryToImageIndirectInfoKHR* ptr() { return reinterpret_cast(this); } + VkCopyMemoryToImageIndirectInfoKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR { + VkStructureType sType; + void* pNext{}; + VkBool32 indirectMemoryCopy; + VkBool32 indirectMemoryToImageCopy; + + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(); + ~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(); + void initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR { + VkStructureType sType; + void* pNext{}; + VkQueueFlags supportedQueues; + + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& copy_src); + safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(); + ~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(); + void initialize(const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkVideoEncodeIntraRefreshCapabilitiesKHR { VkStructureType sType; void* pNext{}; @@ -10093,6 +10199,23 @@ struct safe_VkPhysicalDeviceLayeredApiVu return reinterpret_cast(this); } }; +struct safe_VkMemoryBarrierAccessFlags3KHR { + VkStructureType sType; + const void* pNext{}; + VkAccessFlags3KHR srcAccessMask3; + VkAccessFlags3KHR dstAccessMask3; + + safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src); + safe_VkMemoryBarrierAccessFlags3KHR& operator=(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src); + safe_VkMemoryBarrierAccessFlags3KHR(); + ~safe_VkMemoryBarrierAccessFlags3KHR(); + void initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src, PNextCopyState* copy_state = {}); + VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast(this); } + VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast(this); } +}; struct safe_VkPhysicalDeviceMaintenance8FeaturesKHR { VkStructureType sType; void* pNext{}; @@ -10111,23 +10234,6 @@ struct safe_VkPhysicalDeviceMaintenance8 return reinterpret_cast(this); } }; -struct safe_VkMemoryBarrierAccessFlags3KHR { - VkStructureType sType; - const void* pNext{}; - VkAccessFlags3KHR srcAccessMask3; - VkAccessFlags3KHR dstAccessMask3; - - safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src); - safe_VkMemoryBarrierAccessFlags3KHR& operator=(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src); - safe_VkMemoryBarrierAccessFlags3KHR(); - ~safe_VkMemoryBarrierAccessFlags3KHR(); - void initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src, PNextCopyState* copy_state = {}); - VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast(this); } - VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast(this); } -}; struct safe_VkPhysicalDeviceMaintenance9FeaturesKHR { VkStructureType sType; void* pNext{}; @@ -16688,6 +16794,96 @@ struct safe_VkPhysicalDevicePrimitivesGe return reinterpret_cast(this); } }; +struct safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE { + VkStructureType sType; + void* pNext{}; + VkBool32 videoEncodeRgbConversion; + + safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( + const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( + const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src); + safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& operator=( + const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src); + safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(); + ~safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(); + void initialize(const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeRgbConversionCapabilitiesVALVE { + VkStructureType sType; + void* pNext{}; + VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels; + VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges; + VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets; + VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets; + + safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src); + safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& operator=(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src); + safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(); + ~safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(); + void initialize(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeRgbConversionCapabilitiesVALVE* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeRgbConversionCapabilitiesVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeProfileRgbConversionInfoVALVE { + VkStructureType sType; + const void* pNext{}; + VkBool32 performEncodeRgbConversion; + + safe_VkVideoEncodeProfileRgbConversionInfoVALVE(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeProfileRgbConversionInfoVALVE(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src); + safe_VkVideoEncodeProfileRgbConversionInfoVALVE& operator=(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src); + safe_VkVideoEncodeProfileRgbConversionInfoVALVE(); + ~safe_VkVideoEncodeProfileRgbConversionInfoVALVE(); + void initialize(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeProfileRgbConversionInfoVALVE* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeProfileRgbConversionInfoVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE { + VkStructureType sType; + const void* pNext{}; + VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel; + VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset; + + safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src); + safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& operator=( + const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src); + safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(); + ~safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(); + void initialize(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE* copy_src, PNextCopyState* copy_state = {}); + VkVideoEncodeSessionRgbConversionCreateInfoVALVE* ptr() { + return reinterpret_cast(this); + } + VkVideoEncodeSessionRgbConversionCreateInfoVALVE const* ptr() const { + return reinterpret_cast(this); + } +}; struct safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT { VkStructureType sType; void* pNext{}; @@ -17643,27 +17839,6 @@ struct safe_VkPhysicalDeviceCopyMemoryIn return reinterpret_cast(this); } }; -struct safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { - VkStructureType sType; - void* pNext{}; - VkQueueFlags supportedQueues; - - safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, - PNextCopyState* copy_state = {}, bool copy_pnext = true); - safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src); - safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& operator=( - const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src); - safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(); - ~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(); - void initialize(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, PNextCopyState* copy_state = {}); - VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* ptr() { - return reinterpret_cast(this); - } - VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const* ptr() const { - return reinterpret_cast(this); - } -}; struct safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV { VkStructureType sType; void* pNext{}; @@ -19040,6 +19215,59 @@ struct safe_VkAntiLagDataAMD { VkAntiLagDataAMD* ptr() { return reinterpret_cast(this); } VkAntiLagDataAMD const* ptr() const { return reinterpret_cast(this); } }; +#ifdef VK_ENABLE_BETA_EXTENSIONS +struct safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX { + VkStructureType sType; + void* pNext{}; + VkBool32 denseGeometryFormat; + + safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* in_struct, + PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& copy_src); + safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& operator=( + const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& copy_src); + safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(); + ~safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(); + void initialize(const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* copy_src, PNextCopyState* copy_state = {}); + VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* ptr() { + return reinterpret_cast(this); + } + VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +struct safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX { + VkStructureType sType; + const void* pNext{}; + safe_VkDeviceOrHostAddressConstKHR compressedData; + VkDeviceSize dataSize; + uint32_t numTriangles; + uint32_t numVertices; + uint32_t maxPrimitiveIndex; + uint32_t maxGeometryIndex; + VkCompressedTriangleFormatAMDX format; + + safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX( + const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* in_struct, PNextCopyState* copy_state = {}, + bool copy_pnext = true); + safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX( + const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& copy_src); + safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& operator=( + const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& copy_src); + safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(); + ~safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(); + void initialize(const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* copy_src, + PNextCopyState* copy_state = {}); + VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* ptr() { + return reinterpret_cast(this); + } + VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const* ptr() const { + return reinterpret_cast(this); + } +}; +#endif // VK_ENABLE_BETA_EXTENSIONS struct safe_VkPhysicalDeviceShaderObjectFeaturesEXT { VkStructureType sType; void* pNext{}; @@ -21656,22 +21884,21 @@ struct safe_VkPipelineViewportDepthClamp } }; #ifdef VK_USE_PLATFORM_OHOS -struct safe_VkOHSurfaceCreateInfoOHOS { +struct safe_VkSurfaceCreateInfoOHOS { VkStructureType sType; const void* pNext{}; VkSurfaceCreateFlagsOHOS flags; OHNativeWindow* window{}; - safe_VkOHSurfaceCreateInfoOHOS(const VkOHSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}, - bool copy_pnext = true); - safe_VkOHSurfaceCreateInfoOHOS(const safe_VkOHSurfaceCreateInfoOHOS& copy_src); - safe_VkOHSurfaceCreateInfoOHOS& operator=(const safe_VkOHSurfaceCreateInfoOHOS& copy_src); - safe_VkOHSurfaceCreateInfoOHOS(); - ~safe_VkOHSurfaceCreateInfoOHOS(); - void initialize(const VkOHSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}); - void initialize(const safe_VkOHSurfaceCreateInfoOHOS* copy_src, PNextCopyState* copy_state = {}); - VkOHSurfaceCreateInfoOHOS* ptr() { return reinterpret_cast(this); } - VkOHSurfaceCreateInfoOHOS const* ptr() const { return reinterpret_cast(this); } + safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true); + safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS& operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src); + safe_VkSurfaceCreateInfoOHOS(); + ~safe_VkSurfaceCreateInfoOHOS(); + void initialize(const VkSurfaceCreateInfoOHOS* in_struct, PNextCopyState* copy_state = {}); + void initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src, PNextCopyState* copy_state = {}); + VkSurfaceCreateInfoOHOS* ptr() { return reinterpret_cast(this); } + VkSurfaceCreateInfoOHOS const* ptr() const { return reinterpret_cast(this); } }; #endif // VK_USE_PLATFORM_OHOS struct safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI { diff -pruN 1.4.321.0-1/include/vulkan/utility/vk_struct_helper.hpp 1.4.328.1-1/include/vulkan/utility/vk_struct_helper.hpp --- 1.4.321.0-1/include/vulkan/utility/vk_struct_helper.hpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/utility/vk_struct_helper.hpp 2025-09-26 14:34:45.000000000 +0000 @@ -450,6 +450,7 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; } @@ -509,6 +510,10 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; } @@ -530,8 +535,8 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; } @@ -881,6 +886,10 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; } @@ -928,7 +937,6 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; } -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; } @@ -997,6 +1005,10 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; } +#ifdef VK_ENABLE_BETA_EXTENSIONS +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX; } +#endif // VK_ENABLE_BETA_EXTENSIONS template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; } @@ -1123,7 +1135,7 @@ template <> inline VkStructureType GetST template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; } #ifdef VK_USE_PLATFORM_OHOS -template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS; } +template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS; } #endif // VK_USE_PLATFORM_OHOS template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; } template <> inline VkStructureType GetSType() { return VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; } diff -pruN 1.4.321.0-1/include/vulkan/vk_enum_string_helper.h 1.4.328.1-1/include/vulkan/vk_enum_string_helper.h --- 1.4.321.0-1/include/vulkan/vk_enum_string_helper.h 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/include/vulkan/vk_enum_string_helper.h 2025-09-26 14:34:45.000000000 +0000 @@ -54,6 +54,8 @@ static inline const char* string_VkResul return "VK_ERROR_FRAGMENTED_POOL"; case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN"; + case VK_ERROR_VALIDATION_FAILED: + return "VK_ERROR_VALIDATION_FAILED"; case VK_ERROR_OUT_OF_POOL_MEMORY: return "VK_ERROR_OUT_OF_POOL_MEMORY"; case VK_ERROR_INVALID_EXTERNAL_HANDLE: @@ -76,8 +78,6 @@ static inline const char* string_VkResul return "VK_ERROR_OUT_OF_DATE_KHR"; case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"; - case VK_ERROR_VALIDATION_FAILED_EXT: - return "VK_ERROR_VALIDATION_FAILED_EXT"; case VK_ERROR_INVALID_SHADER_NV: return "VK_ERROR_INVALID_SHADER_NV"; case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: @@ -1610,6 +1610,16 @@ static inline const char* string_VkStruc return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT"; case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: @@ -1696,8 +1706,6 @@ static inline const char* string_VkStruc return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: - return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: @@ -1834,6 +1842,12 @@ static inline const char* string_VkStruc return "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD"; case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: return "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR"; case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: @@ -2108,6 +2122,14 @@ static inline const char* string_VkStruc return "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM"; case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: return "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: + return "VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR"; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: + return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR"; case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV"; case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: @@ -2258,8 +2280,8 @@ static inline const char* string_VkStruc return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR"; - case VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS: - return "VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS"; + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + return "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI"; case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: @@ -4672,6 +4694,10 @@ static inline const char* string_VkGeome return "VK_GEOMETRY_TYPE_SPHERES_NV"; case VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: return "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX: + return "VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS default: return "Unhandled VkGeometryTypeKHR"; } @@ -5228,6 +5254,16 @@ static inline const char* string_VkAntiL return "Unhandled VkAntiLagStageAMD"; } } +#ifdef VK_ENABLE_BETA_EXTENSIONS +static inline const char* string_VkCompressedTriangleFormatAMDX(VkCompressedTriangleFormatAMDX input_value) { + switch (input_value) { + case VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX: + return "VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX"; + default: + return "Unhandled VkCompressedTriangleFormatAMDX"; + } +} +#endif // VK_ENABLE_BETA_EXTENSIONS static inline const char* string_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT input_value) { switch (input_value) { case VK_SHADER_CODE_TYPE_BINARY_EXT: @@ -7874,6 +7910,7 @@ static inline const char* string_VkPipel if (input_value == VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV) return "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV"; if (input_value == VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV) return "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV"; if (input_value == VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM) return "VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM"; + if (input_value == VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR) return "VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR"; return "Unhandled VkPipelineStageFlagBits2"; } @@ -8068,6 +8105,7 @@ static inline const char* string_VkForma if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"; if (input_value == VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM) return "VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM"; + if (input_value == VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR) return "VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"; return "Unhandled VkFormatFeatureFlagBits2"; @@ -8203,6 +8241,9 @@ static inline const char* string_VkBuffe if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + if (input_value == VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX) return "VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS if (input_value == VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM) return "VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM"; if (input_value == VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM) return "VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM"; if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; @@ -9464,6 +9505,35 @@ static inline std::string string_VkVideo return ret; } #endif // __cplusplus +static inline const char* string_VkAddressCopyFlagBitsKHR(VkAddressCopyFlagBitsKHR input_value) { + switch (input_value) { + case VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR: + return "VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR"; + case VK_ADDRESS_COPY_SPARSE_BIT_KHR: + return "VK_ADDRESS_COPY_SPARSE_BIT_KHR"; + case VK_ADDRESS_COPY_PROTECTED_BIT_KHR: + return "VK_ADDRESS_COPY_PROTECTED_BIT_KHR"; + default: + return "Unhandled VkAddressCopyFlagBitsKHR"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkAddressCopyFlagsKHR(VkAddressCopyFlagsKHR input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkAddressCopyFlagBitsKHR(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkAddressCopyFlagsKHR(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkVideoEncodeIntraRefreshModeFlagBitsKHR(VkVideoEncodeIntraRefreshModeFlagBitsKHR input_value) { switch (input_value) { case VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR: @@ -9811,6 +9881,8 @@ static inline const char* string_VkBuild #endif // VK_ENABLE_BETA_EXTENSIONS case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR"; + case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: + return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV"; default: return "Unhandled VkBuildAccelerationStructureFlagBitsKHR"; } @@ -10201,6 +10273,93 @@ static inline std::string string_VkFrame return ret; } #endif // __cplusplus +static inline const char* string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(VkVideoEncodeRgbModelConversionFlagBitsVALVE input_value) { + switch (input_value) { + case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE"; + default: + return "Unhandled VkVideoEncodeRgbModelConversionFlagBitsVALVE"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkVideoEncodeRgbModelConversionFlagsVALVE(VkVideoEncodeRgbModelConversionFlagsVALVE input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkVideoEncodeRgbModelConversionFlagBitsVALVE(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkVideoEncodeRgbModelConversionFlagsVALVE(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(VkVideoEncodeRgbRangeCompressionFlagBitsVALVE input_value) { + switch (input_value) { + case VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE"; + default: + return "Unhandled VkVideoEncodeRgbRangeCompressionFlagBitsVALVE"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkVideoEncodeRgbRangeCompressionFlagsVALVE(VkVideoEncodeRgbRangeCompressionFlagsVALVE input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkVideoEncodeRgbRangeCompressionFlagsVALVE(0)"); + return ret; +} +#endif // __cplusplus +static inline const char* string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE input_value) { + switch (input_value) { + case VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE"; + case VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE: + return "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE"; + default: + return "Unhandled VkVideoEncodeRgbChromaOffsetFlagBitsVALVE"; + } +} + +#ifdef __cplusplus +static inline std::string string_VkVideoEncodeRgbChromaOffsetFlagsVALVE(VkVideoEncodeRgbChromaOffsetFlagsVALVE input_value) { + std::string ret; + int index = 0; + while(input_value) { + if (input_value & 1) { + if( !ret.empty()) ret.append("|"); + ret.append(string_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(static_cast(1U << index))); + } + ++index; + input_value >>= 1; + } + if (ret.empty()) ret.append("VkVideoEncodeRgbChromaOffsetFlagsVALVE(0)"); + return ret; +} +#endif // __cplusplus static inline const char* string_VkBuildMicromapFlagBitsEXT(VkBuildMicromapFlagBitsEXT input_value) { switch (input_value) { case VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT: @@ -11639,6 +11798,8 @@ static inline const char* string_VkStruc return "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: return "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + return "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: return "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"; case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: @@ -11757,6 +11918,14 @@ static inline const char* string_VkStruc return "VkSetDescriptorBufferOffsetsInfoEXT"; case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: return "VkBindDescriptorBufferEmbeddedSamplersInfoEXT"; + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: + return "VkCopyMemoryIndirectInfoKHR"; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: + return "VkCopyMemoryToImageIndirectInfoKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + return "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + return "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: return "VkVideoEncodeIntraRefreshCapabilitiesKHR"; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: @@ -11799,10 +11968,10 @@ static inline const char* string_VkStruc return "VkPhysicalDeviceLayeredApiPropertiesListKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: return "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: - return "VkPhysicalDeviceMaintenance8FeaturesKHR"; case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: return "VkMemoryBarrierAccessFlags3KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + return "VkPhysicalDeviceMaintenance8FeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: return "VkPhysicalDeviceMaintenance9FeaturesKHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: @@ -12469,6 +12638,14 @@ static inline const char* string_VkStruc return "VkPipelineColorWriteCreateInfoEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: return "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + return "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + return "VkVideoEncodeRgbConversionCapabilitiesVALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + return "VkVideoEncodeProfileRgbConversionInfoVALVE"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + return "VkVideoEncodeSessionRgbConversionCreateInfoVALVE"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: return "VkPhysicalDeviceImageViewMinLodFeaturesEXT"; case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: @@ -12561,8 +12738,6 @@ static inline const char* string_VkStruc return "VkRenderPassFragmentDensityMapOffsetEndInfoEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: return "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: - return "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: return "VkPhysicalDeviceMemoryDecompressionFeaturesNV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: @@ -12697,6 +12872,12 @@ static inline const char* string_VkStruc return "VkAntiLagPresentationInfoAMD"; case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: return "VkAntiLagDataAMD"; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + return "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX"; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + return "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX"; +#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: return "VkPhysicalDeviceShaderObjectFeaturesEXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: @@ -12946,8 +13127,8 @@ static inline const char* string_VkStruc case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: return "VkPipelineViewportDepthClampControlCreateInfoEXT"; #ifdef VK_USE_PLATFORM_OHOS - case VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS: - return "VkOHSurfaceCreateInfoOHOS"; + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + return "VkSurfaceCreateInfoOHOS"; #endif // VK_USE_PLATFORM_OHOS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: return "VkPhysicalDeviceHdrVividFeaturesHUAWEI"; diff -pruN 1.4.321.0-1/scripts/generate_source.py 1.4.328.1-1/scripts/generate_source.py --- 1.4.321.0-1/scripts/generate_source.py 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/scripts/generate_source.py 2025-09-26 14:34:45.000000000 +0000 @@ -8,6 +8,7 @@ import argparse import os import sys +import re import shutil import common_ci from xml.etree import ElementTree @@ -148,6 +149,10 @@ def RunGenerators(api: str, registry: st if has_clang_format: common_ci.RunShellCmd(f'clang-format -i {os.path.join(outDirectory, target)}') +# helper to define paths relative to the repo root +def repo_relative(path): + return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path)) + def main(argv): parser = argparse.ArgumentParser(description='Generate source code for this repository') parser.add_argument('--api', @@ -155,6 +160,7 @@ def main(argv): choices=['vulkan'], help='Specify API name to generate') parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory') + parser.add_argument('--generated-version', help='sets the header version used to generate the repo') group = parser.add_mutually_exclusive_group() group.add_argument('--target', nargs='+', help='only generate file name passed in') args = parser.parse_args(argv) @@ -168,6 +174,15 @@ def main(argv): RunGenerators(args.api, registry, args.target) + # write out the header version used to generate the code to a checked in CMake file + if args.generated_version: + # Update the CMake project version + with open(repo_relative('CMakeLists.txt'), "r+") as f: + data = f.read() + f.seek(0) + f.write(re.sub("project.*VERSION.*", f"project(VUL VERSION {args.generated_version} LANGUAGES CXX)", data)) + f.truncate() + return 0 if __name__ == '__main__': diff -pruN 1.4.321.0-1/scripts/generators/format_utils_generator.py 1.4.328.1-1/scripts/generators/format_utils_generator.py --- 1.4.321.0-1/scripts/generators/format_utils_generator.py 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/scripts/generators/format_utils_generator.py 2025-09-26 14:34:45.000000000 +0000 @@ -311,7 +311,7 @@ struct VKU_FORMAT_INFO { out.append(f'const struct VKU_FORMAT_INFO vku_formats[{len(self.vk.formats) + 1}] = {{\n') for f in formats_in_order.values(): className = getClassName(f.className) - blockExtent = ', '.join(f.blockExtent) if f.blockExtent is not None else '1, 1, 1' + blockExtent = ', '.join(f.blockExtent) if len(f.blockExtent) > 0 else '1, 1, 1' out.extend(f' {{ VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{') for index, component in enumerate(f.components): bits = 'VKU_FORMAT_COMPRESSED_COMPONENT' if component.bits == 'compressed' else component.bits diff -pruN 1.4.321.0-1/scripts/known_good.json 1.4.328.1-1/scripts/known_good.json --- 1.4.321.0-1/scripts/known_good.json 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/scripts/known_good.json 2025-09-26 14:34:45.000000000 +0000 @@ -7,7 +7,7 @@ "sub_dir": "Vulkan-Headers", "build_dir": "Vulkan-Headers/build", "install_dir": "Vulkan-Headers/build/install", - "commit": "v1.4.321" + "commit": "v1.4.328" }, { "name": "googletest", @@ -46,4 +46,4 @@ "googletest": "GOOGLETEST_INSTALL_DIR", "magic_enum": "MAGIC_ENUM_INSTALL_DIR" } -} +} \ No newline at end of file diff -pruN 1.4.321.0-1/src/layer/vk_layer_settings.cpp 1.4.328.1-1/src/layer/vk_layer_settings.cpp --- 1.4.321.0-1/src/layer/vk_layer_settings.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/src/layer/vk_layer_settings.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -690,41 +690,9 @@ static bool vkuHasSetting(uint32_t setti return false; } -VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings, - uint32_t *pUnknownSettingCount, const char **pUnknownSettings) { - assert(pUnknownSettingCount != nullptr); - - const VkLayerSettingsCreateInfoEXT *current_create_info = pCreateInfo; - - uint32_t current_unknown_setting_count = 0; - while (current_create_info != nullptr) { - for (uint32_t info_index = 0, info_count = current_create_info->settingCount; info_index < info_count; ++info_index) { - const char *current_setting_name = current_create_info->pSettings[info_index].pSettingName; - if (!vkuHasSetting(settingsCount, pSettings, current_setting_name)) { - if (pUnknownSettings != nullptr && current_unknown_setting_count < *pUnknownSettingCount) { - pUnknownSettings[current_unknown_setting_count] = current_setting_name; - } - - ++current_unknown_setting_count; - } - } - - current_create_info = vkuNextLayerSettingsCreateInfo(current_create_info); - } - - if (pUnknownSettings == nullptr) { - *pUnknownSettingCount = current_unknown_setting_count; - return VK_SUCCESS; - } else if (current_unknown_setting_count > *pUnknownSettingCount) { - return VK_INCOMPLETE; - } - - return VK_SUCCESS; -} - -VkResult vkuGatherUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, - const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t *pUnknownSettingCount, - const char **pUnknownSettings) { +VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, + const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t *pUnknownSettingCount, + const char **pUnknownSettings) { assert(pUnknownSettingCount != nullptr); if (layerSettingSet == VK_NULL_HANDLE) { diff -pruN 1.4.321.0-1/src/layer/vk_layer_settings_helper.cpp 1.4.328.1-1/src/layer/vk_layer_settings_helper.cpp --- 1.4.321.0-1/src/layer/vk_layer_settings_helper.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/src/layer/vk_layer_settings_helper.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -266,28 +266,11 @@ VkResult vkuGetLayerSettingValues(VkuLay return result; } -VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings, - std::vector &unknownSettings) { - uint32_t unknown_setting_count = 0; - VkResult result = vkuGetUnknownSettings(pFirstCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr); - if (result != VK_SUCCESS) { - return result; - } - - if (unknown_setting_count > 0) { - unknownSettings.resize(unknown_setting_count); - - result = vkuGetUnknownSettings(pFirstCreateInfo, settingsCount, pSettings, &unknown_setting_count, &unknownSettings[0]); - } - - return result; -} - VkResult vkuGetUnknownSettings(VkuLayerSettingSet layerSettingSet, uint32_t layerSettingsCount, const char **pLayerSettings, const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, std::vector &unknownSettings) { uint32_t unknown_setting_count = 0; - VkResult result = vkuGatherUnknownSettings(layerSettingSet, layerSettingsCount, pLayerSettings, pFirstCreateInfo, - &unknown_setting_count, nullptr); + VkResult result = vkuGetUnknownSettings(layerSettingSet, layerSettingsCount, pLayerSettings, pFirstCreateInfo, + &unknown_setting_count, nullptr); if (result != VK_SUCCESS) { return result; } @@ -295,8 +278,8 @@ VkResult vkuGetUnknownSettings(VkuLayerS if (unknown_setting_count > 0) { unknownSettings.resize(unknown_setting_count); - result = vkuGatherUnknownSettings(layerSettingSet, layerSettingsCount, pLayerSettings, pFirstCreateInfo, - &unknown_setting_count, &unknownSettings[0]); + result = vkuGetUnknownSettings(layerSettingSet, layerSettingsCount, pLayerSettings, pFirstCreateInfo, + &unknown_setting_count, &unknownSettings[0]); } return result; diff -pruN 1.4.321.0-1/src/vulkan/vk_safe_struct_khr.cpp 1.4.328.1-1/src/vulkan/vk_safe_struct_khr.cpp --- 1.4.321.0-1/src/vulkan/vk_safe_struct_khr.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/src/vulkan/vk_safe_struct_khr.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -10959,6 +10959,56 @@ void safe_VkPhysicalDeviceRayTracingMain pNext = SafePnextCopy(copy_src->pNext); } +safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR( + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), shaderUntypedPointers(in_struct->shaderUntypedPointers) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR), pNext(nullptr), shaderUntypedPointers() {} + +safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR( + const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& copy_src) { + sType = copy_src.sType; + shaderUntypedPointers = copy_src.shaderUntypedPointers; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::operator=( + const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + shaderUntypedPointers = copy_src.shaderUntypedPointers; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::~safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::initialize( + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + shaderUntypedPointers = in_struct->shaderUntypedPointers; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR::initialize( + const safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + shaderUntypedPointers = copy_src->shaderUntypedPointers; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) @@ -15095,6 +15145,295 @@ void safe_VkCalibratedTimestampInfoKHR:: pNext = SafePnextCopy(copy_src->pNext); } +safe_VkCopyMemoryIndirectInfoKHR::safe_VkCopyMemoryIndirectInfoKHR(const VkCopyMemoryIndirectInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcCopyFlags(in_struct->srcCopyFlags), + dstCopyFlags(in_struct->dstCopyFlags), + copyCount(in_struct->copyCount), + copyAddressRange(in_struct->copyAddressRange) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkCopyMemoryIndirectInfoKHR::safe_VkCopyMemoryIndirectInfoKHR() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR), + pNext(nullptr), + srcCopyFlags(), + dstCopyFlags(), + copyCount(), + copyAddressRange() {} + +safe_VkCopyMemoryIndirectInfoKHR::safe_VkCopyMemoryIndirectInfoKHR(const safe_VkCopyMemoryIndirectInfoKHR& copy_src) { + sType = copy_src.sType; + srcCopyFlags = copy_src.srcCopyFlags; + dstCopyFlags = copy_src.dstCopyFlags; + copyCount = copy_src.copyCount; + copyAddressRange = copy_src.copyAddressRange; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkCopyMemoryIndirectInfoKHR& safe_VkCopyMemoryIndirectInfoKHR::operator=(const safe_VkCopyMemoryIndirectInfoKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + srcCopyFlags = copy_src.srcCopyFlags; + dstCopyFlags = copy_src.dstCopyFlags; + copyCount = copy_src.copyCount; + copyAddressRange = copy_src.copyAddressRange; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkCopyMemoryIndirectInfoKHR::~safe_VkCopyMemoryIndirectInfoKHR() { FreePnextChain(pNext); } + +void safe_VkCopyMemoryIndirectInfoKHR::initialize(const VkCopyMemoryIndirectInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + srcCopyFlags = in_struct->srcCopyFlags; + dstCopyFlags = in_struct->dstCopyFlags; + copyCount = in_struct->copyCount; + copyAddressRange = in_struct->copyAddressRange; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkCopyMemoryIndirectInfoKHR::initialize(const safe_VkCopyMemoryIndirectInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcCopyFlags = copy_src->srcCopyFlags; + dstCopyFlags = copy_src->dstCopyFlags; + copyCount = copy_src->copyCount; + copyAddressRange = copy_src->copyAddressRange; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkCopyMemoryToImageIndirectInfoKHR::safe_VkCopyMemoryToImageIndirectInfoKHR( + const VkCopyMemoryToImageIndirectInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + srcCopyFlags(in_struct->srcCopyFlags), + copyCount(in_struct->copyCount), + copyAddressRange(in_struct->copyAddressRange), + dstImage(in_struct->dstImage), + dstImageLayout(in_struct->dstImageLayout), + pImageSubresources(nullptr) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } + if (in_struct->pImageSubresources) { + pImageSubresources = new VkImageSubresourceLayers[in_struct->copyCount]; + memcpy((void*)pImageSubresources, (void*)in_struct->pImageSubresources, + sizeof(VkImageSubresourceLayers) * in_struct->copyCount); + } +} + +safe_VkCopyMemoryToImageIndirectInfoKHR::safe_VkCopyMemoryToImageIndirectInfoKHR() + : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR), + pNext(nullptr), + srcCopyFlags(), + copyCount(), + copyAddressRange(), + dstImage(), + dstImageLayout(), + pImageSubresources(nullptr) {} + +safe_VkCopyMemoryToImageIndirectInfoKHR::safe_VkCopyMemoryToImageIndirectInfoKHR( + const safe_VkCopyMemoryToImageIndirectInfoKHR& copy_src) { + sType = copy_src.sType; + srcCopyFlags = copy_src.srcCopyFlags; + copyCount = copy_src.copyCount; + copyAddressRange = copy_src.copyAddressRange; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + pImageSubresources = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pImageSubresources) { + pImageSubresources = new VkImageSubresourceLayers[copy_src.copyCount]; + memcpy((void*)pImageSubresources, (void*)copy_src.pImageSubresources, + sizeof(VkImageSubresourceLayers) * copy_src.copyCount); + } +} + +safe_VkCopyMemoryToImageIndirectInfoKHR& safe_VkCopyMemoryToImageIndirectInfoKHR::operator=( + const safe_VkCopyMemoryToImageIndirectInfoKHR& copy_src) { + if (©_src == this) return *this; + + if (pImageSubresources) delete[] pImageSubresources; + FreePnextChain(pNext); + + sType = copy_src.sType; + srcCopyFlags = copy_src.srcCopyFlags; + copyCount = copy_src.copyCount; + copyAddressRange = copy_src.copyAddressRange; + dstImage = copy_src.dstImage; + dstImageLayout = copy_src.dstImageLayout; + pImageSubresources = nullptr; + pNext = SafePnextCopy(copy_src.pNext); + + if (copy_src.pImageSubresources) { + pImageSubresources = new VkImageSubresourceLayers[copy_src.copyCount]; + memcpy((void*)pImageSubresources, (void*)copy_src.pImageSubresources, + sizeof(VkImageSubresourceLayers) * copy_src.copyCount); + } + + return *this; +} + +safe_VkCopyMemoryToImageIndirectInfoKHR::~safe_VkCopyMemoryToImageIndirectInfoKHR() { + if (pImageSubresources) delete[] pImageSubresources; + FreePnextChain(pNext); +} + +void safe_VkCopyMemoryToImageIndirectInfoKHR::initialize(const VkCopyMemoryToImageIndirectInfoKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + if (pImageSubresources) delete[] pImageSubresources; + FreePnextChain(pNext); + sType = in_struct->sType; + srcCopyFlags = in_struct->srcCopyFlags; + copyCount = in_struct->copyCount; + copyAddressRange = in_struct->copyAddressRange; + dstImage = in_struct->dstImage; + dstImageLayout = in_struct->dstImageLayout; + pImageSubresources = nullptr; + pNext = SafePnextCopy(in_struct->pNext, copy_state); + + if (in_struct->pImageSubresources) { + pImageSubresources = new VkImageSubresourceLayers[in_struct->copyCount]; + memcpy((void*)pImageSubresources, (void*)in_struct->pImageSubresources, + sizeof(VkImageSubresourceLayers) * in_struct->copyCount); + } +} + +void safe_VkCopyMemoryToImageIndirectInfoKHR::initialize(const safe_VkCopyMemoryToImageIndirectInfoKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + srcCopyFlags = copy_src->srcCopyFlags; + copyCount = copy_src->copyCount; + copyAddressRange = copy_src->copyAddressRange; + dstImage = copy_src->dstImage; + dstImageLayout = copy_src->dstImageLayout; + pImageSubresources = nullptr; + pNext = SafePnextCopy(copy_src->pNext); + + if (copy_src->pImageSubresources) { + pImageSubresources = new VkImageSubresourceLayers[copy_src->copyCount]; + memcpy((void*)pImageSubresources, (void*)copy_src->pImageSubresources, + sizeof(VkImageSubresourceLayers) * copy_src->copyCount); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR( + const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + indirectMemoryCopy(in_struct->indirectMemoryCopy), + indirectMemoryToImageCopy(in_struct->indirectMemoryToImageCopy) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR), + pNext(nullptr), + indirectMemoryCopy(), + indirectMemoryToImageCopy() {} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& copy_src) { + sType = copy_src.sType; + indirectMemoryCopy = copy_src.indirectMemoryCopy; + indirectMemoryToImageCopy = copy_src.indirectMemoryToImageCopy; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + indirectMemoryCopy = copy_src.indirectMemoryCopy; + indirectMemoryToImageCopy = copy_src.indirectMemoryToImageCopy; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR() { FreePnextChain(pNext); } + +void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + indirectMemoryCopy = in_struct->indirectMemoryCopy; + indirectMemoryToImageCopy = in_struct->indirectMemoryToImageCopy; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR::initialize( + const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + indirectMemoryCopy = copy_src->indirectMemoryCopy; + indirectMemoryToImageCopy = copy_src->indirectMemoryToImageCopy; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR( + const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), supportedQueues(in_struct->supportedQueues) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR), pNext(nullptr), supportedQueues() {} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& copy_src) { + sType = copy_src.sType; + supportedQueues = copy_src.supportedQueues; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::operator=( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + supportedQueues = copy_src.supportedQueues; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::initialize( + const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + supportedQueues = in_struct->supportedQueues; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR::initialize( + const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + supportedQueues = copy_src->supportedQueues; + pNext = SafePnextCopy(copy_src->pNext); +} + safe_VkVideoEncodeIntraRefreshCapabilitiesKHR::safe_VkVideoEncodeIntraRefreshCapabilitiesKHR( const VkVideoEncodeIntraRefreshCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), @@ -16307,103 +16646,103 @@ void safe_VkPhysicalDeviceLayeredApiVulk pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR( - const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), maintenance8(in_struct->maintenance8) { +safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), srcAccessMask3(in_struct->srcAccessMask3), dstAccessMask3(in_struct->dstAccessMask3) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR), pNext(nullptr), maintenance8() {} +safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR() + : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR), pNext(nullptr), srcAccessMask3(), dstAccessMask3() {} -safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR( - const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) { +safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) { sType = copy_src.sType; - maintenance8 = copy_src.maintenance8; + srcAccessMask3 = copy_src.srcAccessMask3; + dstAccessMask3 = copy_src.dstAccessMask3; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkPhysicalDeviceMaintenance8FeaturesKHR& safe_VkPhysicalDeviceMaintenance8FeaturesKHR::operator=( - const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) { +safe_VkMemoryBarrierAccessFlags3KHR& safe_VkMemoryBarrierAccessFlags3KHR::operator=( + const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - maintenance8 = copy_src.maintenance8; + srcAccessMask3 = copy_src.srcAccessMask3; + dstAccessMask3 = copy_src.dstAccessMask3; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkPhysicalDeviceMaintenance8FeaturesKHR::~safe_VkPhysicalDeviceMaintenance8FeaturesKHR() { FreePnextChain(pNext); } +safe_VkMemoryBarrierAccessFlags3KHR::~safe_VkMemoryBarrierAccessFlags3KHR() { FreePnextChain(pNext); } -void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - maintenance8 = in_struct->maintenance8; + srcAccessMask3 = in_struct->srcAccessMask3; + dstAccessMask3 = in_struct->dstAccessMask3; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - maintenance8 = copy_src->maintenance8; + srcAccessMask3 = copy_src->srcAccessMask3; + dstAccessMask3 = copy_src->dstAccessMask3; pNext = SafePnextCopy(copy_src->pNext); } -safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, - bool copy_pnext) - : sType(in_struct->sType), srcAccessMask3(in_struct->srcAccessMask3), dstAccessMask3(in_struct->dstAccessMask3) { +safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR( + const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), maintenance8(in_struct->maintenance8) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); } } -safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR() - : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR), pNext(nullptr), srcAccessMask3(), dstAccessMask3() {} +safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR), pNext(nullptr), maintenance8() {} -safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) { +safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR( + const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) { sType = copy_src.sType; - srcAccessMask3 = copy_src.srcAccessMask3; - dstAccessMask3 = copy_src.dstAccessMask3; + maintenance8 = copy_src.maintenance8; pNext = SafePnextCopy(copy_src.pNext); } -safe_VkMemoryBarrierAccessFlags3KHR& safe_VkMemoryBarrierAccessFlags3KHR::operator=( - const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) { +safe_VkPhysicalDeviceMaintenance8FeaturesKHR& safe_VkPhysicalDeviceMaintenance8FeaturesKHR::operator=( + const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) { if (©_src == this) return *this; FreePnextChain(pNext); sType = copy_src.sType; - srcAccessMask3 = copy_src.srcAccessMask3; - dstAccessMask3 = copy_src.dstAccessMask3; + maintenance8 = copy_src.maintenance8; pNext = SafePnextCopy(copy_src.pNext); return *this; } -safe_VkMemoryBarrierAccessFlags3KHR::~safe_VkMemoryBarrierAccessFlags3KHR() { FreePnextChain(pNext); } +safe_VkPhysicalDeviceMaintenance8FeaturesKHR::~safe_VkPhysicalDeviceMaintenance8FeaturesKHR() { FreePnextChain(pNext); } -void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { FreePnextChain(pNext); sType = in_struct->sType; - srcAccessMask3 = in_struct->srcAccessMask3; - dstAccessMask3 = in_struct->dstAccessMask3; + maintenance8 = in_struct->maintenance8; pNext = SafePnextCopy(in_struct->pNext, copy_state); } -void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; - srcAccessMask3 = copy_src->srcAccessMask3; - dstAccessMask3 = copy_src->dstAccessMask3; + maintenance8 = copy_src->maintenance8; pNext = SafePnextCopy(copy_src->pNext); } diff -pruN 1.4.321.0-1/src/vulkan/vk_safe_struct_utils.cpp 1.4.328.1-1/src/vulkan/vk_safe_struct_utils.cpp --- 1.4.321.0-1/src/vulkan/vk_safe_struct_utils.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/src/vulkan/vk_safe_struct_utils.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -761,6 +761,9 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -902,6 +905,12 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: safe_pNext = new safe_VkAttachmentFeedbackLoopInfoEXT(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: safe_pNext = new safe_VkVideoEncodeIntraRefreshCapabilitiesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -962,12 +971,12 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: safe_pNext = new safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: - safe_pNext = new safe_VkPhysicalDeviceMaintenance8FeaturesKHR(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: safe_pNext = new safe_VkMemoryBarrierAccessFlags3KHR(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + safe_pNext = new safe_VkPhysicalDeviceMaintenance8FeaturesKHR(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: safe_pNext = new safe_VkPhysicalDeviceMaintenance9FeaturesKHR(reinterpret_cast(pNext), copy_state, false); break; @@ -1665,6 +1674,18 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + safe_pNext = new safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + safe_pNext = new safe_VkVideoEncodeRgbConversionCapabilitiesVALVE(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + safe_pNext = new safe_VkVideoEncodeProfileRgbConversionInfoVALVE(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + safe_pNext = new safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(reinterpret_cast(pNext), copy_state, false); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -1772,9 +1793,6 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: - safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(reinterpret_cast(pNext), copy_state, false); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: safe_pNext = new safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(reinterpret_cast(pNext), copy_state, false); break; @@ -1918,6 +1936,14 @@ void *SafePnextCopy(const void *pNext, P case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: safe_pNext = new safe_VkPhysicalDeviceAntiLagFeaturesAMD(reinterpret_cast(pNext), copy_state, false); break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + safe_pNext = new safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(reinterpret_cast(pNext), copy_state, false); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + safe_pNext = new safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(reinterpret_cast(pNext), copy_state, false); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: safe_pNext = new safe_VkPhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast(pNext), copy_state, false); break; @@ -2980,6 +3006,9 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -3121,6 +3150,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: delete reinterpret_cast(header); break; @@ -3181,12 +3216,12 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: delete reinterpret_cast(header); break; @@ -3884,6 +3919,18 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: delete reinterpret_cast(header); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + delete reinterpret_cast(header); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: delete reinterpret_cast(header); break; @@ -3991,9 +4038,6 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: delete reinterpret_cast(header); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: - delete reinterpret_cast(header); - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: delete reinterpret_cast(header); break; @@ -4137,6 +4181,14 @@ void FreePnextChain(const void *pNext) { case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: delete reinterpret_cast(header); break; +#ifdef VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + delete reinterpret_cast(header); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + delete reinterpret_cast(header); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: delete reinterpret_cast(header); break; diff -pruN 1.4.321.0-1/src/vulkan/vk_safe_struct_vendor.cpp 1.4.328.1-1/src/vulkan/vk_safe_struct_vendor.cpp --- 1.4.321.0-1/src/vulkan/vk_safe_struct_vendor.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/src/vulkan/vk_safe_struct_vendor.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -10494,6 +10494,247 @@ void safe_VkScreenSurfaceCreateInfoQNX:: window = copy_src->window; } #endif // VK_USE_PLATFORM_SCREEN_QNX + +safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( + const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), videoEncodeRgbConversion(in_struct->videoEncodeRgbConversion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE), + pNext(nullptr), + videoEncodeRgbConversion() {} + +safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( + const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src) { + sType = copy_src.sType; + videoEncodeRgbConversion = copy_src.videoEncodeRgbConversion; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::operator=( + const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + videoEncodeRgbConversion = copy_src.videoEncodeRgbConversion; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::~safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::initialize( + const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + videoEncodeRgbConversion = in_struct->videoEncodeRgbConversion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE::initialize( + const safe_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + videoEncodeRgbConversion = copy_src->videoEncodeRgbConversion; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE( + const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rgbModels(in_struct->rgbModels), + rgbRanges(in_struct->rgbRanges), + xChromaOffsets(in_struct->xChromaOffsets), + yChromaOffsets(in_struct->yChromaOffsets) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE), + pNext(nullptr), + rgbModels(), + rgbRanges(), + xChromaOffsets(), + yChromaOffsets() {} + +safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::safe_VkVideoEncodeRgbConversionCapabilitiesVALVE( + const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src) { + sType = copy_src.sType; + rgbModels = copy_src.rgbModels; + rgbRanges = copy_src.rgbRanges; + xChromaOffsets = copy_src.xChromaOffsets; + yChromaOffsets = copy_src.yChromaOffsets; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::operator=( + const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rgbModels = copy_src.rgbModels; + rgbRanges = copy_src.rgbRanges; + xChromaOffsets = copy_src.xChromaOffsets; + yChromaOffsets = copy_src.yChromaOffsets; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::~safe_VkVideoEncodeRgbConversionCapabilitiesVALVE() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::initialize(const VkVideoEncodeRgbConversionCapabilitiesVALVE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rgbModels = in_struct->rgbModels; + rgbRanges = in_struct->rgbRanges; + xChromaOffsets = in_struct->xChromaOffsets; + yChromaOffsets = in_struct->yChromaOffsets; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeRgbConversionCapabilitiesVALVE::initialize(const safe_VkVideoEncodeRgbConversionCapabilitiesVALVE* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rgbModels = copy_src->rgbModels; + rgbRanges = copy_src->rgbRanges; + xChromaOffsets = copy_src->xChromaOffsets; + yChromaOffsets = copy_src->yChromaOffsets; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE( + const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), performEncodeRgbConversion(in_struct->performEncodeRgbConversion) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE), pNext(nullptr), performEncodeRgbConversion() {} + +safe_VkVideoEncodeProfileRgbConversionInfoVALVE::safe_VkVideoEncodeProfileRgbConversionInfoVALVE( + const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src) { + sType = copy_src.sType; + performEncodeRgbConversion = copy_src.performEncodeRgbConversion; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeProfileRgbConversionInfoVALVE& safe_VkVideoEncodeProfileRgbConversionInfoVALVE::operator=( + const safe_VkVideoEncodeProfileRgbConversionInfoVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + performEncodeRgbConversion = copy_src.performEncodeRgbConversion; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeProfileRgbConversionInfoVALVE::~safe_VkVideoEncodeProfileRgbConversionInfoVALVE() { FreePnextChain(pNext); } + +void safe_VkVideoEncodeProfileRgbConversionInfoVALVE::initialize(const VkVideoEncodeProfileRgbConversionInfoVALVE* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + performEncodeRgbConversion = in_struct->performEncodeRgbConversion; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeProfileRgbConversionInfoVALVE::initialize(const safe_VkVideoEncodeProfileRgbConversionInfoVALVE* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + performEncodeRgbConversion = copy_src->performEncodeRgbConversion; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE( + const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), + rgbModel(in_struct->rgbModel), + rgbRange(in_struct->rgbRange), + xChromaOffset(in_struct->xChromaOffset), + yChromaOffset(in_struct->yChromaOffset) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE() + : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE), + pNext(nullptr), + rgbModel(), + rgbRange(), + xChromaOffset(), + yChromaOffset() {} + +safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE( + const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src) { + sType = copy_src.sType; + rgbModel = copy_src.rgbModel; + rgbRange = copy_src.rgbRange; + xChromaOffset = copy_src.xChromaOffset; + yChromaOffset = copy_src.yChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::operator=( + const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + rgbModel = copy_src.rgbModel; + rgbRange = copy_src.rgbRange; + xChromaOffset = copy_src.xChromaOffset; + yChromaOffset = copy_src.yChromaOffset; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::~safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE() { + FreePnextChain(pNext); +} + +void safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::initialize( + const VkVideoEncodeSessionRgbConversionCreateInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + rgbModel = in_struct->rgbModel; + rgbRange = in_struct->rgbRange; + xChromaOffset = in_struct->xChromaOffset; + yChromaOffset = in_struct->yChromaOffset; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE::initialize( + const safe_VkVideoEncodeSessionRgbConversionCreateInfoVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + rgbModel = copy_src->rgbModel; + rgbRange = copy_src->rgbRange; + xChromaOffset = copy_src->xChromaOffset; + yChromaOffset = copy_src->yChromaOffset; + pNext = SafePnextCopy(copy_src->pNext); +} #ifdef VK_ENABLE_BETA_EXTENSIONS safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV( @@ -11549,56 +11790,6 @@ void safe_VkPhysicalDeviceCopyMemoryIndi pNext = SafePnextCopy(copy_src->pNext); } -safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV( - const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) - : sType(in_struct->sType), supportedQueues(in_struct->supportedQueues) { - if (copy_pnext) { - pNext = SafePnextCopy(in_struct->pNext, copy_state); - } -} - -safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV() - : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV), pNext(nullptr), supportedQueues() {} - -safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV( - const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) { - sType = copy_src.sType; - supportedQueues = copy_src.supportedQueues; - pNext = SafePnextCopy(copy_src.pNext); -} - -safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::operator=( - const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) { - if (©_src == this) return *this; - - FreePnextChain(pNext); - - sType = copy_src.sType; - supportedQueues = copy_src.supportedQueues; - pNext = SafePnextCopy(copy_src.pNext); - - return *this; -} - -safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV() { - FreePnextChain(pNext); -} - -void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize( - const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { - FreePnextChain(pNext); - sType = in_struct->sType; - supportedQueues = in_struct->supportedQueues; - pNext = SafePnextCopy(in_struct->pNext, copy_state); -} - -void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize( - const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { - sType = copy_src->sType; - supportedQueues = copy_src->supportedQueues; - pNext = SafePnextCopy(copy_src->pNext); -} - safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV( const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), memoryDecompression(in_struct->memoryDecompression) { @@ -15144,6 +15335,149 @@ void safe_VkAntiLagDataAMD::initialize(c pNext = SafePnextCopy(copy_src->pNext); if (copy_src->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src->pPresentationInfo); } +#ifdef VK_ENABLE_BETA_EXTENSIONS + +safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX( + const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) + : sType(in_struct->sType), denseGeometryFormat(in_struct->denseGeometryFormat) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX() + : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX), pNext(nullptr), denseGeometryFormat() {} + +safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX( + const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& copy_src) { + sType = copy_src.sType; + denseGeometryFormat = copy_src.denseGeometryFormat; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::operator=( + const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + denseGeometryFormat = copy_src.denseGeometryFormat; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::~safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX() { + FreePnextChain(pNext); +} + +void safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::initialize( + const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + denseGeometryFormat = in_struct->denseGeometryFormat; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX::initialize( + const safe_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + denseGeometryFormat = copy_src->denseGeometryFormat; + pNext = SafePnextCopy(copy_src->pNext); +} + +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX( + const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, + bool copy_pnext) + : sType(in_struct->sType), + compressedData(&in_struct->compressedData), + dataSize(in_struct->dataSize), + numTriangles(in_struct->numTriangles), + numVertices(in_struct->numVertices), + maxPrimitiveIndex(in_struct->maxPrimitiveIndex), + maxGeometryIndex(in_struct->maxGeometryIndex), + format(in_struct->format) { + if (copy_pnext) { + pNext = SafePnextCopy(in_struct->pNext, copy_state); + } +} + +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX() + : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX), + pNext(nullptr), + dataSize(), + numTriangles(), + numVertices(), + maxPrimitiveIndex(), + maxGeometryIndex(), + format() {} + +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX( + const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& copy_src) { + sType = copy_src.sType; + compressedData.initialize(©_src.compressedData); + dataSize = copy_src.dataSize; + numTriangles = copy_src.numTriangles; + numVertices = copy_src.numVertices; + maxPrimitiveIndex = copy_src.maxPrimitiveIndex; + maxGeometryIndex = copy_src.maxGeometryIndex; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); +} + +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::operator=( + const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& copy_src) { + if (©_src == this) return *this; + + FreePnextChain(pNext); + + sType = copy_src.sType; + compressedData.initialize(©_src.compressedData); + dataSize = copy_src.dataSize; + numTriangles = copy_src.numTriangles; + numVertices = copy_src.numVertices; + maxPrimitiveIndex = copy_src.maxPrimitiveIndex; + maxGeometryIndex = copy_src.maxGeometryIndex; + format = copy_src.format; + pNext = SafePnextCopy(copy_src.pNext); + + return *this; +} + +safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX:: + ~safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX() { + FreePnextChain(pNext); +} + +void safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::initialize( + const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) { + FreePnextChain(pNext); + sType = in_struct->sType; + compressedData.initialize(&in_struct->compressedData); + dataSize = in_struct->dataSize; + numTriangles = in_struct->numTriangles; + numVertices = in_struct->numVertices; + maxPrimitiveIndex = in_struct->maxPrimitiveIndex; + maxGeometryIndex = in_struct->maxGeometryIndex; + format = in_struct->format; + pNext = SafePnextCopy(in_struct->pNext, copy_state); +} + +void safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX::initialize( + const safe_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) { + sType = copy_src->sType; + compressedData.initialize(©_src->compressedData); + dataSize = copy_src->dataSize; + numTriangles = copy_src->numTriangles; + numVertices = copy_src->numVertices; + maxPrimitiveIndex = copy_src->maxPrimitiveIndex; + maxGeometryIndex = copy_src->maxGeometryIndex; + format = copy_src->format; + pNext = SafePnextCopy(copy_src->pNext); +} +#endif // VK_ENABLE_BETA_EXTENSIONS safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM( const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) @@ -21090,8 +21424,8 @@ void safe_VkImageAlignmentControlCreateI } #ifdef VK_USE_PLATFORM_OHOS -safe_VkOHSurfaceCreateInfoOHOS::safe_VkOHSurfaceCreateInfoOHOS(const VkOHSurfaceCreateInfoOHOS* in_struct, - [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext) : sType(in_struct->sType), flags(in_struct->flags), window(nullptr) { if (copy_pnext) { pNext = SafePnextCopy(in_struct->pNext, copy_state); @@ -21101,10 +21435,10 @@ safe_VkOHSurfaceCreateInfoOHOS::safe_VkO } } -safe_VkOHSurfaceCreateInfoOHOS::safe_VkOHSurfaceCreateInfoOHOS() - : sType(VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS), pNext(nullptr), flags(), window(nullptr) {} +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS() + : sType(VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS), pNext(nullptr), flags(), window(nullptr) {} -safe_VkOHSurfaceCreateInfoOHOS::safe_VkOHSurfaceCreateInfoOHOS(const safe_VkOHSurfaceCreateInfoOHOS& copy_src) { +safe_VkSurfaceCreateInfoOHOS::safe_VkSurfaceCreateInfoOHOS(const safe_VkSurfaceCreateInfoOHOS& copy_src) { sType = copy_src.sType; flags = copy_src.flags; window = nullptr; @@ -21115,7 +21449,7 @@ safe_VkOHSurfaceCreateInfoOHOS::safe_VkO } } -safe_VkOHSurfaceCreateInfoOHOS& safe_VkOHSurfaceCreateInfoOHOS::operator=(const safe_VkOHSurfaceCreateInfoOHOS& copy_src) { +safe_VkSurfaceCreateInfoOHOS& safe_VkSurfaceCreateInfoOHOS::operator=(const safe_VkSurfaceCreateInfoOHOS& copy_src) { if (©_src == this) return *this; if (window) delete window; @@ -21133,13 +21467,13 @@ safe_VkOHSurfaceCreateInfoOHOS& safe_VkO return *this; } -safe_VkOHSurfaceCreateInfoOHOS::~safe_VkOHSurfaceCreateInfoOHOS() { +safe_VkSurfaceCreateInfoOHOS::~safe_VkSurfaceCreateInfoOHOS() { if (window) delete window; FreePnextChain(pNext); } -void safe_VkOHSurfaceCreateInfoOHOS::initialize(const VkOHSurfaceCreateInfoOHOS* in_struct, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSurfaceCreateInfoOHOS::initialize(const VkSurfaceCreateInfoOHOS* in_struct, + [[maybe_unused]] PNextCopyState* copy_state) { if (window) delete window; FreePnextChain(pNext); sType = in_struct->sType; @@ -21152,8 +21486,8 @@ void safe_VkOHSurfaceCreateInfoOHOS::ini } } -void safe_VkOHSurfaceCreateInfoOHOS::initialize(const safe_VkOHSurfaceCreateInfoOHOS* copy_src, - [[maybe_unused]] PNextCopyState* copy_state) { +void safe_VkSurfaceCreateInfoOHOS::initialize(const safe_VkSurfaceCreateInfoOHOS* copy_src, + [[maybe_unused]] PNextCopyState* copy_state) { sType = copy_src->sType; flags = copy_src->flags; window = nullptr; diff -pruN 1.4.321.0-1/tests/test_setting_cpp.cpp 1.4.328.1-1/tests/test_setting_cpp.cpp --- 1.4.321.0-1/tests/test_setting_cpp.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/tests/test_setting_cpp.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -568,12 +568,17 @@ TEST(test_layer_setting_cpp, vkuGetUnkno const char* setting_names[] = {"int32_value", "int64_value", "uint32_value", "uint64_value", "float_value", "double_value"}; const std::uint32_t setting_name_count = static_cast(std::size(setting_names)); + VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet); + std::vector unknown_settings; - vkuGetUnknownSettings(&layer_settings_create_info, setting_name_count, setting_names, unknown_settings); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &layer_settings_create_info, unknown_settings); EXPECT_EQ(2, unknown_settings.size()); EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("frameset_value", unknown_settings[1]); + + vkuDestroyLayerSettingSet(layerSettingSet, nullptr); } TEST(test_layer_setting_cpp, vkuGetUnknownSettings) { diff -pruN 1.4.321.0-1/tests/test_setting_util.cpp 1.4.328.1-1/tests/test_setting_util.cpp --- 1.4.321.0-1/tests/test_setting_util.cpp 2025-07-04 08:39:27.000000000 +0000 +++ 1.4.328.1-1/tests/test_setting_util.cpp 2025-09-26 14:34:45.000000000 +0000 @@ -662,22 +662,29 @@ TEST(test_layer_settings_util, vkuGetUnk const char* setting_names[] = {"int32_value", "int64_value", "uint32_value", "uint64_value", "float_value", "double_value"}; const std::uint32_t setting_name_count = static_cast(std::size(setting_names)); + VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &create_info, nullptr, nullptr, &layerSettingSet); + uint32_t unknown_settings_count = 0; - vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_info, &unknown_settings_count, nullptr); EXPECT_EQ(2u, unknown_settings_count); std::vector unknown_settings(unknown_settings_count); unknown_settings_count = 1; - vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_info, &unknown_settings_count, + &unknown_settings[0]); EXPECT_EQ(1u, unknown_settings_count); EXPECT_STREQ("bool_value", unknown_settings[0]); unknown_settings_count = 2; - vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_info, &unknown_settings_count, + &unknown_settings[0]); EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("frameset_value", unknown_settings[1]); + + vkuDestroyLayerSettingSet(layerSettingSet, nullptr); } TEST(test_layer_settings_util, vlGetUnknownSettings_MultipleCreateInfo) { @@ -775,20 +782,27 @@ TEST(test_layer_settings_util, vlGetUnkn const char* setting_names[] = {"int32_value", "int64_value", "uint32_value", "uint64_value", "float_value", "double_value"}; const std::uint32_t setting_name_count = static_cast(std::size(setting_names)); + VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE; + vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &create_infoA, nullptr, nullptr, &layerSettingSet); + uint32_t unknown_settings_count = 0; - vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, nullptr); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_infoA, &unknown_settings_count, nullptr); EXPECT_EQ(2u, unknown_settings_count); std::vector unknown_settings(unknown_settings_count); unknown_settings_count = 1; - vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_infoA, &unknown_settings_count, + &unknown_settings[0]); EXPECT_EQ(1u, unknown_settings_count); EXPECT_STREQ("bool_value", unknown_settings[0]); unknown_settings_count = 2; - vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]); + vkuGetUnknownSettings(layerSettingSet, setting_name_count, setting_names, &create_infoA, &unknown_settings_count, + &unknown_settings[0]); EXPECT_STREQ("bool_value", unknown_settings[0]); EXPECT_STREQ("frameset_value", unknown_settings[1]); + + vkuDestroyLayerSettingSet(layerSettingSet, nullptr); }