BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.328

Browse source
This commit is contained in:
Jon Leech 2025-09-25 22:31:15 +01:00 • committed by Jon Leech
parent d7a7044334
commit 9a0f3099c8
16 changed files with 1811 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Makefile.release
View file

@ -19,9 +19,6 @@ HPP = $(SPEC)/Vulkan-Hpp
REGISTRY = $(GIT)/registry/vulkan
update: revision-check create-branch update-files push-branch
echo "Verify that Vulkan-Headers is on a branch with the new header updates."
echo "Then push them to github and create an MR there with:"
echo " make -f Makefile.release REVISION=$(REVISION) push-branch"
# Working branch for the update, and a test if it exists
BRANCH = update-$(REVISION)

62
include/vulkan/vulkan.cppm
View file

@ -10,9 +10,8 @@
module;
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
#include <version>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_NO_STD_MODULE )
# define VULKAN_HPP_ENABLE_STD_MODULE
#endif
@ -22,11 +21,11 @@ module;
#include <vulkan/vulkan_hash.hpp>
#include <vulkan/vulkan_raii.hpp>
#include <vulkan/vulkan_shared.hpp>
#ifndef VULKAN_HPP_NO_TO_STRING
# include <vulkan/vulkan_to_string.hpp>
#endif
export module vulkan_hpp;
#if defined( VULKAN_HPP_ENABLE_STD_MODULE )
export import VULKAN_HPP_STD_MODULE;
#endif
export namespace VULKAN_HPP_NAMESPACE
{
@ -49,6 +48,8 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic;
using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic;
#endif /*VK_NO_PROTOTYPES*/
using VULKAN_HPP_NAMESPACE::detail::createResultValueType;
using VULKAN_HPP_NAMESPACE::detail::resultCheck;
} // namespace detail
using VULKAN_HPP_NAMESPACE::operator&;
@ -958,6 +959,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
//=== VK_KHR_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::AddressCopyFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::AddressCopyFlagsKHR;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoTypeNV;
@ -2756,6 +2761,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapSpecVersion;
//=== VK_KHR_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectExtensionName;
using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectSpecVersion;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName;
using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion;
@ -4572,10 +4581,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;
//=== VK_NV_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV;
//=== VK_NV_memory_decompression ===
using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV;
@ -4941,6 +4947,18 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM;
using VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM;
//=== VK_KHR_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR;
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV;
using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV;
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV;
@ -8224,13 +8242,7 @@ export namespace std
//=== VK_NV_copy_memory_indirect ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>;
//=== VK_NV_memory_decompression ===
template <>
@ -8814,6 +8826,22 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>;
//=== VK_KHR_copy_memory_indirect ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR>;
//=== VK_NV_display_stereo ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>;
@ -10274,6 +10302,10 @@ export using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT;
//=== VK_QCOM_tile_memory_heap ===
export using ::PFN_vkCmdBindTileMemoryQCOM;
//=== VK_KHR_copy_memory_indirect ===
export using ::PFN_vkCmdCopyMemoryIndirectKHR;
export using ::PFN_vkCmdCopyMemoryToImageIndirectKHR;
//=== VK_NV_external_compute_queue ===
export using ::PFN_vkCreateExternalComputeQueueNV;
export using ::PFN_vkDestroyExternalComputeQueueNV;

68
include/vulkan/vulkan.hpp
View file

@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 327, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 328, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -6341,6 +6341,19 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo );
}
//=== VK_KHR_copy_memory_indirect ===
void vkCmdCopyMemoryIndirectKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryIndirectKHR( commandBuffer, pCopyMemoryIndirectInfo );
}
void vkCmdCopyMemoryToImageIndirectKHR( VkCommandBuffer commandBuffer,
const VkCopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdCopyMemoryToImageIndirectKHR( commandBuffer, pCopyMemoryToImageIndirectInfo );
}
//=== VK_NV_external_compute_queue ===
VkResult vkCreateExternalComputeQueueNV( VkDevice device,
@ -9265,6 +9278,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION;
//=== VK_KHR_copy_memory_indirect ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectExtensionName = VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectSpecVersion = VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION;
//=== VK_NV_display_stereo ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION;
@ -16192,15 +16209,6 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectPropertiesNV, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_memory_decompression ===
template <>
struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesNV, PhysicalDeviceFeatures2>
@ -18318,6 +18326,34 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_copy_memory_indirect ===
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectPropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_NV_display_stereo ===
template <>
struct StructExtends<DisplaySurfaceStereoCreateInfoNV, DisplaySurfaceCreateInfoKHR>
@ -20713,6 +20749,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_tile_memory_heap ===
PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0;
//=== VK_KHR_copy_memory_indirect ===
PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0;
PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0;
//=== VK_NV_external_compute_queue ===
PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0;
PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
@ -22319,6 +22359,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_KHR_copy_memory_indirect ===
vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectKHR" ) );
vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectKHR" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) );
@ -23552,6 +23596,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_KHR_copy_memory_indirect ===
vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) );
vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );

115
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 327
#define VK_HEADER_VERSION 328
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1022,7 +1022,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003,
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000,
@ -1234,6 +1233,10 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002,
VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003,
VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001,
VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002,
VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003,
VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000,
VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001,
VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000,
@ -1565,6 +1568,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@ -7010,6 +7014,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ULL;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ULL;
static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 0x400000000000ULL;
typedef VkFlags64 VkAccessFlags2;
@ -7190,6 +7195,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ULL;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ULL;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ULL;
static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ULL;
@ -13443,6 +13449,90 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
#endif
// VK_KHR_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_copy_memory_indirect 1
#define VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION 1
#define VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_KHR_copy_memory_indirect"
typedef enum VkAddressCopyFlagBitsKHR {
VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 0x00000001,
VK_ADDRESS_COPY_SPARSE_BIT_KHR = 0x00000002,
VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 0x00000004,
VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
} VkAddressCopyFlagBitsKHR;
typedef VkFlags VkAddressCopyFlagsKHR;
typedef struct VkStridedDeviceAddressRangeKHR {
VkDeviceAddress address;
VkDeviceSize size;
VkDeviceSize stride;
} VkStridedDeviceAddressRangeKHR;
typedef struct VkCopyMemoryIndirectCommandKHR {
VkDeviceAddress srcAddress;
VkDeviceAddress dstAddress;
VkDeviceSize size;
} VkCopyMemoryIndirectCommandKHR;
typedef struct VkCopyMemoryIndirectInfoKHR {
VkStructureType sType;
const void* pNext;
VkAddressCopyFlagsKHR srcCopyFlags;
VkAddressCopyFlagsKHR dstCopyFlags;
uint32_t copyCount;
VkStridedDeviceAddressRangeKHR copyAddressRange;
} VkCopyMemoryIndirectInfoKHR;
typedef struct VkCopyMemoryToImageIndirectCommandKHR {
VkDeviceAddress srcAddress;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkCopyMemoryToImageIndirectCommandKHR;
typedef struct VkCopyMemoryToImageIndirectInfoKHR {
VkStructureType sType;
const void* pNext;
VkAddressCopyFlagsKHR srcCopyFlags;
uint32_t copyCount;
VkStridedDeviceAddressRangeKHR copyAddressRange;
VkImage dstImage;
VkImageLayout dstImageLayout;
const VkImageSubresourceLayers* pImageSubresources;
} VkCopyMemoryToImageIndirectInfoKHR;
typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 indirectMemoryCopy;
VkBool32 indirectMemoryToImageCopy;
} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR;
typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR {
VkStructureType sType;
void* pNext;
VkQueueFlags supportedQueues;
} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo);
typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(
VkCommandBuffer commandBuffer,
const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(
VkCommandBuffer commandBuffer,
const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo);
#endif
#endif
// VK_KHR_video_encode_intra_refresh is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_video_encode_intra_refresh 1
#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1
@ -20128,20 +20218,9 @@ typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityM
#define VK_NV_copy_memory_indirect 1
#define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1
#define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect"
typedef struct VkCopyMemoryIndirectCommandNV {
VkDeviceAddress srcAddress;
VkDeviceAddress dstAddress;
VkDeviceSize size;
} VkCopyMemoryIndirectCommandNV;
typedef VkCopyMemoryIndirectCommandKHR VkCopyMemoryIndirectCommandNV;
typedef struct VkCopyMemoryToImageIndirectCommandNV {
VkDeviceAddress srcAddress;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkCopyMemoryToImageIndirectCommandNV;
typedef VkCopyMemoryToImageIndirectCommandKHR VkCopyMemoryToImageIndirectCommandNV;
typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
VkStructureType sType;
@ -20149,11 +20228,7 @@ typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
VkBool32 indirectCopy;
} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV;
typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV {
VkStructureType sType;
void* pNext;
VkQueueFlags supportedQueues;
} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;
typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;
typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride);
typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources);

