kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-04-18 13:36:49 +02:00
Code Issues Packages Projects Releases Wiki Activity

[BOT] update dependencies

Browse Source
This commit is contained in:
kbJeff-8
2026-04-12 01:15:09 +00:00
committed by kbz_8
parent f9f4fc6425
commit 6f0beebdf9
12 changed files with 2486 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
third_party/vulkan/vulkan.cppm vendored
View File

@@ -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;

105
third_party/vulkan/vulkan.hpp vendored
View File

@@ -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<PhysicalDeviceDataGraphOpticalFlowFeaturesARM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDataGraphOpticalFlowFeaturesARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphPipelineOpticalFlowCreateInfoARM, DataGraphPipelineCreateInfoARM>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphOpticalFlowImageFormatInfoARM, PhysicalDeviceImageFormatInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphOpticalFlowImageFormatInfoARM, ImageCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphPipelineOpticalFlowDispatchInfoARM, DataGraphPipelineDispatchInfoARM>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphPipelineResourceInfoImageLayoutARM, DataGraphPipelineResourceInfoARM>
{
enum
{
value = true
};
};
template <>
struct StructExtends<DataGraphPipelineSingleNodeCreateInfoARM, DataGraphPipelineCreateInfoARM>
{
enum
{
value = true
};
};
//=== VK_EXT_shader_long_vector ===
template <>
struct StructExtends<PhysicalDeviceShaderLongVectorFeaturesEXT, PhysicalDeviceFeatures2>
@@ -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" ) );

170
third_party/vulkan/vulkan_core.h vendored
View File

@@ -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

190
third_party/vulkan/vulkan_enums.hpp vendored
View File

