From 6f0beebdf95c68eccfec2a9712239b02a4b53d01 Mon Sep 17 00:00:00 2001 From: kbJeff-8 Date: Sun, 12 Apr 2026 01:15:09 +0000 Subject: [PATCH] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 5 +- third_party/vulkan/vulkan.hpp | 105 +- third_party/vulkan/vulkan_core.h | 170 ++- third_party/vulkan/vulkan_enums.hpp | 190 ++- .../vulkan/vulkan_extension_inspection.hpp | 25 +- third_party/vulkan/vulkan_funcs.hpp | 141 +- third_party/vulkan/vulkan_handles.hpp | 57 + third_party/vulkan/vulkan_hash.hpp | 146 ++ third_party/vulkan/vulkan_raii.hpp | 67 +- .../vulkan/vulkan_static_assertions.hpp | 70 + third_party/vulkan/vulkan_structs.hpp | 1341 +++++++++++++++++ third_party/vulkan/vulkan_to_string.hpp | 195 ++- 12 files changed, 2486 insertions(+), 26 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index d6e6c55..1a82fbb 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -27,7 +27,7 @@ export module vulkan; export import std; -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 348, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 349, "Wrong VK_HEADER_VERSION!" ); #if defined( _MSC_VER ) # pragma warning( push ) @@ -1307,6 +1307,9 @@ export //=== VK_KHR_maintenance10 === using ::PFN_vkCmdEndRendering2KHR; + //=== VK_ARM_data_graph_optical_flow === + using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM; + //=== VK_NV_compute_occupancy_priority === using ::PFN_vkCmdSetComputeOccupancyPriorityNV; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 4c23d33..aff7b4c 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -37,7 +37,7 @@ # endif #endif -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 348, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 349, "Wrong VK_HEADER_VERSION!" ); VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { @@ -1747,6 +1747,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2 ) DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2KHR ) DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ) DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM ) DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM ) DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR ) @@ -8055,6 +8056,20 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return ::vkCmdEndRendering2KHR( commandBuffer, pRenderingEndInfo ); } + //=== VK_ARM_data_graph_optical_flow === + + VULKAN_HPP_INLINE VkResult vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkQueueFamilyDataGraphPropertiesARM const * pQueueFamilyDataGraphProperties, + VkDataGraphOpticalFlowImageFormatInfoARM const * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphProperties, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties ); + } + //=== VK_NV_compute_occupancy_priority === VULKAN_HPP_INLINE void vkCmdSetComputeOccupancyPriorityNV( VkCommandBuffer commandBuffer, @@ -10877,7 +10892,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME; //=== VK_NV_per_stage_descriptor_set === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_per_stage_descriptor_set extension has been deprecated by VK_EXT_descriptor_heap." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_per_stage_descriptor_set extension has been deprecated by VK_EXT_descriptor_heap." ) VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetExtensionName = VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME; //=== VK_QCOM_image_processing2 === @@ -11142,6 +11159,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME; + //=== VK_ARM_data_graph_optical_flow === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphOpticalFlowSpecVersion = VK_ARM_DATA_GRAPH_OPTICAL_FLOW_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphOpticalFlowExtensionName = VK_ARM_DATA_GRAPH_OPTICAL_FLOW_EXTENSION_NAME; + //=== VK_EXT_shader_long_vector === VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorSpecVersion = VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorExtensionName = VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME; @@ -21941,6 +21962,79 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_ARM_data_graph_optical_flow === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_shader_long_vector === template <> struct StructExtends @@ -23565,6 +23659,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_maintenance10 === PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0; + //=== VK_ARM_data_graph_optical_flow === + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = 0; + //=== VK_NV_compute_occupancy_priority === PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0; @@ -25294,6 +25391,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_maintenance10 === vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2KHR" ) ); + //=== VK_ARM_data_graph_optical_flow === + vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM" ) ); + //=== VK_NV_compute_occupancy_priority === vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetInstanceProcAddr( instance, "vkCmdSetComputeOccupancyPriorityNV" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index d633015..419c382 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 348 +#define VK_HEADER_VERSION 349 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -1429,6 +1429,15 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM = 1000631000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM = 1000631001, + VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM = 1000631003, + VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM = 1000631004, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM = 1000631005, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM = 1000631002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM = 1000631006, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM = 1000631007, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM = 1000631008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT = 1000635000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT = 1000635001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, @@ -7326,6 +7335,9 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x80000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM = 0x100000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM = 0x200000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM = 0x400000000000000ULL; typedef enum VkPipelineCreationFeedbackFlagBits { @@ -23435,6 +23447,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) typedef enum VkDataGraphPipelineSessionBindPointARM { VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM = 1000631001, VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF } VkDataGraphPipelineSessionBindPointARM; @@ -23460,6 +23473,7 @@ typedef enum VkPhysicalDeviceDataGraphOperationTypeARM { VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM = 1000631000, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF } VkPhysicalDeviceDataGraphOperationTypeARM; typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; @@ -23467,6 +23481,7 @@ typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; // Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL; +static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM = 0x00000002ULL; typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; @@ -25378,6 +25393,159 @@ typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM { +// VK_ARM_data_graph_optical_flow is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph_optical_flow 1 +#define VK_ARM_DATA_GRAPH_OPTICAL_FLOW_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_OPTICAL_FLOW_EXTENSION_NAME "VK_ARM_data_graph_optical_flow" + +typedef enum VkDataGraphOpticalFlowPerformanceLevelARM { + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM = 1, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM = 2, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM = 3, + VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowPerformanceLevelARM; + +typedef enum VkDataGraphPipelineNodeTypeARM { + VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM = 1000631000, + VK_DATA_GRAPH_PIPELINE_NODE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineNodeTypeARM; + +typedef enum VkDataGraphPipelineNodeConnectionTypeARM { + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM = 1000631000, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM = 1000631001, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM = 1000631002, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM = 1000631003, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM = 1000631004, + VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineNodeConnectionTypeARM; + +typedef enum VkDataGraphOpticalFlowGridSizeFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowGridSizeFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowGridSizeFlagsARM; + +typedef enum VkDataGraphOpticalFlowCreateFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM = 0x40000000, + VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowCreateFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowCreateFlagsARM; + +typedef enum VkDataGraphOpticalFlowImageUsageFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM = 0, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowImageUsageFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowImageUsageFlagsARM; + +typedef enum VkDataGraphOpticalFlowExecuteFlagBitsARM { + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM = 0x00000001, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM = 0x00000002, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM = 0x00000004, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM = 0x00000008, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM = 0x00000010, + VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphOpticalFlowExecuteFlagBitsARM; +typedef VkFlags VkDataGraphOpticalFlowExecuteFlagsARM; +typedef struct VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraphOpticalFlow; +} VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM; + +typedef struct VkQueueFamilyDataGraphOpticalFlowPropertiesARM { + VkStructureType sType; + void* pNext; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedOutputGridSizes; + VkDataGraphOpticalFlowGridSizeFlagsARM supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; +} VkQueueFamilyDataGraphOpticalFlowPropertiesARM; + +typedef struct VkDataGraphPipelineOpticalFlowCreateInfoARM { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkDataGraphOpticalFlowGridSizeFlagsARM outputGridSize; + VkDataGraphOpticalFlowGridSizeFlagsARM hintGridSize; + VkDataGraphOpticalFlowPerformanceLevelARM performanceLevel; + VkDataGraphOpticalFlowCreateFlagsARM flags; +} VkDataGraphPipelineOpticalFlowCreateInfoARM; + +typedef struct VkDataGraphOpticalFlowImageFormatPropertiesARM { + VkStructureType sType; + void* pNext; + VkFormat format; +} VkDataGraphOpticalFlowImageFormatPropertiesARM; + +typedef struct VkDataGraphOpticalFlowImageFormatInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphOpticalFlowImageUsageFlagsARM usage; +} VkDataGraphOpticalFlowImageFormatInfoARM; + +typedef struct VkDataGraphPipelineOpticalFlowDispatchInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphOpticalFlowExecuteFlagsARM flags; + uint32_t meanFlowL1NormHint; +} VkDataGraphPipelineOpticalFlowDispatchInfoARM; + +typedef struct VkDataGraphPipelineResourceInfoImageLayoutARM { + VkStructureType sType; + const void* pNext; + VkImageLayout layout; +} VkDataGraphPipelineResourceInfoImageLayoutARM; + +typedef struct VkDataGraphPipelineSingleNodeConnectionARM { + VkStructureType sType; + void* pNext; + uint32_t set; + uint32_t binding; + VkDataGraphPipelineNodeConnectionTypeARM connection; +} VkDataGraphPipelineSingleNodeConnectionARM; + +typedef struct VkDataGraphPipelineSingleNodeCreateInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelineNodeTypeARM nodeType; + uint32_t connectionCount; + const VkDataGraphPipelineSingleNodeConnectionARM* pConnections; +} VkDataGraphPipelineSingleNodeCreateInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties, + const VkDataGraphOpticalFlowImageFormatInfoARM* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkDataGraphOpticalFlowImageFormatPropertiesARM* pImageFormatProperties); +#endif +#endif + + // VK_EXT_shader_long_vector is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_shader_long_vector 1 #define VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION 1 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index c347d74..dc9f144 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -1807,6 +1807,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eRenderingEndInfoKHR = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT, eResolveImageModeInfoKHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR, + ePhysicalDeviceDataGraphOpticalFlowFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM, + eQueueFamilyDataGraphOpticalFlowPropertiesARM = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM, + eDataGraphOpticalFlowImageFormatInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM, + eDataGraphOpticalFlowImageFormatPropertiesARM = VK_STRUCTURE_TYPE_DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM, + eDataGraphPipelineOpticalFlowDispatchInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM, + eDataGraphPipelineOpticalFlowCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM, + eDataGraphPipelineResourceInfoImageLayoutARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM, + eDataGraphPipelineSingleNodeCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM, + eDataGraphPipelineSingleNodeConnectionARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM, ePhysicalDeviceShaderLongVectorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT, ePhysicalDeviceShaderLongVectorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT, ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, @@ -5368,7 +5377,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eDepthCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR, eDepthCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR, eStencilCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR, - eStencilCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR + eStencilCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR, + eDataGraphOpticalFlowImageARM = VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_IMAGE_BIT_ARM, + eDataGraphOpticalFlowVectorARM = VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_VECTOR_BIT_ARM, + eDataGraphOpticalFlowCostARM = VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLOW_COST_BIT_ARM }; using FormatFeatureFlagBits2KHR = FormatFeatureFlagBits2; @@ -5404,7 +5416,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR | FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR | FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR | FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR | - FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR; + FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR | + FormatFeatureFlagBits2::eDataGraphOpticalFlowImageARM | FormatFeatureFlagBits2::eDataGraphOpticalFlowVectorARM | + FormatFeatureFlagBits2::eDataGraphOpticalFlowCostARM; }; // wrapper class for enum VkPipelineCreationFeedbackFlagBits, see @@ -9257,7 +9271,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointARM.html enum class DataGraphPipelineSessionBindPointARM { - eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM + eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM, + eOpticalFlowCache = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_OPTICAL_FLOW_CACHE_ARM }; // wrapper class for enum VkDataGraphPipelineSessionBindPointTypeARM, see @@ -9271,7 +9286,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagBitsARM.html enum class DataGraphPipelineSessionCreateFlagBitsARM : VkDataGraphPipelineSessionCreateFlagsARM { - eProtected = VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM + eProtected = VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM, + eOpticalFlowCache = VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_OPTICAL_FLOW_CACHE_BIT_ARM }; // wrapper using for bitmask VkDataGraphPipelineSessionCreateFlagsARM, see @@ -9283,7 +9299,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { using WrappedType = VkDataGraphPipelineSessionCreateFlagBitsARM; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineSessionCreateFlagsARM allFlags = DataGraphPipelineSessionCreateFlagBitsARM::eProtected; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineSessionCreateFlagsARM allFlags = + DataGraphPipelineSessionCreateFlagBitsARM::eProtected | DataGraphPipelineSessionCreateFlagBitsARM::eOpticalFlowCache; }; // wrapper class for enum VkDataGraphPipelinePropertyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyARM.html @@ -9323,7 +9340,40 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM, eNeuralModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM, - eBuiltinModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM + eBuiltinModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM, + eOpticalFlow = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_OPTICAL_FLOW_ARM + }; + + //=== VK_ARM_data_graph_instruction_set_tosa === + + // wrapper class for enum VkDataGraphTOSAQualityFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphTOSAQualityFlagBitsARM.html + enum class DataGraphTOSAQualityFlagBitsARM : VkDataGraphTOSAQualityFlagsARM + { + eAccelerated = VK_DATA_GRAPH_TOSA_QUALITY_ACCELERATED_ARM, + eConformant = VK_DATA_GRAPH_TOSA_QUALITY_CONFORMANT_ARM, + eExperimental = VK_DATA_GRAPH_TOSA_QUALITY_EXPERIMENTAL_ARM, + eDeprecated = VK_DATA_GRAPH_TOSA_QUALITY_DEPRECATED_ARM + }; + + // wrapper using for bitmask VkDataGraphTOSAQualityFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphTOSAQualityFlagsARM.html + using DataGraphTOSAQualityFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphTOSAQualityFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphTOSAQualityFlagsARM allFlags = + DataGraphTOSAQualityFlagBitsARM::eAccelerated | DataGraphTOSAQualityFlagBitsARM::eConformant | DataGraphTOSAQualityFlagBitsARM::eExperimental | + DataGraphTOSAQualityFlagBitsARM::eDeprecated; + }; + + // wrapper class for enum VkDataGraphTOSALevelARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphTOSALevelARM.html + enum class DataGraphTOSALevelARM + { + eNone = VK_DATA_GRAPH_TOSA_LEVEL_NONE_ARM, + e8K = VK_DATA_GRAPH_TOSA_LEVEL_8K_ARM }; //=== VK_ARM_data_graph_instruction_set_tosa === @@ -10074,6 +10124,134 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ResolveImageFlagBitsKHR::eSkipTransferFunction | ResolveImageFlagBitsKHR::eEnableTransferFunction; }; + //=== VK_ARM_data_graph_optical_flow === + + // wrapper class for enum VkDataGraphOpticalFlowImageUsageFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageUsageFlagBitsARM.html + enum class DataGraphOpticalFlowImageUsageFlagBitsARM : VkDataGraphOpticalFlowImageUsageFlagsARM + { + eUnknown = VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_UNKNOWN_ARM, + eInput = VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_INPUT_BIT_ARM, + eOutput = VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_OUTPUT_BIT_ARM, + eHint = VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_HINT_BIT_ARM, + eCost = VK_DATA_GRAPH_OPTICAL_FLOW_IMAGE_USAGE_COST_BIT_ARM + }; + + // wrapper using for bitmask VkDataGraphOpticalFlowImageUsageFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageUsageFlagsARM.html + using DataGraphOpticalFlowImageUsageFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphOpticalFlowImageUsageFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphOpticalFlowImageUsageFlagsARM allFlags = + DataGraphOpticalFlowImageUsageFlagBitsARM::eUnknown | DataGraphOpticalFlowImageUsageFlagBitsARM::eInput | + DataGraphOpticalFlowImageUsageFlagBitsARM::eOutput | DataGraphOpticalFlowImageUsageFlagBitsARM::eHint | DataGraphOpticalFlowImageUsageFlagBitsARM::eCost; + }; + + // wrapper class for enum VkDataGraphOpticalFlowCreateFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowCreateFlagBitsARM.html + enum class DataGraphOpticalFlowCreateFlagBitsARM : VkDataGraphOpticalFlowCreateFlagsARM + { + eEnableHint = VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_HINT_BIT_ARM, + eEnableCost = VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_ENABLE_COST_BIT_ARM, + eReserved30 = VK_DATA_GRAPH_OPTICAL_FLOW_CREATE_RESERVED_30_BIT_ARM + }; + + // wrapper using for bitmask VkDataGraphOpticalFlowCreateFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowCreateFlagsARM.html + using DataGraphOpticalFlowCreateFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphOpticalFlowCreateFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphOpticalFlowCreateFlagsARM allFlags = DataGraphOpticalFlowCreateFlagBitsARM::eEnableHint | + DataGraphOpticalFlowCreateFlagBitsARM::eEnableCost | + DataGraphOpticalFlowCreateFlagBitsARM::eReserved30; + }; + + // wrapper class for enum VkDataGraphOpticalFlowPerformanceLevelARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowPerformanceLevelARM.html + enum class DataGraphOpticalFlowPerformanceLevelARM + { + eUnknown = VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_ARM, + eSlow = VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_ARM, + eMedium = VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_ARM, + eFast = VK_DATA_GRAPH_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_ARM + }; + + // wrapper class for enum VkDataGraphOpticalFlowGridSizeFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowGridSizeFlagBitsARM.html + enum class DataGraphOpticalFlowGridSizeFlagBitsARM : VkDataGraphOpticalFlowGridSizeFlagsARM + { + eUnknown = VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_ARM, + e1X1 = VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_ARM, + e2X2 = VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_ARM, + e4X4 = VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_ARM, + e8X8 = VK_DATA_GRAPH_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_ARM + }; + + // wrapper using for bitmask VkDataGraphOpticalFlowGridSizeFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowGridSizeFlagsARM.html + using DataGraphOpticalFlowGridSizeFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphOpticalFlowGridSizeFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphOpticalFlowGridSizeFlagsARM allFlags = + DataGraphOpticalFlowGridSizeFlagBitsARM::eUnknown | DataGraphOpticalFlowGridSizeFlagBitsARM::e1X1 | DataGraphOpticalFlowGridSizeFlagBitsARM::e2X2 | + DataGraphOpticalFlowGridSizeFlagBitsARM::e4X4 | DataGraphOpticalFlowGridSizeFlagBitsARM::e8X8; + }; + + // wrapper class for enum VkDataGraphOpticalFlowExecuteFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowExecuteFlagBitsARM.html + enum class DataGraphOpticalFlowExecuteFlagBitsARM : VkDataGraphOpticalFlowExecuteFlagsARM + { + eDisableTemporalHints = VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_ARM, + eInputUnchanged = VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_UNCHANGED_BIT_ARM, + eReferenceUnchanged = VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_UNCHANGED_BIT_ARM, + eInputIsPreviousReference = VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_INPUT_IS_PREVIOUS_REFERENCE_BIT_ARM, + eReferenceIsPreviousInput = VK_DATA_GRAPH_OPTICAL_FLOW_EXECUTE_REFERENCE_IS_PREVIOUS_INPUT_BIT_ARM + }; + + // wrapper using for bitmask VkDataGraphOpticalFlowExecuteFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowExecuteFlagsARM.html + using DataGraphOpticalFlowExecuteFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphOpticalFlowExecuteFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphOpticalFlowExecuteFlagsARM allFlags = + DataGraphOpticalFlowExecuteFlagBitsARM::eDisableTemporalHints | DataGraphOpticalFlowExecuteFlagBitsARM::eInputUnchanged | + DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceUnchanged | DataGraphOpticalFlowExecuteFlagBitsARM::eInputIsPreviousReference | + DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceIsPreviousInput; + }; + + // wrapper class for enum VkDataGraphPipelineNodeTypeARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineNodeTypeARM.html + enum class DataGraphPipelineNodeTypeARM + { + eOpticalFlow = VK_DATA_GRAPH_PIPELINE_NODE_TYPE_OPTICAL_FLOW_ARM + }; + + // wrapper class for enum VkDataGraphPipelineNodeConnectionTypeARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineNodeConnectionTypeARM.html + enum class DataGraphPipelineNodeConnectionTypeARM + { + eOpticalFlowInput = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_INPUT_ARM, + eOpticalFlowReference = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_REFERENCE_ARM, + eOpticalFlowHint = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_HINT_ARM, + eOpticalFlowFlowVector = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_FLOW_VECTOR_ARM, + eOpticalFlowCost = VK_DATA_GRAPH_PIPELINE_NODE_CONNECTION_TYPE_OPTICAL_FLOW_COST_ARM + }; + #if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 4aee088..97973e2 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -75,9 +75,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { "VK_EXT_validation_features", "VK_EXT_layer_settings" }, { "VK_EXT_descriptor_buffer", "VK_EXT_descriptor_heap" }, #if defined( VK_ENABLE_BETA_EXTENSIONS ) - { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" } + { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" }, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; + { "VK_NV_per_stage_descriptor_set", "VK_EXT_descriptor_heap" } }; return deprecatedExtensions; } @@ -527,6 +527,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_EXT_custom_resolve", "VK_QCOM_data_graph_model", "VK_KHR_maintenance10", + "VK_ARM_data_graph_optical_flow", "VK_EXT_shader_long_vector", "VK_SEC_pipeline_cache_incremental_mode", "VK_EXT_shader_uniform_buffer_unsized_array", @@ -3106,6 +3107,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_data_graph_optical_flow", + { { "VK_VERSION_1_0", + { { + "VK_ARM_data_graph", + } } } } }, { "VK_EXT_shader_long_vector", { { "VK_VERSION_1_2", { {} } } } }, { "VK_SEC_pipeline_cache_incremental_mode", { { "VK_VERSION_1_0", @@ -3408,7 +3414,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return "VK_NV_cluster_acceleration_structure"; } #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - + if ( extension == "VK_NV_per_stage_descriptor_set" ) + { + return "VK_EXT_descriptor_heap"; + } return ""; } @@ -3900,7 +3909,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) || ( extension == "VK_NV_displacement_micromap" ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || false; + || ( extension == "VK_NV_per_stage_descriptor_set" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ) @@ -4127,10 +4136,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) || ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) || ( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) || - ( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || - ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) || - ( extension == "VK_EXT_shader_subgroup_partitioned" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) || - ( extension == "VK_EXT_primitive_restart_index" ); + ( extension == "VK_ARM_data_graph_optical_flow" ) || ( extension == "VK_EXT_shader_long_vector" ) || + ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || + ( extension == "VK_NV_compute_occupancy_priority" ) || ( extension == "VK_EXT_shader_subgroup_partitioned" ) || + ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) || ( extension == "VK_EXT_primitive_restart_index" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index c5a54d7..8a32c11 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -30877,8 +30877,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM && - "Function requires " ); + VULKAN_HPP_ASSERT( + d.vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM && + "Function requires or " ); # endif BaseOutStructure properties; @@ -32949,6 +32950,142 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_ARM_data_graph_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM( + uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const * pQueueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + DataGraphOpticalFlowImageFormatPropertiesARM * pImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + static_cast( m_physicalDevice ), + queueFamilyIndex, + reinterpret_cast( pQueueFamilyDataGraphProperties ), + reinterpret_cast( pOpticalFlowImageFormatInfo ), + pFormatCount, + reinterpret_cast( pImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM && + "Function requires " ); +# endif + + std::vector imageFormatProperties; + uint32_t formatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + m_physicalDevice, + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + m_physicalDevice, + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM( + uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo, + DataGraphOpticalFlowImageFormatPropertiesARMAllocator const & dataGraphOpticalFlowImageFormatPropertiesARMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM && + "Function requires " ); +# endif + + std::vector imageFormatProperties( + dataGraphOpticalFlowImageFormatPropertiesARMAllocator ); + uint32_t formatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + m_physicalDevice, + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + m_physicalDevice, + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_compute_occupancy_priority === // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 9dbddce..e978161 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -2369,6 +2369,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct RenderingAttachmentFlagsInfoKHR; struct ResolveImageModeInfoKHR; + //=== VK_ARM_data_graph_optical_flow === + struct PhysicalDeviceDataGraphOpticalFlowFeaturesARM; + struct QueueFamilyDataGraphOpticalFlowPropertiesARM; + struct DataGraphPipelineOpticalFlowCreateInfoARM; + struct DataGraphOpticalFlowImageFormatPropertiesARM; + struct DataGraphOpticalFlowImageFormatInfoARM; + struct DataGraphPipelineOpticalFlowDispatchInfoARM; + struct DataGraphPipelineResourceInfoImageLayoutARM; + struct DataGraphPipelineSingleNodeCreateInfoARM; + struct DataGraphPipelineSingleNodeConnectionARM; + //=== VK_EXT_shader_long_vector === struct PhysicalDeviceShaderLongVectorFeaturesEXT; struct PhysicalDeviceShaderLongVectorPropertiesEXT; @@ -22371,6 +22382,52 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_ARM_data_graph_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const * pQueueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + DataGraphOpticalFlowImageFormatPropertiesARM * pImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if< + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if< + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getQueueFamilyDataGraphOpticalFlowImageFormatsARM( + uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo, + DataGraphOpticalFlowImageFormatPropertiesARMAllocator const & dataGraphOpticalFlowImageFormatPropertiesARMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + #if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 5853362..892c415 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -3682,6 +3682,34 @@ VULKAN_HPP_EXPORT namespace std }; # endif /*VK_USE_PLATFORM_WIN32_KHR*/ + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatInfoARM const & dataGraphOpticalFlowImageFormatInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatInfoARM.usage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatPropertiesARM const & dataGraphOpticalFlowImageFormatPropertiesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphOpticalFlowImageFormatPropertiesARM.format ); + return seed; + } + }; + template <> struct hash { @@ -3832,6 +3860,43 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowCreateInfoARM const & dataGraphPipelineOpticalFlowCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.width ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.height ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.imageFormat ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.flowVectorFormat ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.costFormat ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.outputGridSize ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.hintGridSize ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.performanceLevel ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowCreateInfoARM.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowDispatchInfoARM const & dataGraphPipelineOpticalFlowDispatchInfoARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowDispatchInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowDispatchInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowDispatchInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineOpticalFlowDispatchInfoARM.meanFlowL1NormHint ); + return seed; + } + }; + template <> struct hash { @@ -3849,6 +3914,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoImageLayoutARM const & dataGraphPipelineResourceInfoImageLayoutARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoImageLayoutARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoImageLayoutARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoImageLayoutARM.layout ); + return seed; + } + }; + template <> struct hash { @@ -3931,6 +4010,38 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeConnectionARM const & dataGraphPipelineSingleNodeConnectionARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeConnectionARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeConnectionARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeConnectionARM.set ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeConnectionARM.binding ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeConnectionARM.connection ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeCreateInfoARM const & dataGraphPipelineSingleNodeCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeCreateInfoARM.nodeType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeCreateInfoARM.connectionCount ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSingleNodeCreateInfoARM.pConnections ); + return seed; + } + }; + template <> struct hash { @@ -10453,6 +10564,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOpticalFlowFeaturesARM const & physicalDeviceDataGraphOpticalFlowFeaturesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOpticalFlowFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOpticalFlowFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOpticalFlowFeaturesARM.dataGraphOpticalFlow ); + return seed; + } + }; + template <> struct hash { @@ -17725,6 +17850,27 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphOpticalFlowPropertiesARM const & queueFamilyDataGraphOpticalFlowPropertiesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.supportedOutputGridSizes ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.supportedHintGridSizes ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.hintSupported ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.costSupported ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.minWidth ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.minHeight ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.maxWidth ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphOpticalFlowPropertiesARM.maxHeight ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index b5a268a..674b3bd 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -411,6 +411,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM = PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM" ) ); + //=== VK_ARM_data_graph_optical_flow === + vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM" ) ); + # if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === vkCreateUbmSurfaceSEC = PFN_vkCreateUbmSurfaceSEC( vkGetInstanceProcAddr( instance, "vkCreateUbmSurfaceSEC" ) ); @@ -727,6 +731,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_ARM_shader_instrumentation === PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM = 0; + //=== VK_ARM_data_graph_optical_flow === + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM = 0; + # if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === PFN_vkCreateUbmSurfaceSEC vkCreateUbmSurfaceSEC = 0; @@ -4348,6 +4355,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateShaderInstrumentationMetricsARM() const; + //=== VK_ARM_data_graph_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo ) const; + # if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === @@ -28712,8 +28728,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PhysicalDevice::getQueueFamilyDataGraphEngineOperationPropertiesARM( uint32_t queueFamilyIndex, QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties ) const { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM && - "Function requires " ); + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM && + "Function requires or " ); BaseOutStructure properties; Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM( @@ -29537,6 +29554,52 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE reinterpret_cast( renderingEndInfo.get() ) ); } + //=== VK_ARM_data_graph_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties, + DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM && + "Function requires " ); + + std::vector imageFormatProperties; + uint32_t formatCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + static_cast( m_physicalDevice ), + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM( + static_cast( m_physicalDevice ), + queueFamilyIndex, + reinterpret_cast( &queueFamilyDataGraphProperties ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + //=== VK_NV_compute_occupancy_priority === // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 807e0a5..87a41e5 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -10055,6 +10055,76 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "ResolveImageModeInfoKHR is not nothrow_move_constructible!" ); +//=== VK_ARM_data_graph_optical_flow === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOpticalFlowFeaturesARM ) == + sizeof( VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphOpticalFlowFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphOpticalFlowPropertiesARM ) == + sizeof( VkQueueFamilyDataGraphOpticalFlowPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyDataGraphOpticalFlowPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowCreateInfoARM ) == sizeof( VkDataGraphPipelineOpticalFlowCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineOpticalFlowCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatPropertiesARM ) == + sizeof( VkDataGraphOpticalFlowImageFormatPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphOpticalFlowImageFormatPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatInfoARM ) == sizeof( VkDataGraphOpticalFlowImageFormatInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphOpticalFlowImageFormatInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowDispatchInfoARM ) == + sizeof( VkDataGraphPipelineOpticalFlowDispatchInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineOpticalFlowDispatchInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoImageLayoutARM ) == + sizeof( VkDataGraphPipelineResourceInfoImageLayoutARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineResourceInfoImageLayoutARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeCreateInfoARM ) == sizeof( VkDataGraphPipelineSingleNodeCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSingleNodeCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeConnectionARM ) == sizeof( VkDataGraphPipelineSingleNodeConnectionARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSingleNodeConnectionARM is not nothrow_move_constructible!" ); + //=== VK_EXT_shader_long_vector === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderLongVectorFeaturesEXT ), diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 8b80e0a..4dde26d 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -36388,6 +36388,227 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_USE_PLATFORM_WIN32_KHR*/ + // wrapper struct for struct VkDataGraphOpticalFlowImageFormatInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageFormatInfoARM.html + struct DataGraphOpticalFlowImageFormatInfoARM + { + using NativeType = VkDataGraphOpticalFlowImageFormatInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphOpticalFlowImageFormatInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatInfoARM( DataGraphOpticalFlowImageUsageFlagsARM usage_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatInfoARM( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphOpticalFlowImageFormatInfoARM( VkDataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphOpticalFlowImageFormatInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphOpticalFlowImageFormatInfoARM & operator=( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphOpticalFlowImageFormatInfoARM & operator=( VkDataGraphOpticalFlowImageFormatInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM & setUsage( DataGraphOpticalFlowImageUsageFlagsARM usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphOpticalFlowImageFormatInfoARM && setUsage( DataGraphOpticalFlowImageUsageFlagsARM usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphOpticalFlowImageFormatInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphOpticalFlowImageFormatInfoARM const & ) const = default; +#else + bool operator==( DataGraphOpticalFlowImageFormatInfoARM 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 ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( DataGraphOpticalFlowImageFormatInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphOpticalFlowImageFormatInfoARM; + void const * pNext = {}; + DataGraphOpticalFlowImageUsageFlagsARM usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphOpticalFlowImageFormatInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphOpticalFlowImageFormatInfoARM; + }; + + // wrapper struct for struct VkDataGraphOpticalFlowImageFormatPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphOpticalFlowImageFormatPropertiesARM.html + struct DataGraphOpticalFlowImageFormatPropertiesARM + { + using NativeType = VkDataGraphOpticalFlowImageFormatPropertiesARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatPropertiesARM( Format format_ = Format::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphOpticalFlowImageFormatPropertiesARM( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphOpticalFlowImageFormatPropertiesARM( VkDataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphOpticalFlowImageFormatPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphOpticalFlowImageFormatPropertiesARM & operator=( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphOpticalFlowImageFormatPropertiesARM & operator=( VkDataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDataGraphOpticalFlowImageFormatPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphOpticalFlowImageFormatPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphOpticalFlowImageFormatPropertiesARM const & ) const = default; +#else + bool operator==( DataGraphOpticalFlowImageFormatPropertiesARM 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 ) && ( format == rhs.format ); +# endif + } + + bool operator!=( DataGraphOpticalFlowImageFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM; + void * pNext = {}; + Format format = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphOpticalFlowImageFormatPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphOpticalFlowImageFormatPropertiesARM; + }; + // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html struct PhysicalDeviceDataGraphOperationSupportARM @@ -37870,6 +38091,409 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DataGraphPipelineInfoARM; }; + // wrapper struct for struct VkDataGraphPipelineOpticalFlowCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineOpticalFlowCreateInfoARM.html + struct DataGraphPipelineOpticalFlowCreateInfoARM + { + using NativeType = VkDataGraphPipelineOpticalFlowCreateInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DataGraphPipelineOpticalFlowCreateInfoARM( uint32_t width_ = {}, + uint32_t height_ = {}, + Format imageFormat_ = Format::eUndefined, + Format flowVectorFormat_ = Format::eUndefined, + Format costFormat_ = Format::eUndefined, + DataGraphOpticalFlowGridSizeFlagsARM outputGridSize_ = {}, + DataGraphOpticalFlowGridSizeFlagsARM hintGridSize_ = {}, + DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ = DataGraphOpticalFlowPerformanceLevelARM::eUnknown, + DataGraphOpticalFlowCreateFlagsARM flags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , width{ width_ } + , height{ height_ } + , imageFormat{ imageFormat_ } + , flowVectorFormat{ flowVectorFormat_ } + , costFormat{ costFormat_ } + , outputGridSize{ outputGridSize_ } + , hintGridSize{ hintGridSize_ } + , performanceLevel{ performanceLevel_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowCreateInfoARM( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineOpticalFlowCreateInfoARM( VkDataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineOpticalFlowCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineOpticalFlowCreateInfoARM & operator=( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineOpticalFlowCreateInfoARM & operator=( VkDataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setFlowVectorFormat( Format flowVectorFormat_ ) & VULKAN_HPP_NOEXCEPT + { + flowVectorFormat = flowVectorFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setFlowVectorFormat( Format flowVectorFormat_ ) && VULKAN_HPP_NOEXCEPT + { + flowVectorFormat = flowVectorFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setCostFormat( Format costFormat_ ) & VULKAN_HPP_NOEXCEPT + { + costFormat = costFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setCostFormat( Format costFormat_ ) && VULKAN_HPP_NOEXCEPT + { + costFormat = costFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setOutputGridSize( DataGraphOpticalFlowGridSizeFlagsARM outputGridSize_ ) & + VULKAN_HPP_NOEXCEPT + { + outputGridSize = outputGridSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setOutputGridSize( DataGraphOpticalFlowGridSizeFlagsARM outputGridSize_ ) && + VULKAN_HPP_NOEXCEPT + { + outputGridSize = outputGridSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setHintGridSize( DataGraphOpticalFlowGridSizeFlagsARM hintGridSize_ ) & + VULKAN_HPP_NOEXCEPT + { + hintGridSize = hintGridSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setHintGridSize( DataGraphOpticalFlowGridSizeFlagsARM hintGridSize_ ) && + VULKAN_HPP_NOEXCEPT + { + hintGridSize = hintGridSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setPerformanceLevel( DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ ) & + VULKAN_HPP_NOEXCEPT + { + performanceLevel = performanceLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setPerformanceLevel( DataGraphOpticalFlowPerformanceLevelARM performanceLevel_ ) && + VULKAN_HPP_NOEXCEPT + { + performanceLevel = performanceLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM & setFlags( DataGraphOpticalFlowCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowCreateInfoARM && setFlags( DataGraphOpticalFlowCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineOpticalFlowCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, width, height, imageFormat, flowVectorFormat, costFormat, outputGridSize, hintGridSize, performanceLevel, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineOpticalFlowCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineOpticalFlowCreateInfoARM 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 ) && ( width == rhs.width ) && ( height == rhs.height ) && ( imageFormat == rhs.imageFormat ) && + ( flowVectorFormat == rhs.flowVectorFormat ) && ( costFormat == rhs.costFormat ) && ( outputGridSize == rhs.outputGridSize ) && + ( hintGridSize == rhs.hintGridSize ) && ( performanceLevel == rhs.performanceLevel ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( DataGraphPipelineOpticalFlowCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM; + void * pNext = {}; + uint32_t width = {}; + uint32_t height = {}; + Format imageFormat = Format::eUndefined; + Format flowVectorFormat = Format::eUndefined; + Format costFormat = Format::eUndefined; + DataGraphOpticalFlowGridSizeFlagsARM outputGridSize = {}; + DataGraphOpticalFlowGridSizeFlagsARM hintGridSize = {}; + DataGraphOpticalFlowPerformanceLevelARM performanceLevel = DataGraphOpticalFlowPerformanceLevelARM::eUnknown; + DataGraphOpticalFlowCreateFlagsARM flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineOpticalFlowCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineOpticalFlowCreateInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineOpticalFlowDispatchInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineOpticalFlowDispatchInfoARM.html + struct DataGraphPipelineOpticalFlowDispatchInfoARM + { + using NativeType = VkDataGraphPipelineOpticalFlowDispatchInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowDispatchInfoARM( DataGraphOpticalFlowExecuteFlagsARM flags_ = {}, + uint32_t meanFlowL1NormHint_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , meanFlowL1NormHint{ meanFlowL1NormHint_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineOpticalFlowDispatchInfoARM( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineOpticalFlowDispatchInfoARM( VkDataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineOpticalFlowDispatchInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineOpticalFlowDispatchInfoARM & operator=( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineOpticalFlowDispatchInfoARM & operator=( VkDataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setFlags( DataGraphOpticalFlowExecuteFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setFlags( DataGraphOpticalFlowExecuteFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM & setMeanFlowL1NormHint( uint32_t meanFlowL1NormHint_ ) & VULKAN_HPP_NOEXCEPT + { + meanFlowL1NormHint = meanFlowL1NormHint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineOpticalFlowDispatchInfoARM && setMeanFlowL1NormHint( uint32_t meanFlowL1NormHint_ ) && VULKAN_HPP_NOEXCEPT + { + meanFlowL1NormHint = meanFlowL1NormHint_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineOpticalFlowDispatchInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowDispatchInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowDispatchInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineOpticalFlowDispatchInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, meanFlowL1NormHint ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineOpticalFlowDispatchInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineOpticalFlowDispatchInfoARM 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 ) && ( flags == rhs.flags ) && ( meanFlowL1NormHint == rhs.meanFlowL1NormHint ); +# endif + } + + bool operator!=( DataGraphPipelineOpticalFlowDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM; + void * pNext = {}; + DataGraphOpticalFlowExecuteFlagsARM flags = {}; + uint32_t meanFlowL1NormHint = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineOpticalFlowDispatchInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineOpticalFlowDispatchInfoARM; + }; + // wrapper struct for struct VkDataGraphPipelinePropertyQueryResultARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyQueryResultARM.html struct DataGraphPipelinePropertyQueryResultARM @@ -38062,6 +38686,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DataGraphPipelinePropertyQueryResultARM; }; + // wrapper struct for struct VkDataGraphPipelineResourceInfoImageLayoutARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineResourceInfoImageLayoutARM.html + struct DataGraphPipelineResourceInfoImageLayoutARM + { + using NativeType = VkDataGraphPipelineResourceInfoImageLayoutARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineResourceInfoImageLayoutARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoImageLayoutARM( ImageLayout layout_ = ImageLayout::eUndefined, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , layout{ layout_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoImageLayoutARM( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineResourceInfoImageLayoutARM( VkDataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineResourceInfoImageLayoutARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineResourceInfoImageLayoutARM & operator=( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineResourceInfoImageLayoutARM & operator=( VkDataGraphPipelineResourceInfoImageLayoutARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoImageLayoutARM && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineResourceInfoImageLayoutARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoImageLayoutARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoImageLayoutARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoImageLayoutARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, layout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineResourceInfoImageLayoutARM const & ) const = default; +#else + bool operator==( DataGraphPipelineResourceInfoImageLayoutARM 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 ) && ( layout == rhs.layout ); +# endif + } + + bool operator!=( DataGraphPipelineResourceInfoImageLayoutARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineResourceInfoImageLayoutARM; + void const * pNext = {}; + ImageLayout layout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineResourceInfoImageLayoutARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineResourceInfoImageLayoutARM; + }; + // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementARM.html struct DataGraphPipelineSessionBindPointRequirementARM @@ -38838,6 +39586,344 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = DataGraphPipelineShaderModuleCreateInfoARM; }; + // wrapper struct for struct VkDataGraphPipelineSingleNodeConnectionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSingleNodeConnectionARM.html + struct DataGraphPipelineSingleNodeConnectionARM + { + using NativeType = VkDataGraphPipelineSingleNodeConnectionARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSingleNodeConnectionARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSingleNodeConnectionARM( uint32_t set_ = {}, + uint32_t binding_ = {}, + DataGraphPipelineNodeConnectionTypeARM connection_ = DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowInput, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , set{ set_ } + , binding{ binding_ } + , connection{ connection_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeConnectionARM( DataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSingleNodeConnectionARM( VkDataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSingleNodeConnectionARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSingleNodeConnectionARM & operator=( DataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSingleNodeConnectionARM & operator=( VkDataGraphPipelineSingleNodeConnectionARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT + { + set = set_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT + { + set = set_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM & setConnection( DataGraphPipelineNodeConnectionTypeARM connection_ ) & VULKAN_HPP_NOEXCEPT + { + connection = connection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeConnectionARM && setConnection( DataGraphPipelineNodeConnectionTypeARM connection_ ) && + VULKAN_HPP_NOEXCEPT + { + connection = connection_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSingleNodeConnectionARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeConnectionARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeConnectionARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeConnectionARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, set, binding, connection ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSingleNodeConnectionARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSingleNodeConnectionARM 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 ) && ( set == rhs.set ) && ( binding == rhs.binding ) && ( connection == rhs.connection ); +# endif + } + + bool operator!=( DataGraphPipelineSingleNodeConnectionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSingleNodeConnectionARM; + void * pNext = {}; + uint32_t set = {}; + uint32_t binding = {}; + DataGraphPipelineNodeConnectionTypeARM connection = DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowInput; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSingleNodeConnectionARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSingleNodeConnectionARM; + }; + + // wrapper struct for struct VkDataGraphPipelineSingleNodeCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSingleNodeCreateInfoARM.html + struct DataGraphPipelineSingleNodeCreateInfoARM + { + using NativeType = VkDataGraphPipelineSingleNodeCreateInfoARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSingleNodeCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineNodeTypeARM nodeType_ = DataGraphPipelineNodeTypeARM::eOpticalFlow, + uint32_t connectionCount_ = {}, + DataGraphPipelineSingleNodeConnectionARM const * pConnections_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , nodeType{ nodeType_ } + , connectionCount{ connectionCount_ } + , pConnections{ pConnections_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSingleNodeCreateInfoARM( VkDataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSingleNodeCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineSingleNodeCreateInfoARM( DataGraphPipelineNodeTypeARM nodeType_, + ArrayProxyNoTemporaries const & connections_, + void * pNext_ = nullptr ) + : pNext( pNext_ ), nodeType( nodeType_ ), connectionCount( static_cast( connections_.size() ) ), pConnections( connections_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphPipelineSingleNodeCreateInfoARM & operator=( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSingleNodeCreateInfoARM & operator=( VkDataGraphPipelineSingleNodeCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setNodeType( DataGraphPipelineNodeTypeARM nodeType_ ) & VULKAN_HPP_NOEXCEPT + { + nodeType = nodeType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setNodeType( DataGraphPipelineNodeTypeARM nodeType_ ) && VULKAN_HPP_NOEXCEPT + { + nodeType = nodeType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setConnectionCount( uint32_t connectionCount_ ) & VULKAN_HPP_NOEXCEPT + { + connectionCount = connectionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setConnectionCount( uint32_t connectionCount_ ) && VULKAN_HPP_NOEXCEPT + { + connectionCount = connectionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM & setPConnections( DataGraphPipelineSingleNodeConnectionARM const * pConnections_ ) & + VULKAN_HPP_NOEXCEPT + { + pConnections = pConnections_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSingleNodeCreateInfoARM && setPConnections( DataGraphPipelineSingleNodeConnectionARM const * pConnections_ ) && + VULKAN_HPP_NOEXCEPT + { + pConnections = pConnections_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineSingleNodeCreateInfoARM & + setConnections( ArrayProxyNoTemporaries const & connections_ ) VULKAN_HPP_NOEXCEPT + { + connectionCount = static_cast( connections_.size() ); + pConnections = connections_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSingleNodeCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSingleNodeCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, nodeType, connectionCount, pConnections ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSingleNodeCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSingleNodeCreateInfoARM 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 ) && ( nodeType == rhs.nodeType ) && ( connectionCount == rhs.connectionCount ) && + ( pConnections == rhs.pConnections ); +# endif + } + + bool operator!=( DataGraphPipelineSingleNodeCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSingleNodeCreateInfoARM; + void * pNext = {}; + DataGraphPipelineNodeTypeARM nodeType = DataGraphPipelineNodeTypeARM::eOpticalFlow; + uint32_t connectionCount = {}; + DataGraphPipelineSingleNodeConnectionARM const * pConnections = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSingleNodeCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSingleNodeCreateInfoARM; + }; + // wrapper struct for struct VkPhysicalDeviceDataGraphProcessingEngineARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineARM.html struct PhysicalDeviceDataGraphProcessingEngineARM @@ -104295,6 +105381,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; }; + // wrapper struct for struct VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM.html + struct PhysicalDeviceDataGraphOpticalFlowFeaturesARM + { + using NativeType = VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphOpticalFlowFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphOpticalFlowFeaturesARM( Bool32 dataGraphOpticalFlow_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataGraphOpticalFlow{ dataGraphOpticalFlow_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDataGraphOpticalFlowFeaturesARM( PhysicalDeviceDataGraphOpticalFlowFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphOpticalFlowFeaturesARM( VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphOpticalFlowFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDataGraphOpticalFlowFeaturesARM & operator=( PhysicalDeviceDataGraphOpticalFlowFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphOpticalFlowFeaturesARM & operator=( VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOpticalFlowFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOpticalFlowFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOpticalFlowFeaturesARM & setDataGraphOpticalFlow( Bool32 dataGraphOpticalFlow_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphOpticalFlow = dataGraphOpticalFlow_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOpticalFlowFeaturesARM && setDataGraphOpticalFlow( Bool32 dataGraphOpticalFlow_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphOpticalFlow = dataGraphOpticalFlow_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOpticalFlowFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataGraphOpticalFlow ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDataGraphOpticalFlowFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDataGraphOpticalFlowFeaturesARM 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 ) && ( dataGraphOpticalFlow == rhs.dataGraphOpticalFlow ); +# endif + } + + bool operator!=( PhysicalDeviceDataGraphOpticalFlowFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDataGraphOpticalFlowFeaturesARM; + void * pNext = {}; + Bool32 dataGraphOpticalFlow = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphOpticalFlowFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphOpticalFlowFeaturesARM; + }; + // wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV @@ -168479,6 +169689,137 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = QueueFamilyCheckpointPropertiesNV; }; + // wrapper struct for struct VkQueueFamilyDataGraphOpticalFlowPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphOpticalFlowPropertiesARM.html + struct QueueFamilyDataGraphOpticalFlowPropertiesARM + { + using NativeType = VkQueueFamilyDataGraphOpticalFlowPropertiesARM; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyDataGraphOpticalFlowPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyDataGraphOpticalFlowPropertiesARM( DataGraphOpticalFlowGridSizeFlagsARM supportedOutputGridSizes_ = {}, + DataGraphOpticalFlowGridSizeFlagsARM supportedHintGridSizes_ = {}, + Bool32 hintSupported_ = {}, + Bool32 costSupported_ = {}, + uint32_t minWidth_ = {}, + uint32_t minHeight_ = {}, + uint32_t maxWidth_ = {}, + uint32_t maxHeight_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedOutputGridSizes{ supportedOutputGridSizes_ } + , supportedHintGridSizes{ supportedHintGridSizes_ } + , hintSupported{ hintSupported_ } + , costSupported{ costSupported_ } + , minWidth{ minWidth_ } + , minHeight{ minHeight_ } + , maxWidth{ maxWidth_ } + , maxHeight{ maxHeight_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyDataGraphOpticalFlowPropertiesARM( QueueFamilyDataGraphOpticalFlowPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyDataGraphOpticalFlowPropertiesARM( VkQueueFamilyDataGraphOpticalFlowPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyDataGraphOpticalFlowPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyDataGraphOpticalFlowPropertiesARM & operator=( QueueFamilyDataGraphOpticalFlowPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyDataGraphOpticalFlowPropertiesARM & operator=( VkQueueFamilyDataGraphOpticalFlowPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyDataGraphOpticalFlowPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphOpticalFlowPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphOpticalFlowPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphOpticalFlowPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportedOutputGridSizes, supportedHintGridSizes, hintSupported, costSupported, minWidth, minHeight, maxWidth, maxHeight ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyDataGraphOpticalFlowPropertiesARM const & ) const = default; +#else + bool operator==( QueueFamilyDataGraphOpticalFlowPropertiesARM 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 ) && ( supportedOutputGridSizes == rhs.supportedOutputGridSizes ) && + ( supportedHintGridSizes == rhs.supportedHintGridSizes ) && ( hintSupported == rhs.hintSupported ) && ( costSupported == rhs.costSupported ) && + ( minWidth == rhs.minWidth ) && ( minHeight == rhs.minHeight ) && ( maxWidth == rhs.maxWidth ) && ( maxHeight == rhs.maxHeight ); +# endif + } + + bool operator!=( QueueFamilyDataGraphOpticalFlowPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyDataGraphOpticalFlowPropertiesARM; + void * pNext = {}; + DataGraphOpticalFlowGridSizeFlagsARM supportedOutputGridSizes = {}; + DataGraphOpticalFlowGridSizeFlagsARM supportedHintGridSizes = {}; + Bool32 hintSupported = {}; + Bool32 costSupported = {}; + uint32_t minWidth = {}; + uint32_t minHeight = {}; + uint32_t maxWidth = {}; + uint32_t maxHeight = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyDataGraphOpticalFlowPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyDataGraphOpticalFlowPropertiesARM; + }; + // wrapper struct for struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphProcessingEnginePropertiesARM.html struct QueueFamilyDataGraphProcessingEnginePropertiesARM diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 3d2caf7..72fff97 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -1988,6 +1988,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE result += " StencilCopyOnComputeQueueKHR |"; if ( value & FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR ) result += " StencilCopyOnTransferQueueKHR |"; + if ( value & FormatFeatureFlagBits2::eDataGraphOpticalFlowImageARM ) + result += " DataGraphOpticalFlowImageARM |"; + if ( value & FormatFeatureFlagBits2::eDataGraphOpticalFlowVectorARM ) + result += " DataGraphOpticalFlowVectorARM |"; + if ( value & FormatFeatureFlagBits2::eDataGraphOpticalFlowCostARM ) + result += " DataGraphOpticalFlowCostARM |"; if ( result.size() > 1 ) result.back() = '}'; @@ -4097,6 +4103,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE std::string result = "{"; if ( value & DataGraphPipelineSessionCreateFlagBitsARM::eProtected ) result += " Protected |"; + if ( value & DataGraphPipelineSessionCreateFlagBitsARM::eOpticalFlowCache ) + result += " OpticalFlowCache |"; if ( result.size() > 1 ) result.back() = '}'; @@ -4480,6 +4488,84 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return result; } + //=== VK_ARM_data_graph_optical_flow === + + VULKAN_HPP_INLINE std::string to_string( DataGraphOpticalFlowImageUsageFlagsARM value ) + { + std::string result = "{"; + if ( value & DataGraphOpticalFlowImageUsageFlagBitsARM::eInput ) + result += " Input |"; + if ( value & DataGraphOpticalFlowImageUsageFlagBitsARM::eOutput ) + result += " Output |"; + if ( value & DataGraphOpticalFlowImageUsageFlagBitsARM::eHint ) + result += " Hint |"; + if ( value & DataGraphOpticalFlowImageUsageFlagBitsARM::eCost ) + result += " Cost |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Unknown"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DataGraphOpticalFlowCreateFlagsARM value ) + { + std::string result = "{"; + if ( value & DataGraphOpticalFlowCreateFlagBitsARM::eEnableHint ) + result += " EnableHint |"; + if ( value & DataGraphOpticalFlowCreateFlagBitsARM::eEnableCost ) + result += " EnableCost |"; + if ( value & DataGraphOpticalFlowCreateFlagBitsARM::eReserved30 ) + result += " Reserved30 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DataGraphOpticalFlowGridSizeFlagsARM value ) + { + std::string result = "{"; + if ( value & DataGraphOpticalFlowGridSizeFlagBitsARM::e1X1 ) + result += " 1X1 |"; + if ( value & DataGraphOpticalFlowGridSizeFlagBitsARM::e2X2 ) + result += " 2X2 |"; + if ( value & DataGraphOpticalFlowGridSizeFlagBitsARM::e4X4 ) + result += " 4X4 |"; + if ( value & DataGraphOpticalFlowGridSizeFlagBitsARM::e8X8 ) + result += " 8X8 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Unknown"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DataGraphOpticalFlowExecuteFlagsARM value ) + { + std::string result = "{"; + if ( value & DataGraphOpticalFlowExecuteFlagBitsARM::eDisableTemporalHints ) + result += " DisableTemporalHints |"; + if ( value & DataGraphOpticalFlowExecuteFlagBitsARM::eInputUnchanged ) + result += " InputUnchanged |"; + if ( value & DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceUnchanged ) + result += " ReferenceUnchanged |"; + if ( value & DataGraphOpticalFlowExecuteFlagBitsARM::eInputIsPreviousReference ) + result += " InputIsPreviousReference |"; + if ( value & DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceIsPreviousInput ) + result += " ReferenceIsPreviousInput |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + #if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface === @@ -5826,6 +5912,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR"; case StructureType::eRenderingEndInfoKHR : return "RenderingEndInfoKHR"; case StructureType::eResolveImageModeInfoKHR : return "ResolveImageModeInfoKHR"; + case StructureType::ePhysicalDeviceDataGraphOpticalFlowFeaturesARM : return "PhysicalDeviceDataGraphOpticalFlowFeaturesARM"; + case StructureType::eQueueFamilyDataGraphOpticalFlowPropertiesARM : return "QueueFamilyDataGraphOpticalFlowPropertiesARM"; + case StructureType::eDataGraphOpticalFlowImageFormatInfoARM : return "DataGraphOpticalFlowImageFormatInfoARM"; + case StructureType::eDataGraphOpticalFlowImageFormatPropertiesARM : return "DataGraphOpticalFlowImageFormatPropertiesARM"; + case StructureType::eDataGraphPipelineOpticalFlowDispatchInfoARM : return "DataGraphPipelineOpticalFlowDispatchInfoARM"; + case StructureType::eDataGraphPipelineOpticalFlowCreateInfoARM : return "DataGraphPipelineOpticalFlowCreateInfoARM"; + case StructureType::eDataGraphPipelineResourceInfoImageLayoutARM : return "DataGraphPipelineResourceInfoImageLayoutARM"; + case StructureType::eDataGraphPipelineSingleNodeCreateInfoARM : return "DataGraphPipelineSingleNodeCreateInfoARM"; + case StructureType::eDataGraphPipelineSingleNodeConnectionARM : return "DataGraphPipelineSingleNodeConnectionARM"; case StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT : return "PhysicalDeviceShaderLongVectorFeaturesEXT"; case StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT : return "PhysicalDeviceShaderLongVectorPropertiesEXT"; case StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : return "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"; @@ -8161,6 +8256,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR : return "DepthCopyOnTransferQueueKHR"; case FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR : return "StencilCopyOnComputeQueueKHR"; case FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR : return "StencilCopyOnTransferQueueKHR"; + case FormatFeatureFlagBits2::eDataGraphOpticalFlowImageARM : return "DataGraphOpticalFlowImageARM"; + case FormatFeatureFlagBits2::eDataGraphOpticalFlowVectorARM : return "DataGraphOpticalFlowVectorARM"; + case FormatFeatureFlagBits2::eDataGraphOpticalFlowCostARM : return "DataGraphOpticalFlowCostARM"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10710,8 +10808,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case DataGraphPipelineSessionBindPointARM::eTransient: return "Transient"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case DataGraphPipelineSessionBindPointARM::eTransient : return "Transient"; + case DataGraphPipelineSessionBindPointARM::eOpticalFlowCache: return "OpticalFlowCache"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10728,8 +10827,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { switch ( value ) { - case DataGraphPipelineSessionCreateFlagBitsARM::eProtected: return "Protected"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + case DataGraphPipelineSessionCreateFlagBitsARM::eProtected : return "Protected"; + case DataGraphPipelineSessionCreateFlagBitsARM::eOpticalFlowCache: return "OpticalFlowCache"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -10766,6 +10866,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet"; case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM : return "NeuralModelQCOM"; case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM : return "BuiltinModelQCOM"; + case PhysicalDeviceDataGraphOperationTypeARM::eOpticalFlow : return "OpticalFlow"; default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; } } @@ -11300,6 +11401,92 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } + //=== VK_ARM_data_graph_optical_flow === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphOpticalFlowImageUsageFlagBitsARM value ) + { + switch ( value ) + { + case DataGraphOpticalFlowImageUsageFlagBitsARM::eUnknown: return "Unknown"; + case DataGraphOpticalFlowImageUsageFlagBitsARM::eInput : return "Input"; + case DataGraphOpticalFlowImageUsageFlagBitsARM::eOutput : return "Output"; + case DataGraphOpticalFlowImageUsageFlagBitsARM::eHint : return "Hint"; + case DataGraphOpticalFlowImageUsageFlagBitsARM::eCost : return "Cost"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphOpticalFlowCreateFlagBitsARM value ) + { + switch ( value ) + { + case DataGraphOpticalFlowCreateFlagBitsARM::eEnableHint: return "EnableHint"; + case DataGraphOpticalFlowCreateFlagBitsARM::eEnableCost: return "EnableCost"; + case DataGraphOpticalFlowCreateFlagBitsARM::eReserved30: return "Reserved30"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphOpticalFlowPerformanceLevelARM value ) + { + switch ( value ) + { + case DataGraphOpticalFlowPerformanceLevelARM::eUnknown: return "Unknown"; + case DataGraphOpticalFlowPerformanceLevelARM::eSlow : return "Slow"; + case DataGraphOpticalFlowPerformanceLevelARM::eMedium : return "Medium"; + case DataGraphOpticalFlowPerformanceLevelARM::eFast : return "Fast"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphOpticalFlowGridSizeFlagBitsARM value ) + { + switch ( value ) + { + case DataGraphOpticalFlowGridSizeFlagBitsARM::eUnknown: return "Unknown"; + case DataGraphOpticalFlowGridSizeFlagBitsARM::e1X1 : return "1X1"; + case DataGraphOpticalFlowGridSizeFlagBitsARM::e2X2 : return "2X2"; + case DataGraphOpticalFlowGridSizeFlagBitsARM::e4X4 : return "4X4"; + case DataGraphOpticalFlowGridSizeFlagBitsARM::e8X8 : return "8X8"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphOpticalFlowExecuteFlagBitsARM value ) + { + switch ( value ) + { + case DataGraphOpticalFlowExecuteFlagBitsARM::eDisableTemporalHints : return "DisableTemporalHints"; + case DataGraphOpticalFlowExecuteFlagBitsARM::eInputUnchanged : return "InputUnchanged"; + case DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceUnchanged : return "ReferenceUnchanged"; + case DataGraphOpticalFlowExecuteFlagBitsARM::eInputIsPreviousReference: return "InputIsPreviousReference"; + case DataGraphOpticalFlowExecuteFlagBitsARM::eReferenceIsPreviousInput: return "ReferenceIsPreviousInput"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineNodeTypeARM value ) + { + switch ( value ) + { + case DataGraphPipelineNodeTypeARM::eOpticalFlow: return "OpticalFlow"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineNodeConnectionTypeARM value ) + { + switch ( value ) + { + case DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowInput : return "OpticalFlowInput"; + case DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowReference : return "OpticalFlowReference"; + case DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowHint : return "OpticalFlowHint"; + case DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowFlowVector: return "OpticalFlowFlowVector"; + case DataGraphPipelineNodeConnectionTypeARM::eOpticalFlowCost : return "OpticalFlowCost"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + #if defined( VK_USE_PLATFORM_UBM_SEC ) //=== VK_SEC_ubm_surface ===