45
include/vulkan/vulkan_enums.hpp
View file

@ -11,7 +11,11 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"
#include <type_traits> // for std::underlying_type
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
# include <type_traits> // for std::underlying_type
#endif
namespace VULKAN_HPP_NAMESPACE
{
@ -1365,7 +1369,6 @@ namespace VULKAN_HPP_NAMESPACE
eRenderPassStripeInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM,
eRenderPassStripeSubmitInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM,
ePhysicalDeviceCopyMemoryIndirectFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
ePhysicalDeviceMemoryDecompressionFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
ePhysicalDeviceMemoryDecompressionPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV,
ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV,
@ -1593,6 +1596,11 @@ namespace VULKAN_HPP_NAMESPACE
eTileMemoryRequirementsQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM,
eTileMemoryBindInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM,
eTileMemorySizeInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM,
ePhysicalDeviceCopyMemoryIndirectFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR,
ePhysicalDeviceCopyMemoryIndirectPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR,
ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
eCopyMemoryIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR,
eCopyMemoryToImageIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR,
eDisplaySurfaceStereoCreateInfoNV = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV,
eDisplayModeStereoPropertiesNV = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV,
eVideoEncodeIntraRefreshCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR,
@ -4868,7 +4876,8 @@ namespace VULKAN_HPP_NAMESPACE
eClusterCullingShaderHUAWEI = VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI,
eOpticalFlowNV = VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV,
eConvertCooperativeVectorMatrixNV = VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV,
eDataGraphARM = VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM
eDataGraphARM = VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM,
eCopyIndirectKHR = VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR
};
using PipelineStageFlagBits2KHR = PipelineStageFlagBits2;
@ -4896,7 +4905,8 @@ namespace VULKAN_HPP_NAMESPACE
PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT |
PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShaderHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI |
PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI |
PipelineStageFlagBits2::eOpticalFlowNV | PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV | PipelineStageFlagBits2::eDataGraphARM;
PipelineStageFlagBits2::eOpticalFlowNV | PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV | PipelineStageFlagBits2::eDataGraphARM |
PipelineStageFlagBits2::eCopyIndirectKHR;
};
// wrapper class for enum VkAccessFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits2.html
@ -5085,6 +5095,7 @@ namespace VULKAN_HPP_NAMESPACE
eOpticalFlowVectorNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV,
eOpticalFlowCostNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV,
eTensorDataGraphARM = VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM,
eCopyImageIndirectDstKHR = VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR,
eVideoEncodeQuantizationDeltaMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
eVideoEncodeEmphasisMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR
};
@ -5119,8 +5130,8 @@ namespace VULKAN_HPP_NAMESPACE
FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | FormatFeatureFlagBits2::eBlockMatchingQCOM |
FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eTensorShaderARM | FormatFeatureFlagBits2::eTensorImageAliasingARM |
FormatFeatureFlagBits2::eOpticalFlowImageNV | FormatFeatureFlagBits2::eOpticalFlowVectorNV | FormatFeatureFlagBits2::eOpticalFlowCostNV |
FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR |
FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR;
FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR |
FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR | FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR;
};
//=== VK_VERSION_1_4 ===
@ -8932,6 +8943,28 @@ namespace VULKAN_HPP_NAMESPACE
using TimeDomainEXT = TimeDomainKHR;
//=== VK_KHR_copy_memory_indirect ===
// wrapper class for enum VkAddressCopyFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagBitsKHR.html
enum class AddressCopyFlagBitsKHR : VkAddressCopyFlagsKHR
{
eDeviceLocal = VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR,
eSparse = VK_ADDRESS_COPY_SPARSE_BIT_KHR,
eProtected = VK_ADDRESS_COPY_PROTECTED_BIT_KHR
};
// wrapper using for bitmask VkAddressCopyFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagsKHR.html
using AddressCopyFlagsKHR = Flags<AddressCopyFlagBitsKHR>;
template <>
struct FlagTraits<AddressCopyFlagBitsKHR>
{
using WrappedType = VkAddressCopyFlagBitsKHR;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR AddressCopyFlagsKHR allFlags =
AddressCopyFlagBitsKHR::eDeviceLocal | AddressCopyFlagBitsKHR::eSparse | AddressCopyFlagBitsKHR::eProtected;
};
//=== VK_NV_display_stereo ===
// wrapper class for enum VkDisplaySurfaceStereoTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoTypeNV.html