@@ -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<DataGraphTOSAQualityFlagBitsARM>;
template <>
struct FlagTraits<DataGraphTOSAQualityFlagBitsARM>
{
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<DataGraphOpticalFlowImageUsageFlagBitsARM>;
template <>
struct FlagTraits<DataGraphOpticalFlowImageUsageFlagBitsARM>
{
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<DataGraphOpticalFlowCreateFlagBitsARM>;
template <>
struct FlagTraits<DataGraphOpticalFlowCreateFlagBitsARM>
{
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<DataGraphOpticalFlowGridSizeFlagBitsARM>;
template <>
struct FlagTraits<DataGraphOpticalFlowGridSizeFlagBitsARM>
{
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<DataGraphOpticalFlowExecuteFlagBitsARM>;
template <>
struct FlagTraits<DataGraphOpticalFlowExecuteFlagBitsARM>
{
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 ===

25
third_party/vulkan/vulkan_extension_inspection.hpp vendored
View File

@@ -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 )

141
third_party/vulkan/vulkan_funcs.hpp vendored
View File

@@ -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 <vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM> requires <VK_ARM_data_graph_instruction_set_tosa>" );
VULKAN_HPP_ASSERT(
d.vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM &&
"Function <vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM> requires <VK_ARM_data_graph_instruction_set_tosa> or <VK_ARM_data_graph_optical_flow>" );
# 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 <typename Dispatch, typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::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<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
static_cast<VkPhysicalDevice>( m_physicalDevice ),
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( pQueueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( pOpticalFlowImageFormatInfo ),
pFormatCount,
reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( 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 <typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator,
typename Dispatch,
typename std::enable_if<
std::is_same<typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator::value_type, DataGraphOpticalFlowImageFormatPropertiesARM>::value,
int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator>>::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 <vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM> requires <VK_ARM_data_graph_optical_flow>" );
# endif
std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator> imageFormatProperties;
uint32_t formatCount;
Result result;
do
{
result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
m_physicalDevice,
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
nullptr ) );
if ( ( result == Result::eSuccess ) && formatCount )
{
imageFormatProperties.resize( formatCount );
result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
m_physicalDevice,
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( 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 <typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator,
typename Dispatch,
typename std::enable_if<
std::is_same<typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator::value_type, DataGraphOpticalFlowImageFormatPropertiesARM>::value,
int>::type,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::type>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
typename ResultValueType<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator>>::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 <vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM> requires <VK_ARM_data_graph_optical_flow>" );
# endif
std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator> imageFormatProperties(
dataGraphOpticalFlowImageFormatPropertiesARMAllocator );
uint32_t formatCount;
Result result;
do
{
result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
m_physicalDevice,
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
nullptr ) );
if ( ( result == Result::eSuccess ) && formatCount )
{
imageFormatProperties.resize( formatCount );
result = static_cast<Result>( d.vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
m_physicalDevice,
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( 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

57
third_party/vulkan/vulkan_handles.hpp vendored
View File

@@ -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 <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::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 DataGraphOpticalFlowImageFormatPropertiesARMAllocator = std::allocator<DataGraphOpticalFlowImageFormatPropertiesARM>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<
std::is_same<typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator::value_type, DataGraphOpticalFlowImageFormatPropertiesARM>::value,
int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::type = true>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator>>::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 DataGraphOpticalFlowImageFormatPropertiesARMAllocator = std::allocator<DataGraphOpticalFlowImageFormatPropertiesARM>,
typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
typename std::enable_if<
std::is_same<typename DataGraphOpticalFlowImageFormatPropertiesARMAllocator::value_type, DataGraphOpticalFlowImageFormatPropertiesARM>::value,
int>::type = 0,
typename std::enable_if<IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM ), bool>::type = true>
VULKAN_HPP_NODISCARD
typename ResultValueType<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM, DataGraphOpticalFlowImageFormatPropertiesARMAllocator>>::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 ===

146
third_party/vulkan/vulkan_hash.hpp vendored
View File

@@ -3682,6 +3682,34 @@ VULKAN_HPP_EXPORT namespace std
};
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatInfoARM>
{
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<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatPropertiesARM>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
{
@@ -3832,6 +3860,43 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowCreateInfoARM>
{
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<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowDispatchInfoARM>
{
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<VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM>
{
@@ -3849,6 +3914,20 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoImageLayoutARM>
{
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<VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM>
{
@@ -3931,6 +4010,38 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeConnectionARM>
{
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<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeCreateInfoARM>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM>
{
@@ -10453,6 +10564,20 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOpticalFlowFeaturesARM>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
{
@@ -17725,6 +17850,27 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphOpticalFlowPropertiesARM>
{
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<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM>
{

67
third_party/vulkan/vulkan_raii.hpp vendored
View File

@@ -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<std::vector<ShaderInstrumentationMetricDescriptionARM>>::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<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM>>::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 <vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM> requires <VK_ARM_data_graph_instruction_set_tosa>" );
VULKAN_HPP_ASSERT(
getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM &&
"Function <vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM> requires <VK_ARM_data_graph_instruction_set_tosa> or <VK_ARM_data_graph_optical_flow>" );
BaseOutStructure properties;
Result result = static_cast<Result>( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(
@@ -29537,6 +29554,52 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkRenderingEndInfoKHR const *>( 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<std::vector<DataGraphOpticalFlowImageFormatPropertiesARM>>::type
PhysicalDevice::getQueueFamilyDataGraphOpticalFlowImageFormatsARM( uint32_t queueFamilyIndex,
QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphProperties,
DataGraphOpticalFlowImageFormatInfoARM const & opticalFlowImageFormatInfo ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM &&
"Function <vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM> requires <VK_ARM_data_graph_optical_flow>" );
std::vector<DataGraphOpticalFlowImageFormatPropertiesARM> imageFormatProperties;
uint32_t formatCount;
Result result;
do
{
result = static_cast<Result>( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
static_cast<VkPhysicalDevice>( m_physicalDevice ),
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
nullptr ) );
if ( ( result == Result::eSuccess ) && formatCount )
{
imageFormatProperties.resize( formatCount );
result = static_cast<Result>( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(
static_cast<VkPhysicalDevice>( m_physicalDevice ),
queueFamilyIndex,
reinterpret_cast<VkQueueFamilyDataGraphPropertiesARM const *>( &queueFamilyDataGraphProperties ),
reinterpret_cast<VkDataGraphOpticalFlowImageFormatInfoARM const *>( &opticalFlowImageFormatInfo ),
&formatCount,
reinterpret_cast<VkDataGraphOpticalFlowImageFormatPropertiesARM *>( 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

70
third_party/vulkan/vulkan_static_assertions.hpp vendored
View File

@@ -10055,6 +10055,76 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ResolveI
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOpticalFlowFeaturesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOpticalFlowFeaturesARM>::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<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphOpticalFlowPropertiesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphOpticalFlowPropertiesARM>::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<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowCreateInfoARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowCreateInfoARM>::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<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatPropertiesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatPropertiesARM>::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<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatInfoARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphOpticalFlowImageFormatInfoARM>::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<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowDispatchInfoARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineOpticalFlowDispatchInfoARM>::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<VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoImageLayoutARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoImageLayoutARM>::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<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeCreateInfoARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeCreateInfoARM>::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<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeConnectionARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineSingleNodeConnectionARM>::value,
"DataGraphPipelineSingleNodeConnectionARM is not nothrow_move_constructible!" );
//=== VK_EXT_shader_long_vector ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderLongVectorFeaturesEXT ),

1341
third_party/vulkan/vulkan_structs.hpp vendored
View File

File diff suppressed because it is too large Load Diff

195
third_party/vulkan/vulkan_to_string.hpp vendored
View File

@@ -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<uint32_t>( 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<uint32_t>( value ) ) + " )";
case DataGraphPipelineSessionBindPointARM::eTransient : return "Transient";
case DataGraphPipelineSessionBindPointARM::eOpticalFlowCache: return "OpticalFlowCache";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( 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<uint32_t>( value ) ) + " )";
case DataGraphPipelineSessionCreateFlagBitsARM::eProtected : return "Protected";
case DataGraphPipelineSessionCreateFlagBitsARM::eOpticalFlowCache: return "OpticalFlowCache";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( value ) ) + " )";
}
}
#if defined( VK_USE_PLATFORM_UBM_SEC )
//=== VK_SEC_ubm_surface ===