36
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -463,6 +463,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_maintenance6",
"VK_NV_descriptor_pool_overallocation",
"VK_QCOM_tile_memory_heap",
"VK_KHR_copy_memory_indirect",
"VK_KHR_video_encode_intra_refresh",
"VK_KHR_video_encode_quantization_map",
"VK_NV_raw_access_chains",
@ -2586,6 +2587,13 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_copy_memory_indirect",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_buffer_device_address",
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_NV_display_stereo",
{ { "VK_VERSION_1_0",
{ {
@ -2894,6 +2902,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
{ "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
{ "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
{ "VK_NV_copy_memory_indirect", "VK_KHR_copy_memory_indirect" },
{ "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
{ "VK_KHR_maintenance5", "VK_VERSION_1_4" },
{ "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
@ -3394,6 +3403,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_EXT_fragment_density_map_offset";
}
if ( extension == "VK_NV_copy_memory_indirect" )
{
return "VK_KHR_copy_memory_indirect";
}
if ( extension == "VK_EXT_pipeline_protected_access" )
{
return "VK_VERSION_1_4";
@ -3659,16 +3672,17 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) ||
( extension == "VK_KHR_video_encode_intra_refresh" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) ||
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_KHR_copy_memory_indirect" ) || ( extension == "VK_KHR_video_encode_intra_refresh" ) ||
( extension == "VK_KHR_video_encode_quantization_map" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_NV_external_compute_queue" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
( extension == "VK_EXT_shader_float8" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) ||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
@ -3795,7 +3809,7 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) ||
( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) ||
( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) ||
( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );

54
include/vulkan/vulkan_funcs.hpp
View file

@ -30360,6 +30360,60 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_copy_memory_indirect ===
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdCopyMemoryIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( pCopyMemoryIndirectInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryIndirectKHR && "Function <vkCmdCopyMemoryIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
# endif
d.vkCmdCopyMemoryIndirectKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( &copyMemoryIndirectInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdCopyMemoryToImageIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( pCopyMemoryToImageIndirectInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectKHR && "Function <vkCmdCopyMemoryToImageIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
# endif
d.vkCmdCopyMemoryToImageIndirectKHR( m_commandBuffer, reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( &copyMemoryToImageIndirectInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_external_compute_queue ===
// wrapper function for command vkCreateExternalComputeQueueNV, see

41
include/vulkan/vulkan_handles.hpp
View file

@ -1629,10 +1629,7 @@ namespace VULKAN_HPP_NAMESPACE
struct RenderPassStripeSubmitInfoARM;
//=== VK_NV_copy_memory_indirect ===
struct CopyMemoryIndirectCommandNV;
struct CopyMemoryToImageIndirectCommandNV;
struct PhysicalDeviceCopyMemoryIndirectFeaturesNV;
struct PhysicalDeviceCopyMemoryIndirectPropertiesNV;
//=== VK_NV_memory_decompression ===
struct DecompressMemoryRegionNV;
@ -1998,6 +1995,18 @@ namespace VULKAN_HPP_NAMESPACE
struct TileMemoryBindInfoQCOM;
struct TileMemorySizeInfoQCOM;
//=== VK_KHR_copy_memory_indirect ===
struct StridedDeviceAddressRangeKHR;
struct CopyMemoryIndirectCommandKHR;
using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;
struct CopyMemoryIndirectInfoKHR;
struct CopyMemoryToImageIndirectCommandKHR;
using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;
struct CopyMemoryToImageIndirectInfoKHR;
struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
//=== VK_NV_display_stereo ===
struct DisplaySurfaceStereoCreateInfoNV;
struct DisplayModeStereoPropertiesNV;
@ -7963,6 +7972,32 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_copy_memory_indirect ===
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_cluster_acceleration_structure ===
// wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see

98
include/vulkan/vulkan_hash.hpp
View file

@ -3138,30 +3138,77 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV const & copyMemoryIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR const & copyMemoryIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.srcAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.dstAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandNV.size );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.srcAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.dstAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>
struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV const & copyMemoryToImageIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.srcAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferRowLength );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.bufferImageHeight );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageSubresource );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageOffset );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandNV.imageExtent );
VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address );
VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size );
VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR const & copyMemoryIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.srcCopyFlags );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.dstCopyFlags );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyCount );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyAddressRange );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR const & copyMemoryToImageIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.srcAddress );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferRowLength );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferImageHeight );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageSubresource );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageOffset );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageExtent );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR const & copyMemoryToImageIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.srcCopyFlags );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyCount );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyAddressRange );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImage );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImageLayout );
VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pImageSubresources );
return seed;
}
};
@ -9275,6 +9322,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & physicalDeviceCopyMemoryIndirectFeaturesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryCopy );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryToImageCopy );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>
{
@ -9290,15 +9352,15 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV const & physicalDeviceCopyMemoryIndirectPropertiesNV ) const
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & physicalDeviceCopyMemoryIndirectPropertiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesNV.supportedQueues );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.supportedQueues );
return seed;
}
};

2
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -87,7 +87,7 @@
# define VULKAN_HPP_SUPPORT_SPAN
#endif
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_ENABLE_STD_MODULE )
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_ENABLE_STD_MODULE )
# define VULKAN_HPP_STD_MODULE std.compat
#endif

40
include/vulkan/vulkan_raii.hpp
View file

@ -1877,6 +1877,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_KHR_copy_memory_indirect ===
vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) );
vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );
@ -2873,6 +2877,10 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_tile_memory_heap ===
PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0;
//=== VK_KHR_copy_memory_indirect ===
PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0;
PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0;
//=== VK_NV_external_compute_queue ===
PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0;
PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
@ -7848,6 +7856,15 @@ namespace VULKAN_HPP_NAMESPACE
void bindTileMemoryQCOM( Optional<const TileMemoryBindInfoQCOM> tileMemoryBindInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_copy_memory_indirect ===
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NV_cluster_acceleration_structure ===
// wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
@ -27165,6 +27182,29 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( tileMemoryBindInfo.get() ) );
}
//=== VK_KHR_copy_memory_indirect ===
// wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html
VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectKHR && "Function <vkCmdCopyMemoryIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
getDispatcher()->vkCmdCopyMemoryIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( &copyMemoryIndirectInfo ) );
}
// wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html
VULKAN_HPP_INLINE void
CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR &&
"Function <vkCmdCopyMemoryToImageIndirectKHR> requires <VK_KHR_copy_memory_indirect>" );
getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( &copyMemoryToImageIndirectInfo ) );
}
//=== VK_NV_external_compute_queue ===
// wrapper function for command vkCreateExternalComputeQueueNV, see

70
include/vulkan/vulkan_static_assertions.hpp
View file

@ -6596,19 +6596,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
//=== VK_NV_copy_memory_indirect ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>::value,
"CopyMemoryIndirectCommandNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV ) == sizeof( VkCopyMemoryToImageIndirectCommandNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV>::value,
"CopyMemoryToImageIndirectCommandNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV ) == sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>::value,
@ -6616,14 +6603,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV>::value,
"PhysicalDeviceCopyMemoryIndirectFeaturesNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV ) ==
sizeof( VkPhysicalDeviceCopyMemoryIndirectPropertiesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV>::value,
"PhysicalDeviceCopyMemoryIndirectPropertiesNV is not nothrow_move_constructible!" );
//=== VK_NV_memory_decompression ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV ) == sizeof( VkDecompressMemoryRegionNV ),
@ -8277,6 +8256,55 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TileMemo
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>::value,
"TileMemorySizeInfoQCOM is not nothrow_move_constructible!" );
//=== VK_KHR_copy_memory_indirect ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR ) == sizeof( VkStridedDeviceAddressRangeKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR>::value,
"StridedDeviceAddressRangeKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR ) == sizeof( VkCopyMemoryIndirectCommandKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR>::value,
"CopyMemoryIndirectCommandKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR ) == sizeof( VkCopyMemoryIndirectInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR>::value,
"CopyMemoryIndirectInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR ) == sizeof( VkCopyMemoryToImageIndirectCommandKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR>::value,
"CopyMemoryToImageIndirectCommandKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR ) == sizeof( VkCopyMemoryToImageIndirectInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR>::value,
"CopyMemoryToImageIndirectInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR ) ==
sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR>::value,
"PhysicalDeviceCopyMemoryIndirectFeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR ) ==
sizeof( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR>::value,
"PhysicalDeviceCopyMemoryIndirectPropertiesKHR is not nothrow_move_constructible!" );
//=== VK_NV_display_stereo ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ),

753
include/vulkan/vulkan_structs.hpp
View file

@ -25120,74 +25120,74 @@ namespace VULKAN_HPP_NAMESPACE
using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo;
// wrapper struct for struct VkCopyMemoryIndirectCommandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandNV.html
struct CopyMemoryIndirectCommandNV
// wrapper struct for struct VkCopyMemoryIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandKHR.html
struct CopyMemoryIndirectCommandKHR
{
using NativeType = VkCopyMemoryIndirectCommandNV;
using NativeType = VkCopyMemoryIndirectCommandKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR
CopyMemoryIndirectCommandNV( DeviceAddress srcAddress_ = {}, DeviceAddress dstAddress_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
CopyMemoryIndirectCommandKHR( DeviceAddress srcAddress_ = {}, DeviceAddress dstAddress_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT
: srcAddress{ srcAddress_ }
, dstAddress{ dstAddress_ }
, size{ size_ }
{
}
VULKAN_HPP_CONSTEXPR CopyMemoryIndirectCommandNV( CopyMemoryIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR CopyMemoryIndirectCommandKHR( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryIndirectCommandNV( VkCopyMemoryIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryIndirectCommandNV( *reinterpret_cast<CopyMemoryIndirectCommandNV const *>( &rhs ) )
CopyMemoryIndirectCommandKHR( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryIndirectCommandKHR( *reinterpret_cast<CopyMemoryIndirectCommandKHR const *>( &rhs ) )
{
}
CopyMemoryIndirectCommandNV & operator=( CopyMemoryIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryIndirectCommandKHR & operator=( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
CopyMemoryIndirectCommandNV & operator=( VkCopyMemoryIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
CopyMemoryIndirectCommandKHR & operator=( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<CopyMemoryIndirectCommandNV const *>( &rhs );
*this = *reinterpret_cast<CopyMemoryIndirectCommandKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandNV & setSrcAddress( DeviceAddress srcAddress_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) VULKAN_HPP_NOEXCEPT
{
srcAddress = srcAddress_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandNV & setDstAddress( DeviceAddress dstAddress_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setDstAddress( DeviceAddress dstAddress_ ) VULKAN_HPP_NOEXCEPT
{
dstAddress = dstAddress_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandNV & setSize( DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSize( DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkCopyMemoryIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyMemoryIndirectCommandNV *>( this );
return *reinterpret_cast<const VkCopyMemoryIndirectCommandKHR *>( this );
}
operator VkCopyMemoryIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyMemoryIndirectCommandNV *>( this );
return *reinterpret_cast<VkCopyMemoryIndirectCommandKHR *>( this );
}
operator VkCopyMemoryIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkCopyMemoryIndirectCommandNV *>( this );
return reinterpret_cast<const VkCopyMemoryIndirectCommandKHR *>( this );
}
operator VkCopyMemoryIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkCopyMemoryIndirectCommandNV *>( this );
return reinterpret_cast<VkCopyMemoryIndirectCommandKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -25198,9 +25198,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyMemoryIndirectCommandNV const & ) const = default;
auto operator<=>( CopyMemoryIndirectCommandKHR const & ) const = default;
#else
bool operator==( CopyMemoryIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -25209,7 +25209,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( CopyMemoryIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
@ -25223,11 +25223,265 @@ namespace VULKAN_HPP_NAMESPACE
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkCopyMemoryIndirectCommandNV>
struct CppType<VkCopyMemoryIndirectCommandKHR>
{
using Type = CopyMemoryIndirectCommandNV;
using Type = CopyMemoryIndirectCommandKHR;
};
#endif
using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;
// wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html
struct StridedDeviceAddressRangeKHR
{
using NativeType = VkStridedDeviceAddressRangeKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT
: address{ address_ }
, size{ size_ }
, stride{ stride_ }
{
}
VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: StridedDeviceAddressRangeKHR( *reinterpret_cast<StridedDeviceAddressRangeKHR const *>( &rhs ) )
{
}
StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<StridedDeviceAddressRangeKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) VULKAN_HPP_NOEXCEPT
{
address = address_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) VULKAN_HPP_NOEXCEPT
{
stride = stride_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkStridedDeviceAddressRangeKHR *>( this );
}
operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkStridedDeviceAddressRangeKHR *>( this );
}
operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkStridedDeviceAddressRangeKHR *>( this );
}
operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkStridedDeviceAddressRangeKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<DeviceAddress const &, DeviceSize const &, DeviceSize const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( address, size, stride );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default;
#else
bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride );
# endif
}
bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
DeviceAddress address = {};
DeviceSize size = {};
DeviceSize stride = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkStridedDeviceAddressRangeKHR>
{
using Type = StridedDeviceAddressRangeKHR;
};
#endif
// wrapper struct for struct VkCopyMemoryIndirectInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectInfoKHR.html
struct CopyMemoryIndirectInfoKHR
{
using NativeType = VkCopyMemoryIndirectInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryIndirectInfoKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {},
AddressCopyFlagsKHR dstCopyFlags_ = {},
uint32_t copyCount_ = {},
StridedDeviceAddressRangeKHR copyAddressRange_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, srcCopyFlags{ srcCopyFlags_ }
, dstCopyFlags{ dstCopyFlags_ }
, copyCount{ copyCount_ }
, copyAddressRange{ copyAddressRange_ }
{
}
VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryIndirectInfoKHR( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryIndirectInfoKHR( *reinterpret_cast<CopyMemoryIndirectInfoKHR const *>( &rhs ) )
{
}
CopyMemoryIndirectInfoKHR & operator=( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
CopyMemoryIndirectInfoKHR & operator=( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<CopyMemoryIndirectInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) VULKAN_HPP_NOEXCEPT
{
srcCopyFlags = srcCopyFlags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) VULKAN_HPP_NOEXCEPT
{
dstCopyFlags = dstCopyFlags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) VULKAN_HPP_NOEXCEPT
{
copyCount = copyCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) VULKAN_HPP_NOEXCEPT
{
copyAddressRange = copyAddressRange_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkCopyMemoryIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( this );
}
operator VkCopyMemoryIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyMemoryIndirectInfoKHR *>( this );
}
operator VkCopyMemoryIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkCopyMemoryIndirectInfoKHR *>( this );
}
operator VkCopyMemoryIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkCopyMemoryIndirectInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &,
const void * const &,
AddressCopyFlagsKHR const &,
AddressCopyFlagsKHR const &,
uint32_t const &,
StridedDeviceAddressRangeKHR const &>
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, srcCopyFlags, dstCopyFlags, copyCount, copyAddressRange );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyMemoryIndirectInfoKHR const & ) const = default;
#else
bool operator==( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( dstCopyFlags == rhs.dstCopyFlags ) &&
( copyCount == rhs.copyCount ) && ( copyAddressRange == rhs.copyAddressRange );
# endif
}
bool operator!=( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::eCopyMemoryIndirectInfoKHR;
const void * pNext = {};
AddressCopyFlagsKHR srcCopyFlags = {};
AddressCopyFlagsKHR dstCopyFlags = {};
uint32_t copyCount = {};
StridedDeviceAddressRangeKHR copyAddressRange = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkCopyMemoryIndirectInfoKHR>
{
using Type = CopyMemoryIndirectInfoKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::eCopyMemoryIndirectInfoKHR>
{
using Type = CopyMemoryIndirectInfoKHR;
};
// wrapper struct for struct VkCopyMemoryToAccelerationStructureInfoKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html
@ -25346,19 +25600,19 @@ namespace VULKAN_HPP_NAMESPACE
using Type = CopyMemoryToAccelerationStructureInfoKHR;
};
// wrapper struct for struct VkCopyMemoryToImageIndirectCommandNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandNV.html
struct CopyMemoryToImageIndirectCommandNV
// wrapper struct for struct VkCopyMemoryToImageIndirectCommandKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandKHR.html
struct CopyMemoryToImageIndirectCommandKHR
{
using NativeType = VkCopyMemoryToImageIndirectCommandNV;
using NativeType = VkCopyMemoryToImageIndirectCommandKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandNV( DeviceAddress srcAddress_ = {},
uint32_t bufferRowLength_ = {},
uint32_t bufferImageHeight_ = {},
ImageSubresourceLayers imageSubresource_ = {},
Offset3D imageOffset_ = {},
Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( DeviceAddress srcAddress_ = {},
uint32_t bufferRowLength_ = {},
uint32_t bufferImageHeight_ = {},
ImageSubresourceLayers imageSubresource_ = {},
Offset3D imageOffset_ = {},
Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT
: srcAddress{ srcAddress_ }
, bufferRowLength{ bufferRowLength_ }
, bufferImageHeight{ bufferImageHeight_ }
@ -25368,78 +25622,78 @@ namespace VULKAN_HPP_NAMESPACE
{
}
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandNV( CopyMemoryToImageIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryToImageIndirectCommandNV( VkCopyMemoryToImageIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryToImageIndirectCommandNV( *reinterpret_cast<CopyMemoryToImageIndirectCommandNV const *>( &rhs ) )
CopyMemoryToImageIndirectCommandKHR( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryToImageIndirectCommandKHR( *reinterpret_cast<CopyMemoryToImageIndirectCommandKHR const *>( &rhs ) )
{
}
CopyMemoryToImageIndirectCommandNV & operator=( CopyMemoryToImageIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryToImageIndirectCommandKHR & operator=( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
CopyMemoryToImageIndirectCommandNV & operator=( VkCopyMemoryToImageIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT
CopyMemoryToImageIndirectCommandKHR & operator=( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<CopyMemoryToImageIndirectCommandNV const *>( &rhs );
*this = *reinterpret_cast<CopyMemoryToImageIndirectCommandKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setSrcAddress( DeviceAddress srcAddress_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) VULKAN_HPP_NOEXCEPT
{
srcAddress = srcAddress_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setBufferRowLength( uint32_t bufferRowLength_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferRowLength( uint32_t bufferRowLength_ ) VULKAN_HPP_NOEXCEPT
{
bufferRowLength = bufferRowLength_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setBufferImageHeight( uint32_t bufferImageHeight_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferImageHeight( uint32_t bufferImageHeight_ ) VULKAN_HPP_NOEXCEPT
{
bufferImageHeight = bufferImageHeight_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) VULKAN_HPP_NOEXCEPT
{
imageSubresource = imageSubresource_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setImageOffset( Offset3D const & imageOffset_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageOffset( Offset3D const & imageOffset_ ) VULKAN_HPP_NOEXCEPT
{
imageOffset = imageOffset_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandNV & setImageExtent( Extent3D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageExtent( Extent3D const & imageExtent_ ) VULKAN_HPP_NOEXCEPT
{
imageExtent = imageExtent_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkCopyMemoryToImageIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryToImageIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyMemoryToImageIndirectCommandNV *>( this );
return *reinterpret_cast<const VkCopyMemoryToImageIndirectCommandKHR *>( this );
}
operator VkCopyMemoryToImageIndirectCommandNV &() VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryToImageIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyMemoryToImageIndirectCommandNV *>( this );
return *reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR *>( this );
}
operator VkCopyMemoryToImageIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryToImageIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkCopyMemoryToImageIndirectCommandNV *>( this );
return reinterpret_cast<const VkCopyMemoryToImageIndirectCommandKHR *>( this );
}
operator VkCopyMemoryToImageIndirectCommandNV *() VULKAN_HPP_NOEXCEPT
operator VkCopyMemoryToImageIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkCopyMemoryToImageIndirectCommandNV *>( this );
return reinterpret_cast<VkCopyMemoryToImageIndirectCommandKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -25451,9 +25705,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyMemoryToImageIndirectCommandNV const & ) const = default;
auto operator<=>( CopyMemoryToImageIndirectCommandKHR const & ) const = default;
#else
bool operator==( CopyMemoryToImageIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -25463,7 +25717,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( CopyMemoryToImageIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
@ -25480,11 +25734,207 @@ namespace VULKAN_HPP_NAMESPACE
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkCopyMemoryToImageIndirectCommandNV>
struct CppType<VkCopyMemoryToImageIndirectCommandKHR>
{
using Type = CopyMemoryToImageIndirectCommandNV;
using Type = CopyMemoryToImageIndirectCommandKHR;
};
#endif
using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;
// wrapper struct for struct VkCopyMemoryToImageIndirectInfoKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectInfoKHR.html
struct CopyMemoryToImageIndirectInfoKHR
{
using NativeType = VkCopyMemoryToImageIndirectInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToImageIndirectInfoKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {},
uint32_t copyCount_ = {},
StridedDeviceAddressRangeKHR copyAddressRange_ = {},
Image dstImage_ = {},
ImageLayout dstImageLayout_ = ImageLayout::eUndefined,
const ImageSubresourceLayers * pImageSubresources_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, srcCopyFlags{ srcCopyFlags_ }
, copyCount{ copyCount_ }
, copyAddressRange{ copyAddressRange_ }
, dstImage{ dstImage_ }
, dstImageLayout{ dstImageLayout_ }
, pImageSubresources{ pImageSubresources_ }
{
}
VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
CopyMemoryToImageIndirectInfoKHR( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: CopyMemoryToImageIndirectInfoKHR( *reinterpret_cast<CopyMemoryToImageIndirectInfoKHR const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_,
StridedDeviceAddressRangeKHR copyAddressRange_,
Image dstImage_,
ImageLayout dstImageLayout_,
ArrayProxyNoTemporaries<const ImageSubresourceLayers> const & imageSubresources_,
const void * pNext_ = nullptr )
: pNext( pNext_ )
, srcCopyFlags( srcCopyFlags_ )
, copyCount( static_cast<uint32_t>( imageSubresources_.size() ) )
, copyAddressRange( copyAddressRange_ )
, dstImage( dstImage_ )
, dstImageLayout( dstImageLayout_ )
, pImageSubresources( imageSubresources_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
CopyMemoryToImageIndirectInfoKHR & operator=( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
CopyMemoryToImageIndirectInfoKHR & operator=( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<CopyMemoryToImageIndirectInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) VULKAN_HPP_NOEXCEPT
{
srcCopyFlags = srcCopyFlags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) VULKAN_HPP_NOEXCEPT
{
copyCount = copyCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) VULKAN_HPP_NOEXCEPT
{
copyAddressRange = copyAddressRange_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImage( Image dstImage_ ) VULKAN_HPP_NOEXCEPT
{
dstImage = dstImage_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImageLayout( ImageLayout dstImageLayout_ ) VULKAN_HPP_NOEXCEPT
{
dstImageLayout = dstImageLayout_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPImageSubresources( const ImageSubresourceLayers * pImageSubresources_ ) VULKAN_HPP_NOEXCEPT
{
pImageSubresources = pImageSubresources_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
CopyMemoryToImageIndirectInfoKHR &
setImageSubresources( ArrayProxyNoTemporaries<const ImageSubresourceLayers> const & imageSubresources_ ) VULKAN_HPP_NOEXCEPT
{
copyCount = static_cast<uint32_t>( imageSubresources_.size() );
pImageSubresources = imageSubresources_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkCopyMemoryToImageIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( this );
}
operator VkCopyMemoryToImageIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR *>( this );
}
operator VkCopyMemoryToImageIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkCopyMemoryToImageIndirectInfoKHR *>( this );
}
operator VkCopyMemoryToImageIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkCopyMemoryToImageIndirectInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &,
const void * const &,
AddressCopyFlagsKHR const &,
uint32_t const &,
StridedDeviceAddressRangeKHR const &,
Image const &,
ImageLayout const &,
const ImageSubresourceLayers * const &>
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, srcCopyFlags, copyCount, copyAddressRange, dstImage, dstImageLayout, pImageSubresources );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( CopyMemoryToImageIndirectInfoKHR const & ) const = default;
#else
bool operator==( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( copyCount == rhs.copyCount ) &&
( copyAddressRange == rhs.copyAddressRange ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
( pImageSubresources == rhs.pImageSubresources );
# endif
}
bool operator!=( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::eCopyMemoryToImageIndirectInfoKHR;
const void * pNext = {};
AddressCopyFlagsKHR srcCopyFlags = {};
uint32_t copyCount = {};
StridedDeviceAddressRangeKHR copyAddressRange = {};
Image dstImage = {};
ImageLayout dstImageLayout = ImageLayout::eUndefined;
const ImageSubresourceLayers * pImageSubresources = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkCopyMemoryToImageIndirectInfoKHR>
{
using Type = CopyMemoryToImageIndirectInfoKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::eCopyMemoryToImageIndirectInfoKHR>
{
using Type = CopyMemoryToImageIndirectInfoKHR;
};
// wrapper struct for struct VkMemoryToImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryToImageCopy.html
struct MemoryToImageCopy
@ -79388,6 +79838,128 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceCooperativeVectorPropertiesNV;
};
// wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.html
struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR
{
using NativeType = VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( Bool32 indirectMemoryCopy_ = {},
Bool32 indirectMemoryToImageCopy_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, indirectMemoryCopy{ indirectMemoryCopy_ }
, indirectMemoryToImageCopy{ indirectMemoryToImageCopy_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceCopyMemoryIndirectFeaturesKHR( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceCopyMemoryIndirectFeaturesKHR( *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectFeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectFeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryCopy( Bool32 indirectMemoryCopy_ ) VULKAN_HPP_NOEXCEPT
{
indirectMemoryCopy = indirectMemoryCopy_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryToImageCopy( Bool32 indirectMemoryToImageCopy_ ) VULKAN_HPP_NOEXCEPT
{
indirectMemoryToImageCopy = indirectMemoryToImageCopy_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, indirectMemoryCopy, indirectMemoryToImageCopy );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectMemoryCopy == rhs.indirectMemoryCopy ) &&
( indirectMemoryToImageCopy == rhs.indirectMemoryToImageCopy );
# endif
}
bool operator!=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR;
void * pNext = {};
Bool32 indirectMemoryCopy = {};
Bool32 indirectMemoryToImageCopy = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR>
{
using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR>
{
using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html
struct PhysicalDeviceCopyMemoryIndirectFeaturesNV
@ -79499,56 +80071,57 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceCopyMemoryIndirectFeaturesNV;
};
// wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.html
struct PhysicalDeviceCopyMemoryIndirectPropertiesNV
// wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR.html
struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR
{
using NativeType = VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;
using NativeType = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectPropertiesNV( QueueFlags supportedQueues_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectPropertiesKHR( QueueFlags supportedQueues_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, supportedQueues{ supportedQueues_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectPropertiesNV( PhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR
PhysicalDeviceCopyMemoryIndirectPropertiesKHR( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceCopyMemoryIndirectPropertiesNV( VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceCopyMemoryIndirectPropertiesNV( *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectPropertiesNV const *>( &rhs ) )
PhysicalDeviceCopyMemoryIndirectPropertiesKHR( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceCopyMemoryIndirectPropertiesKHR( *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectPropertiesKHR const *>( &rhs ) )
{
}
PhysicalDeviceCopyMemoryIndirectPropertiesNV & operator=( PhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceCopyMemoryIndirectPropertiesNV & operator=( VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectPropertiesNV const *>( &rhs );
*this = *reinterpret_cast<PhysicalDeviceCopyMemoryIndirectPropertiesKHR const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>( this );
return *reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesNV &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>( this );
return *reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>( this );
return reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *>( this );
}
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>( this );
return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -79559,9 +80132,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceCopyMemoryIndirectPropertiesNV const & ) const = default;
auto operator<=>( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -79570,32 +80143,34 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceCopyMemoryIndirectPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV;
StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR;
void * pNext = {};
QueueFlags supportedQueues = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>
struct CppType<VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR>
{
using Type = PhysicalDeviceCopyMemoryIndirectPropertiesNV;
using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV>
struct CppType<StructureType, StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR>
{
using Type = PhysicalDeviceCopyMemoryIndirectPropertiesNV;
using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
};
using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
// wrapper struct for struct VkPhysicalDeviceCornerSampledImageFeaturesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html
struct PhysicalDeviceCornerSampledImageFeaturesNV

43
include/vulkan/vulkan_to_string.hpp
View file

@ -1742,6 +1742,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " ConvertCooperativeVectorMatrixNV |";
if ( value & PipelineStageFlagBits2::eDataGraphARM )
result += " DataGraphARM |";
if ( value & PipelineStageFlagBits2::eCopyIndirectKHR )
result += " CopyIndirectKHR |";
if ( result.size() > 1 )
result.back() = '}';
@ -1986,6 +1988,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " OpticalFlowCostNV |";
if ( value & FormatFeatureFlagBits2::eTensorDataGraphARM )
result += " TensorDataGraphARM |";
if ( value & FormatFeatureFlagBits2::eCopyImageIndirectDstKHR )
result += " CopyImageIndirectDstKHR |";
if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR )
result += " VideoEncodeQuantizationDeltaMapKHR |";
if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR )
@ -4026,6 +4030,25 @@ namespace VULKAN_HPP_NAMESPACE
return result;
}
//=== VK_KHR_copy_memory_indirect ===
VULKAN_HPP_INLINE std::string to_string( AddressCopyFlagsKHR value )
{
std::string result = "{";
if ( value & AddressCopyFlagBitsKHR::eDeviceLocal )
result += " DeviceLocal |";
if ( value & AddressCopyFlagBitsKHR::eSparse )
result += " Sparse |";
if ( value & AddressCopyFlagBitsKHR::eProtected )
result += " Protected |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
//=== VK_KHR_video_encode_intra_refresh ===
VULKAN_HPP_INLINE std::string to_string( VideoEncodeIntraRefreshModeFlagsKHR value )
@ -5111,7 +5134,6 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eRenderPassStripeInfoARM : return "RenderPassStripeInfoARM";
case StructureType::eRenderPassStripeSubmitInfoARM : return "RenderPassStripeSubmitInfoARM";
case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV : return "PhysicalDeviceCopyMemoryIndirectFeaturesNV";
case StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesNV : return "PhysicalDeviceCopyMemoryIndirectPropertiesNV";
case StructureType::ePhysicalDeviceMemoryDecompressionFeaturesNV : return "PhysicalDeviceMemoryDecompressionFeaturesNV";
case StructureType::ePhysicalDeviceMemoryDecompressionPropertiesNV : return "PhysicalDeviceMemoryDecompressionPropertiesNV";
case StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV";
@ -5325,6 +5347,10 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eTileMemoryRequirementsQCOM : return "TileMemoryRequirementsQCOM";
case StructureType::eTileMemoryBindInfoQCOM : return "TileMemoryBindInfoQCOM";
case StructureType::eTileMemorySizeInfoQCOM : return "TileMemorySizeInfoQCOM";
case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR : return "PhysicalDeviceCopyMemoryIndirectFeaturesKHR";
case StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR : return "PhysicalDeviceCopyMemoryIndirectPropertiesKHR";
case StructureType::eCopyMemoryIndirectInfoKHR : return "CopyMemoryIndirectInfoKHR";
case StructureType::eCopyMemoryToImageIndirectInfoKHR : return "CopyMemoryToImageIndirectInfoKHR";
case StructureType::eDisplaySurfaceStereoCreateInfoNV : return "DisplaySurfaceStereoCreateInfoNV";
case StructureType::eDisplayModeStereoPropertiesNV : return "DisplayModeStereoPropertiesNV";
case StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR : return "VideoEncodeIntraRefreshCapabilitiesKHR";
@ -7590,6 +7616,7 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineStageFlagBits2::eOpticalFlowNV : return "OpticalFlowNV";
case PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV: return "ConvertCooperativeVectorMatrixNV";
case PipelineStageFlagBits2::eDataGraphARM : return "DataGraphARM";
case PipelineStageFlagBits2::eCopyIndirectKHR : return "CopyIndirectKHR";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -7724,6 +7751,7 @@ namespace VULKAN_HPP_NAMESPACE
case FormatFeatureFlagBits2::eOpticalFlowVectorNV : return "OpticalFlowVectorNV";
case FormatFeatureFlagBits2::eOpticalFlowCostNV : return "OpticalFlowCostNV";
case FormatFeatureFlagBits2::eTensorDataGraphARM : return "TensorDataGraphARM";
case FormatFeatureFlagBits2::eCopyImageIndirectDstKHR : return "CopyImageIndirectDstKHR";
case FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR : return "VideoEncodeQuantizationDeltaMapKHR";
case FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
@ -10359,6 +10387,19 @@ namespace VULKAN_HPP_NAMESPACE
}
}
//=== VK_KHR_copy_memory_indirect ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AddressCopyFlagBitsKHR value )
{
switch ( value )
{
case AddressCopyFlagBitsKHR::eDeviceLocal: return "DeviceLocal";
case AddressCopyFlagBitsKHR::eSparse : return "Sparse";
case AddressCopyFlagBitsKHR::eProtected : return "Protected";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
//=== VK_NV_display_stereo ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceStereoTypeNV value )

567
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

121
registry/vk.xml Executable file → Normal file
View file

@ -183,7 +183,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
<type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 327</type>
#define <name>VK_HEADER_VERSION</name> 328</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 4, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -410,6 +410,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="bitmask" name="VkPipelineCreateFlags2KHR" alias="VkPipelineCreateFlags2"/>
<type bitvalues="VkBufferUsageFlagBits2" category="bitmask">typedef <type>VkFlags64</type> <name>VkBufferUsageFlags2</name>;</type>
<type category="bitmask" name="VkBufferUsageFlags2KHR" alias="VkBufferUsageFlags2"/>
<type requires="VkAddressCopyFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkAddressCopyFlagsKHR</name>;</type>
<type bitvalues="VkTensorCreateFlagBitsARM" category="bitmask">typedef <type>VkFlags64</type> <name>VkTensorCreateFlagsARM</name>;</type>
<type bitvalues="VkTensorUsageFlagBitsARM" category="bitmask">typedef <type>VkFlags64</type> <name>VkTensorUsageFlagsARM</name>;</type>
<type bitvalues="VkTensorViewCreateFlagBitsARM" category="bitmask">typedef <type>VkFlags64</type> <name>VkTensorViewCreateFlagsARM</name>;</type>
@ -874,6 +875,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkDepthClampModeEXT" category="enum"/>
<type name="VkTileShadingRenderPassFlagBitsQCOM" category="enum"/>
<type name="VkCooperativeVectorMatrixLayoutNV" category="enum"/>
<type name="VkAddressCopyFlagBitsKHR" category="enum"/>
<type name="VkTensorCreateFlagBitsARM" category="enum"/>
<type name="VkTensorUsageFlagBitsARM" category="enum"/>
<type name="VkTensorTilingARM" category="enum"/>
@ -1491,18 +1493,43 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkOffset3D</type> <name>imageOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
<member><type>VkExtent3D</type> <name>imageExtent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
</type>
<type category="struct" name="VkCopyMemoryIndirectCommandNV">
<member><type>VkDeviceAddress</type> <name>srcAddress</name></member>
<member><type>VkDeviceAddress</type> <name>dstAddress</name></member>
<member><type>VkDeviceSize</type> <name>size</name><comment>Specified in bytes</comment></member>
<type category="struct" name="VkStridedDeviceAddressRangeKHR">
<member><type>VkDeviceAddress</type> <name>address</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
<member><type>VkDeviceSize</type> <name>stride</name></member>
</type>
<type category="struct" name="VkCopyMemoryToImageIndirectCommandNV">
<member><type>VkDeviceAddress</type> <name>srcAddress</name></member>
<member><type>uint32_t</type> <name>bufferRowLength</name><comment>Specified in texels</comment></member>
<member><type>uint32_t</type> <name>bufferImageHeight</name></member>
<member><type>VkImageSubresourceLayers</type> <name>imageSubresource</name></member>
<member><type>VkOffset3D</type> <name>imageOffset</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
<member><type>VkExtent3D</type> <name>imageExtent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
<type category="struct" name="VkCopyMemoryIndirectCommandKHR">
<member><type>VkDeviceAddress</type> <name>srcAddress</name></member>
<member><type>VkDeviceAddress</type> <name>dstAddress</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
</type>
<type category="struct" name="VkCopyMemoryIndirectCommandNV" alias="VkCopyMemoryIndirectCommandKHR"/>
<type category="struct" name="VkCopyMemoryIndirectInfoKHR">
<member values="VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkAddressCopyFlagsKHR</type> <name>srcCopyFlags</name></member>
<member><type>VkAddressCopyFlagsKHR</type> <name>dstCopyFlags</name></member>
<member><type>uint32_t</type> <name>copyCount</name></member>
<member><type>VkStridedDeviceAddressRangeKHR</type> <name>copyAddressRange</name></member>
</type>
<type category="struct" name="VkCopyMemoryToImageIndirectCommandKHR">
<member><type>VkDeviceAddress</type> <name>srcAddress</name></member>
<member><type>uint32_t</type> <name>bufferRowLength</name></member>
<member><type>uint32_t</type> <name>bufferImageHeight</name></member>
<member><type>VkImageSubresourceLayers</type> <name>imageSubresource</name></member>
<member><type>VkOffset3D</type> <name>imageOffset</name></member>
<member><type>VkExtent3D</type> <name>imageExtent</name></member>
</type>
<type category="struct" name="VkCopyMemoryToImageIndirectCommandNV" alias="VkCopyMemoryToImageIndirectCommandKHR"/>
<type category="struct" name="VkCopyMemoryToImageIndirectInfoKHR">
<member values="VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkAddressCopyFlagsKHR</type> <name>srcCopyFlags</name></member>
<member><type>uint32_t</type> <name>copyCount</name></member>
<member><type>VkStridedDeviceAddressRangeKHR</type> <name>copyAddressRange</name></member>
<member><type>VkImage</type> <name>dstImage</name></member>
<member><type>VkImageLayout</type> <name>dstImageLayout</name></member>
<member len="copyCount">const <type>VkImageSubresourceLayers</type>* <name>pImageSubresources</name></member>
</type>
<type category="struct" name="VkImageResolve">
<member><type>VkImageSubresourceLayers</type> <name>srcSubresource</name></member>
@ -4861,16 +4888,23 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>dedicatedAllocationImageAliasing</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>indirectMemoryCopy</name></member>
<member><type>VkBool32</type> <name>indirectMemoryToImageCopy</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceCopyMemoryIndirectFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>indirectCopy</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceCopyMemoryIndirectPropertiesNV" returnedonly="true" structextends="VkPhysicalDeviceProperties2" requiredlimittype="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2" requiredlimittype="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="bitmask" noautovalidity="true"><type>VkQueueFlags</type> <name>supportedQueues</name><comment>Bitfield of which queues are supported for indirect copy</comment></member>
<member limittype="bitmask" noautovalidity="true"><type>VkQueueFlags</type> <name>supportedQueues</name><comment>Bitmask of VkQueueFlagBits indicating the family of queues that support indirect copy</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceCopyMemoryIndirectPropertiesNV" alias="VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"/>
<type category="struct" name="VkPhysicalDeviceMemoryDecompressionFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -13090,6 +13124,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="2" name="VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV"/>
<enum value="3" name="VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV"/>
</enums>
<enums name="VkAddressCopyFlagBitsKHR" type="bitmask">
<enum bitpos="0" name="VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR"/>
<enum bitpos="1" name="VK_ADDRESS_COPY_SPARSE_BIT_KHR"/>
<enum bitpos="2" name="VK_ADDRESS_COPY_PROTECTED_BIT_KHR"/>
</enums>
<enums name="VkTensorCreateFlagBitsARM" type="bitmask" bitwidth="64">
<enum bitpos="0" name="VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM"/>
<enum bitpos="1" name="VK_TENSOR_CREATE_PROTECTED_BIT_ARM"/>
@ -14094,6 +14133,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>uint32_t</type> <name>copyCount</name></param>
<param><type>uint32_t</type> <name>stride</name></param>
</command>
<command conditionalrendering="false" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdCopyMemoryIndirectKHR</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param>const <type>VkCopyMemoryIndirectInfoKHR</type>* <name>pCopyMemoryIndirectInfo</name></param>
</command>
<command conditionalrendering="false" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdCopyMemoryToImageIndirectNV</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
@ -14104,6 +14148,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>VkImageLayout</type> <name>dstImageLayout</name></param>
<param len="copyCount">const <type>VkImageSubresourceLayers</type>* <name>pImageSubresources</name></param>
</command>
<command conditionalrendering="false" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdCopyMemoryToImageIndirectKHR</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param>const <type>VkCopyMemoryToImageIndirectInfoKHR</type>* <name>pCopyMemoryToImageIndirectInfo</name></param>
</command>
<command conditionalrendering="false" export="vulkan,vulkansc" queues="VK_QUEUE_TRANSFER_BIT,VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdUpdateBuffer</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
@ -25816,12 +25865,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="fragmentDensityMapOffset" struct="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM"/>
</require>
</extension>
<extension name="VK_NV_copy_memory_indirect" number="427" type="device" depends="((VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_buffer_device_address),VK_VERSION_1_2" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
<extension name="VK_NV_copy_memory_indirect" number="427" type="device" depends="((VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_buffer_device_address),VK_VERSION_1_2" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" promotedto="VK_KHR_copy_memory_indirect" supported="vulkan">
<require>
<enum value="1" name="VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION"/>
<enum value="&quot;VK_NV_copy_memory_indirect&quot;" name="VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR"/>
<type name="VkCopyMemoryIndirectCommandNV"/>
<type name="VkCopyMemoryToImageIndirectCommandNV"/>
<type name="VkPhysicalDeviceCopyMemoryIndirectFeaturesNV"/>
@ -27781,12 +27830,28 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_549&quot;" name="VK_NV_EXTENSION_549_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_550" number="550" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
<extension name="VK_KHR_copy_memory_indirect" number="550" type="device" depends="(VK_KHR_get_physical_device_properties2+VK_KHR_buffer_device_address),VK_VERSION_1_2" author="KHR" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan" ratified="vulkan">
<require>
<enum value="0" name="VK_NV_EXTENSION_550_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_550&quot;" name="VK_NV_EXTENSION_550_EXTENSION_NAME"/>
<enum bitpos="46" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_RESERVED_46_BIT_NV"/>
<enum bitpos="59" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_59_BIT_NV"/>
<enum value="1" name="VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_copy_memory_indirect&quot;" name="VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR"/>
<enum offset="1" extnumber="427" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR"/>
<enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR"/>
<enum bitpos="46" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR"/>
<enum bitpos="59" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR"/>
<type name="VkStridedDeviceAddressRangeKHR"/>
<type name="VkAddressCopyFlagBitsKHR"/>
<type name="VkAddressCopyFlagsKHR"/>
<type name="VkCopyMemoryIndirectCommandKHR"/>
<type name="VkCopyMemoryIndirectInfoKHR"/>
<type name="VkCopyMemoryToImageIndirectCommandKHR"/>
<type name="VkCopyMemoryToImageIndirectInfoKHR"/>
<type name="VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"/>
<type name="VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"/>
<command name="vkCmdCopyMemoryIndirectKHR"/>
<command name="vkCmdCopyMemoryToImageIndirectKHR"/>
<feature name="indirectMemoryCopy" struct="VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_extension_551" number="551" author="NV" contact="Daniel Koch @dgkoch" supported="disabled">
@ -31258,6 +31323,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<syncstage name="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT" alias="VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT">
<syncsupport queues="VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT"/>
</syncstage>
<syncstage name="VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR">
<syncsupport queues="VK_QUEUE_GRAPHICS_BIT,VK_QUEUE_COMPUTE_BIT,VK_QUEUE_TRANSFER_BIT"/>
</syncstage>
<syncstage name="VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT" alias="VK_PIPELINE_STAGE_VERTEX_INPUT_BIT">
<syncsupport queues="VK_QUEUE_GRAPHICS_BIT"/>
<syncequivalent stage="VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT,VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT"/>
@ -31299,7 +31367,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
</syncstage>
<syncstage name="VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT" alias="VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT">
<syncsupport queues="VK_QUEUE_GRAPHICS_BIT"/>
<syncequivalent stage="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT,VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT,VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT,VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT,VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT,VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT,VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT,VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT,VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI,VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI,VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI"/>
<syncequivalent stage="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR,VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT,VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT,VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT,VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT,VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT,VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT,VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT,VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT,VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT,VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT,VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI,VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI,VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI"/>
</syncstage>
<syncstage name="VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT" alias="VK_PIPELINE_STAGE_ALL_COMMANDS_BIT">
</syncstage>
@ -31385,7 +31453,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<syncaccess name="VK_ACCESS_2_NONE" alias="VK_ACCESS_NONE">
</syncaccess>
<syncaccess name="VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT" alias="VK_ACCESS_INDIRECT_COMMAND_READ_BIT">
<syncsupport stage="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"/>
<syncsupport stage="VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT,VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR"/>
</syncaccess>
<syncaccess name="VK_ACCESS_2_INDEX_READ_BIT" alias="VK_ACCESS_INDEX_READ_BIT">
<syncsupport stage="VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT,VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT"/>
@ -31536,6 +31604,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
</syncaccess>
<syncpipeline name="graphics primitive">
<syncpipelinestage>VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT</syncpipelinestage>
@ -31565,10 +31634,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
</syncpipeline>
<syncpipeline name="compute">
<syncpipelinestage>VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT</syncpipelinestage>
<syncpipelinestage order="None">VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT</syncpipelinestage>
</syncpipeline>
<syncpipeline name="transfer">
<syncpipelinestage>VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR</syncpipelinestage>
<syncpipelinestage>VK_PIPELINE_STAGE_2_TRANSFER_BIT</syncpipelinestage>
</syncpipeline>
<syncpipeline name="host">