AuroraMiddleware/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp synced 2024-11-08 21:50:08 +00:00
Code Issues Releases Wiki Activity

Update Vulkan-Headers to v1.3.226

Browse Source
This commit is contained in:
GitHub 2022-09-02 00:12:10 +00:00
parent 7693764cdd
commit 5c406ec531
10 changed files with 1520 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 715673702f5b18ffb8e5832e67cf731468d32ac6
Subproject commit 9f4c61a31435a7a90a314fc68aeb386c92a09c0f

101
vulkan/vulkan.hpp
View File

@ -117,7 +117,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 225, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 226, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@ -4915,6 +4915,30 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
}
//=== VK_EXT_mesh_shader ===
void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
}
void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
}
void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkBuffer countBuffer,
VkDeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
}
//=== VK_KHR_copy_commands2 ===
void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
@ -7559,6 +7583,14 @@ namespace VULKAN_HPP_NAMESPACE
value = true
};
};
template <>
struct StructExtends<VideoDecodeUsageInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_NV_dedicated_allocation ===
@ -9948,6 +9980,14 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<VideoEncodeUsageInfoKHR, VideoProfileInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
{
enum
@ -10313,6 +10353,32 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_mesh_shader ===
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMeshShaderPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_ycbcr_2plane_444_formats ===
template <>
struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
@ -11045,6 +11111,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_depth_clamp_zero_one ===
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_non_seamless_cube_map ===
template <>
struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, PhysicalDeviceFeatures2>
@ -12239,6 +12323,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_fragment_shading_rate_enums ===
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;
//=== VK_EXT_mesh_shader ===
PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
//=== VK_KHR_copy_commands2 ===
PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
@ -13415,6 +13504,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_fragment_shading_rate_enums ===
vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) );
//=== VK_EXT_mesh_shader ===
vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) );
vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) );
vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
//=== VK_KHR_copy_commands2 ===
vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
if ( !vkCmdCopyBuffer2 )
@ -14283,6 +14377,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_fragment_shading_rate_enums ===
vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
//=== VK_EXT_mesh_shader ===
vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
//=== VK_KHR_copy_commands2 ===
vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
if ( !vkCmdCopyBuffer2 )

202
vulkan/vulkan_enums.hpp
View File

@ -357,6 +357,7 @@ namespace VULKAN_HPP_NAMESPACE
eQueueFamilyQueryResultStatusPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR,
eVideoDecodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
eVideoDecodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR,
eVideoDecodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
@ -699,6 +700,7 @@ namespace VULKAN_HPP_NAMESPACE
eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
eVideoEncodeRateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
eVideoEncodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR,
eVideoEncodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
@ -731,6 +733,8 @@ namespace VULKAN_HPP_NAMESPACE
eAccelerationStructureGeometryMotionTrianglesDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
ePhysicalDeviceRayTracingMotionBlurFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
eAccelerationStructureMotionInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV,
ePhysicalDeviceMeshShaderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT,
ePhysicalDeviceMeshShaderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT,
ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
ePhysicalDeviceFragmentDensityMap2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
ePhysicalDeviceFragmentDensityMap2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
@ -803,6 +807,7 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
eDescriptorSetBindingReferenceVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
eDescriptorSetLayoutHostMappingInfoVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT,
ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
@ -1597,15 +1602,17 @@ namespace VULKAN_HPP_NAMESPACE
eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT,
eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
eRayTracingShaderKHR = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,
eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV,
eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
eCommandPreprocessNV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
eTaskShaderEXT = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT,
eMeshShaderEXT = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT,
eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV,
eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR,
eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV,
eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV
eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV,
eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
};
enum class MemoryMapFlagBits : VkMemoryMapFlags
@ -1671,7 +1678,9 @@ namespace VULKAN_HPP_NAMESPACE
eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT,
eTaskShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT,
eMeshShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT
};
enum class QueryResultFlagBits : VkQueryResultFlags
@ -1702,6 +1711,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eVideoEncodeBitstreamBufferRangeKHR = VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eMeshPrimitivesGeneratedEXT = VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT,
ePrimitivesGeneratedEXT = VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT,
eAccelerationStructureSerializationBottomLevelPointersKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR,
eAccelerationStructureSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR
@ -2111,15 +2121,17 @@ namespace VULKAN_HPP_NAMESPACE
eMissKHR = VK_SHADER_STAGE_MISS_BIT_KHR,
eIntersectionKHR = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
eCallableKHR = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV,
eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV,
eTaskEXT = VK_SHADER_STAGE_TASK_BIT_EXT,
eMeshEXT = VK_SHADER_STAGE_MESH_BIT_EXT,
eSubpassShadingHUAWEI = VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI,
eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV,
eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV,
eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV,
eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV,
eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV,
eMissNV = VK_SHADER_STAGE_MISS_BIT_NV,
eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV
eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV,
eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV
};
enum class StencilOp
@ -2728,14 +2740,16 @@ namespace VULKAN_HPP_NAMESPACE
eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,
eRayTracingShaderKHR = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR,
eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT,
eTaskShaderNV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT,
eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT,
eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI,
eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI,
eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR,
eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV,
eRayTracingShaderNV = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV,
eShadingRateImageNV = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV,
eTaskShaderNV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV,
eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT
};
using PipelineStageFlagBits2KHR = PipelineStageFlagBits2;
@ -3130,6 +3144,14 @@ namespace VULKAN_HPP_NAMESPACE
eDpbAndOutputDistinct = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR
};
enum class VideoDecodeUsageFlagBitsKHR : VkVideoDecodeUsageFlagsKHR
{
eDefault = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR,
eTranscoding = VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR,
eOffline = VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR,
eStreaming = VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR
};
enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR
{
};
@ -3888,14 +3910,15 @@ namespace VULKAN_HPP_NAMESPACE
enum class IndirectCommandsTokenTypeNV
{
eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV,
eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV,
eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV,
eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV,
ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV,
eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV,
eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV,
eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV
eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV,
eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV,
eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV,
eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV,
ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV,
eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV,
eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV,
eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV,
eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV
};
enum class IndirectCommandsLayoutUsageFlagBitsNV : VkIndirectCommandsLayoutUsageFlagsNV
@ -3936,6 +3959,32 @@ namespace VULKAN_HPP_NAMESPACE
ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR
};
enum class VideoEncodeUsageFlagBitsKHR : VkVideoEncodeUsageFlagsKHR
{
eDefault = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR,
eTranscoding = VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR,
eStreaming = VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR,
eRecording = VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR,
eConferencing = VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR
};
enum class VideoEncodeContentFlagBitsKHR : VkVideoEncodeContentFlagsKHR
{
eDefault = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR,
eCamera = VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR,
eDesktop = VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR,
eRendered = VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR
};
enum class VideoEncodeTuningModeKHR
{
eDefault = VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR,
eHighQuality = VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR,
eLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR,
eUltraLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR,
eLossless = VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR
};
enum class VideoEncodeRateControlModeFlagBitsKHR : VkVideoEncodeRateControlModeFlagsKHR
{
eNone = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR,
@ -4555,9 +4604,9 @@ namespace VULKAN_HPP_NAMESPACE
VkFlags( PipelineStageFlagBits::eAllGraphics ) | VkFlags( PipelineStageFlagBits::eAllCommands ) | VkFlags( PipelineStageFlagBits::eNone ) |
VkFlags( PipelineStageFlagBits::eTransformFeedbackEXT ) | VkFlags( PipelineStageFlagBits::eConditionalRenderingEXT ) |
VkFlags( PipelineStageFlagBits::eAccelerationStructureBuildKHR ) | VkFlags( PipelineStageFlagBits::eRayTracingShaderKHR ) |
VkFlags( PipelineStageFlagBits::eTaskShaderNV ) | VkFlags( PipelineStageFlagBits::eMeshShaderNV ) |
VkFlags( PipelineStageFlagBits::eFragmentDensityProcessEXT ) | VkFlags( PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) |
VkFlags( PipelineStageFlagBits::eCommandPreprocessNV )
VkFlags( PipelineStageFlagBits::eCommandPreprocessNV ) | VkFlags( PipelineStageFlagBits::eTaskShaderEXT ) |
VkFlags( PipelineStageFlagBits::eMeshShaderEXT )
};
};
@ -4758,7 +4807,8 @@ namespace VULKAN_HPP_NAMESPACE
VkFlags( QueryPipelineStatisticFlagBits::eClippingPrimitives ) | VkFlags( QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) |
VkFlags( QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) |
VkFlags( QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) |
VkFlags( QueryPipelineStatisticFlagBits::eComputeShaderInvocations )
VkFlags( QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) | VkFlags( QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT ) |
VkFlags( QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT )
};
};
@ -5239,7 +5289,7 @@ namespace VULKAN_HPP_NAMESPACE
VkFlags( ShaderStageFlagBits::eFragment ) | VkFlags( ShaderStageFlagBits::eCompute ) | VkFlags( ShaderStageFlagBits::eAllGraphics ) |
VkFlags( ShaderStageFlagBits::eAll ) | VkFlags( ShaderStageFlagBits::eRaygenKHR ) | VkFlags( ShaderStageFlagBits::eAnyHitKHR ) |
VkFlags( ShaderStageFlagBits::eClosestHitKHR ) | VkFlags( ShaderStageFlagBits::eMissKHR ) | VkFlags( ShaderStageFlagBits::eIntersectionKHR ) |
VkFlags( ShaderStageFlagBits::eCallableKHR ) | VkFlags( ShaderStageFlagBits::eTaskNV ) | VkFlags( ShaderStageFlagBits::eMeshNV ) |
VkFlags( ShaderStageFlagBits::eCallableKHR ) | VkFlags( ShaderStageFlagBits::eTaskEXT ) | VkFlags( ShaderStageFlagBits::eMeshEXT ) |
VkFlags( ShaderStageFlagBits::eSubpassShadingHUAWEI )
};
};
@ -6388,8 +6438,8 @@ namespace VULKAN_HPP_NAMESPACE
| VkFlags64( PipelineStageFlagBits2::eTransformFeedbackEXT ) | VkFlags64( PipelineStageFlagBits2::eConditionalRenderingEXT ) |
VkFlags64( PipelineStageFlagBits2::eCommandPreprocessNV ) | VkFlags64( PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) |
VkFlags64( PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) | VkFlags64( PipelineStageFlagBits2::eRayTracingShaderKHR ) |
VkFlags64( PipelineStageFlagBits2::eFragmentDensityProcessEXT ) | VkFlags64( PipelineStageFlagBits2::eTaskShaderNV ) |
VkFlags64( PipelineStageFlagBits2::eMeshShaderNV ) | VkFlags64( PipelineStageFlagBits2::eSubpassShadingHUAWEI ) |
VkFlags64( PipelineStageFlagBits2::eFragmentDensityProcessEXT ) | VkFlags64( PipelineStageFlagBits2::eTaskShaderEXT ) |
VkFlags64( PipelineStageFlagBits2::eMeshShaderEXT ) | VkFlags64( PipelineStageFlagBits2::eSubpassShadingHUAWEI ) |
VkFlags64( PipelineStageFlagBits2::eInvocationMaskHUAWEI ) | VkFlags64( PipelineStageFlagBits2::eAccelerationStructureCopyKHR )
};
};
@ -7110,6 +7160,41 @@ namespace VULKAN_HPP_NAMESPACE
return ~( VideoDecodeCapabilityFlagsKHR( bits ) );
}
using VideoDecodeUsageFlagsKHR = Flags<VideoDecodeUsageFlagBitsKHR>;
template <>
struct FlagTraits<VideoDecodeUsageFlagBitsKHR>
{
enum : VkFlags
{
allFlags = VkFlags( VideoDecodeUsageFlagBitsKHR::eDefault ) | VkFlags( VideoDecodeUsageFlagBitsKHR::eTranscoding ) |
VkFlags( VideoDecodeUsageFlagBitsKHR::eOffline ) | VkFlags( VideoDecodeUsageFlagBitsKHR::eStreaming )
};
};
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeUsageFlagsKHR operator|( VideoDecodeUsageFlagBitsKHR bit0,
VideoDecodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoDecodeUsageFlagsKHR( bit0 ) | bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeUsageFlagsKHR operator&( VideoDecodeUsageFlagBitsKHR bit0,
VideoDecodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoDecodeUsageFlagsKHR( bit0 ) & bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeUsageFlagsKHR operator^( VideoDecodeUsageFlagBitsKHR bit0,
VideoDecodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoDecodeUsageFlagsKHR( bit0 ) ^ bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeUsageFlagsKHR operator~( VideoDecodeUsageFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT
{
return ~( VideoDecodeUsageFlagsKHR( bits ) );
}
using VideoDecodeFlagsKHR = Flags<VideoDecodeFlagBitsKHR>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -8072,6 +8157,77 @@ namespace VULKAN_HPP_NAMESPACE
return ~( VideoEncodeCapabilityFlagsKHR( bits ) );
}
using VideoEncodeUsageFlagsKHR = Flags<VideoEncodeUsageFlagBitsKHR>;
template <>
struct FlagTraits<VideoEncodeUsageFlagBitsKHR>
{
enum : VkFlags
{
allFlags = VkFlags( VideoEncodeUsageFlagBitsKHR::eDefault ) | VkFlags( VideoEncodeUsageFlagBitsKHR::eTranscoding ) |
VkFlags( VideoEncodeUsageFlagBitsKHR::eStreaming ) | VkFlags( VideoEncodeUsageFlagBitsKHR::eRecording ) |
VkFlags( VideoEncodeUsageFlagBitsKHR::eConferencing )
};
};
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeUsageFlagsKHR operator|( VideoEncodeUsageFlagBitsKHR bit0,
VideoEncodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeUsageFlagsKHR( bit0 ) | bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeUsageFlagsKHR operator&( VideoEncodeUsageFlagBitsKHR bit0,
VideoEncodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeUsageFlagsKHR( bit0 ) & bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeUsageFlagsKHR operator^( VideoEncodeUsageFlagBitsKHR bit0,
VideoEncodeUsageFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeUsageFlagsKHR( bit0 ) ^ bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeUsageFlagsKHR operator~( VideoEncodeUsageFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT
{
return ~( VideoEncodeUsageFlagsKHR( bits ) );
}
using VideoEncodeContentFlagsKHR = Flags<VideoEncodeContentFlagBitsKHR>;
template <>
struct FlagTraits<VideoEncodeContentFlagBitsKHR>
{
enum : VkFlags
{
allFlags = VkFlags( VideoEncodeContentFlagBitsKHR::eDefault ) | VkFlags( VideoEncodeContentFlagBitsKHR::eCamera ) |
VkFlags( VideoEncodeContentFlagBitsKHR::eDesktop ) | VkFlags( VideoEncodeContentFlagBitsKHR::eRendered )
};
};
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeContentFlagsKHR operator|( VideoEncodeContentFlagBitsKHR bit0,
VideoEncodeContentFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeContentFlagsKHR( bit0 ) | bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeContentFlagsKHR operator&( VideoEncodeContentFlagBitsKHR bit0,
VideoEncodeContentFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeContentFlagsKHR( bit0 ) & bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeContentFlagsKHR operator^( VideoEncodeContentFlagBitsKHR bit0,
VideoEncodeContentFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
return VideoEncodeContentFlagsKHR( bit0 ) ^ bit1;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeContentFlagsKHR operator~( VideoEncodeContentFlagBitsKHR bits ) VULKAN_HPP_NOEXCEPT
{
return ~( VideoEncodeContentFlagsKHR( bits ) );
}
using VideoEncodeRateControlFlagsKHR = Flags<VideoEncodeRateControlFlagBitsKHR>;
using VideoEncodeRateControlModeFlagsKHR = Flags<VideoEncodeRateControlModeFlagBitsKHR>;

40
vulkan/vulkan_funcs.hpp
View File

@ -18202,6 +18202,46 @@ namespace VULKAN_HPP_NAMESPACE
m_commandBuffer, static_cast<VkFragmentShadingRateNV>( shadingRate ), reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
}
//=== VK_EXT_mesh_shader ===
template <typename Dispatch>
VULKAN_HPP_INLINE void
CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdDrawMeshTasksEXT( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
}
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdDrawMeshTasksIndirectEXT( m_commandBuffer, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdDrawMeshTasksIndirectCountEXT( m_commandBuffer,
static_cast<VkBuffer>( buffer ),
static_cast<VkDeviceSize>( offset ),
static_cast<VkBuffer>( countBuffer ),
static_cast<VkDeviceSize>( countBufferOffset ),
maxDrawCount,
stride );
}
//=== VK_KHR_copy_commands2 ===
template <typename Dispatch>

34
vulkan/vulkan_handles.hpp
View File

@ -555,6 +555,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_KHR_video_decode_queue ===
struct VideoDecodeCapabilitiesKHR;
struct VideoDecodeUsageInfoKHR;
struct VideoDecodeInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -1184,6 +1185,7 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_video_encode_queue ===
struct VideoEncodeInfoKHR;
struct VideoEncodeCapabilitiesKHR;
struct VideoEncodeUsageInfoKHR;
struct VideoEncodeRateControlInfoKHR;
struct VideoEncodeRateControlLayerInfoKHR;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -1243,6 +1245,11 @@ namespace VULKAN_HPP_NAMESPACE
struct SRTDataNV;
struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
//=== VK_EXT_mesh_shader ===
struct PhysicalDeviceMeshShaderFeaturesEXT;
struct PhysicalDeviceMeshShaderPropertiesEXT;
struct DrawMeshTasksIndirectCommandEXT;
//=== VK_EXT_ycbcr_2plane_444_formats ===
struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
@ -1401,6 +1408,9 @@ namespace VULKAN_HPP_NAMESPACE
struct DescriptorSetBindingReferenceVALVE;
struct DescriptorSetLayoutHostMappingInfoVALVE;
//=== VK_EXT_depth_clamp_zero_one ===
struct PhysicalDeviceDepthClampZeroOneFeaturesEXT;
//=== VK_EXT_non_seamless_cube_map ===
struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
@ -4658,6 +4668,30 @@ namespace VULKAN_HPP_NAMESPACE
const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_mesh_shader ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMeshTasksEXT( uint32_t groupCountX,
uint32_t groupCountY,
uint32_t groupCountZ,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_copy_commands2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

129
vulkan/vulkan_hash.hpp
View File

@ -3648,6 +3648,19 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX );
VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY );
VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
{
@ -6481,6 +6494,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
{
@ -7771,6 +7798,23 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
{
@ -7785,6 +7829,59 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount );
for ( size_t i = 0; i < 3; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations );
for ( size_t i = 0; i < 3; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount );
for ( size_t i = 0; i < 3; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations );
for ( size_t i = 0; i < 3; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
{
@ -12452,6 +12549,21 @@ namespace std
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
@ -13026,6 +13138,23 @@ namespace std
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>

66
vulkan/vulkan_raii.hpp
View File

@ -984,6 +984,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_line_rasterization ===
vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
//=== VK_EXT_mesh_shader ===
vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
@ -1799,6 +1804,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_line_rasterization ===
PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
//=== VK_EXT_mesh_shader ===
PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0;
PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
@ -5258,6 +5268,22 @@ namespace VULKAN_HPP_NAMESPACE
void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_mesh_shader ===
void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
//=== VK_KHR_copy_commands2 ===
void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
@ -16588,6 +16614,46 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
}
//=== VK_EXT_mesh_shader ===
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function <vkCmdDrawMeshTasksEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
}
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
uint32_t drawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectEXT &&
"Function <vkCmdDrawMeshTasksIndirectEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
getDispatcher()->vkCmdDrawMeshTasksIndirectEXT(
static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
}
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
VULKAN_HPP_NAMESPACE::DeviceSize offset,
VULKAN_HPP_NAMESPACE::Buffer countBuffer,
VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
uint32_t maxDrawCount,
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT &&
"Function <vkCmdDrawMeshTasksIndirectCountEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
static_cast<VkBuffer>( buffer ),
static_cast<VkDeviceSize>( offset ),
static_cast<VkBuffer>( countBuffer ),
static_cast<VkDeviceSize>( countBufferOffset ),
maxDrawCount,
stride );
}
//=== VK_KHR_copy_commands2 ===
VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT

43
vulkan/vulkan_static_assertions.hpp
View File

@ -2125,6 +2125,12 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDec
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>::value,
"VideoDecodeCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR ) == sizeof( VkVideoDecodeUsageInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR>::value,
"VideoDecodeUsageInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR ) == sizeof( VkVideoDecodeInfoKHR ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>::value,
@ -4712,6 +4718,12 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEnc
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>::value,
"VideoEncodeCapabilitiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR ) == sizeof( VkVideoEncodeUsageInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR>::value,
"VideoEncodeUsageInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR ) == sizeof( VkVideoEncodeRateControlInfoKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>::value, "struct wrapper is not a standard layout!" );
@ -4978,6 +4990,28 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>::value,
"PhysicalDeviceRayTracingMotionBlurFeaturesNV is not nothrow_move_constructible!" );
//=== VK_EXT_mesh_shader ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT>::value,
"PhysicalDeviceMeshShaderFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT>::value,
"PhysicalDeviceMeshShaderPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT ) == sizeof( VkDrawMeshTasksIndirectCommandEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT>::value,
"DrawMeshTasksIndirectCommandEXT is not nothrow_move_constructible!" );
//=== VK_EXT_ycbcr_2plane_444_formats ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) ==
@ -5600,6 +5634,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Descript
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>::value,
"DescriptorSetLayoutHostMappingInfoVALVE is not nothrow_move_constructible!" );
//=== VK_EXT_depth_clamp_zero_one ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>::value,
"PhysicalDeviceDepthClampZeroOneFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_EXT_non_seamless_cube_map ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT ) ==

797
vulkan/vulkan_structs.hpp
View File

@ -26544,6 +26544,101 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t firstInstance = {};
};
struct DrawMeshTasksIndirectCommandEXT
{
using NativeType = VkDrawMeshTasksIndirectCommandEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR
DrawMeshTasksIndirectCommandEXT( uint32_t groupCountX_ = {}, uint32_t groupCountY_ = {}, uint32_t groupCountZ_ = {} ) VULKAN_HPP_NOEXCEPT
: groupCountX( groupCountX_ )
, groupCountY( groupCountY_ )
, groupCountZ( groupCountZ_ )
{
}
VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandEXT( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DrawMeshTasksIndirectCommandEXT( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: DrawMeshTasksIndirectCommandEXT( *reinterpret_cast<DrawMeshTasksIndirectCommandEXT const *>( &rhs ) )
{
}
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
DrawMeshTasksIndirectCommandEXT & operator=( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DrawMeshTasksIndirectCommandEXT & operator=( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountX( uint32_t groupCountX_ ) VULKAN_HPP_NOEXCEPT
{
groupCountX = groupCountX_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountY( uint32_t groupCountY_ ) VULKAN_HPP_NOEXCEPT
{
groupCountY = groupCountY_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountZ( uint32_t groupCountZ_ ) VULKAN_HPP_NOEXCEPT
{
groupCountZ = groupCountZ_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDrawMeshTasksIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandEXT *>( this );
}
operator VkDrawMeshTasksIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDrawMeshTasksIndirectCommandEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( groupCountX, groupCountY, groupCountZ );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DrawMeshTasksIndirectCommandEXT const & ) const = default;
#else
bool operator==( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( groupCountX == rhs.groupCountX ) && ( groupCountY == rhs.groupCountY ) && ( groupCountZ == rhs.groupCountZ );
# endif
}
bool operator!=( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
uint32_t groupCountX = {};
uint32_t groupCountY = {};
uint32_t groupCountZ = {};
};
struct DrawMeshTasksIndirectCommandNV
{
using NativeType = VkDrawMeshTasksIndirectCommandNV;
@ -47859,6 +47954,104 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
};
struct PhysicalDeviceDepthClampZeroOneFeaturesEXT
{
using NativeType = VkPhysicalDeviceDepthClampZeroOneFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, depthClampZeroOne( depthClampZeroOne_ )
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesEXT( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDepthClampZeroOneFeaturesEXT( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDepthClampZeroOneFeaturesEXT( *reinterpret_cast<PhysicalDeviceDepthClampZeroOneFeaturesEXT const *>( &rhs ) )
{
}
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceDepthClampZeroOneFeaturesEXT & operator=( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDepthClampZeroOneFeaturesEXT & operator=( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesEXT &
setDepthClampZeroOne( VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne_ ) VULKAN_HPP_NOEXCEPT
{
depthClampZeroOne = depthClampZeroOne_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>( this );
}
operator VkPhysicalDeviceDepthClampZeroOneFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, depthClampZeroOne );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceDepthClampZeroOneFeaturesEXT 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 ) && ( depthClampZeroOne == rhs.depthClampZeroOne );
# endif
}
bool operator!=( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT>
{
using Type = PhysicalDeviceDepthClampZeroOneFeaturesEXT;
};
struct PhysicalDeviceDepthClipControlFeaturesEXT
{
using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT;
@ -56333,6 +56526,149 @@ namespace VULKAN_HPP_NAMESPACE
};
using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
struct PhysicalDeviceMeshShaderFeaturesEXT
{
using NativeType = VkPhysicalDeviceMeshShaderFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 taskShader_ = {},
VULKAN_HPP_NAMESPACE::Bool32 meshShader_ = {},
VULKAN_HPP_NAMESPACE::Bool32 multiviewMeshShader_ = {},
VULKAN_HPP_NAMESPACE::Bool32 primitiveFragmentShadingRateMeshShader_ = {},
VULKAN_HPP_NAMESPACE::Bool32 meshShaderQueries_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, taskShader( taskShader_ )
, meshShader( meshShader_ )
, multiviewMeshShader( multiviewMeshShader_ )
, primitiveFragmentShadingRateMeshShader( primitiveFragmentShadingRateMeshShader_ )
, meshShaderQueries( meshShaderQueries_ )
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMeshShaderFeaturesEXT( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceMeshShaderFeaturesEXT( *reinterpret_cast<PhysicalDeviceMeshShaderFeaturesEXT const *>( &rhs ) )
{
}
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceMeshShaderFeaturesEXT & operator=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMeshShaderFeaturesEXT & operator=( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setTaskShader( VULKAN_HPP_NAMESPACE::Bool32 taskShader_ ) VULKAN_HPP_NOEXCEPT
{
taskShader = taskShader_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShader( VULKAN_HPP_NAMESPACE::Bool32 meshShader_ ) VULKAN_HPP_NOEXCEPT
{
meshShader = meshShader_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT &
setMultiviewMeshShader( VULKAN_HPP_NAMESPACE::Bool32 multiviewMeshShader_ ) VULKAN_HPP_NOEXCEPT
{
multiviewMeshShader = multiviewMeshShader_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT &
setPrimitiveFragmentShadingRateMeshShader( VULKAN_HPP_NAMESPACE::Bool32 primitiveFragmentShadingRateMeshShader_ ) VULKAN_HPP_NOEXCEPT
{
primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShaderQueries( VULKAN_HPP_NAMESPACE::Bool32 meshShaderQueries_ ) VULKAN_HPP_NOEXCEPT
{
meshShaderQueries = meshShaderQueries_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkPhysicalDeviceMeshShaderFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>( this );
}
operator VkPhysicalDeviceMeshShaderFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, taskShader, meshShader, multiviewMeshShader, primitiveFragmentShadingRateMeshShader, meshShaderQueries );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMeshShaderFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMeshShaderFeaturesEXT 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 ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ) &&
( multiviewMeshShader == rhs.multiviewMeshShader ) && ( primitiveFragmentShadingRateMeshShader == rhs.primitiveFragmentShadingRateMeshShader ) &&
( meshShaderQueries == rhs.meshShaderQueries );
# endif
}
bool operator!=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 taskShader = {};
VULKAN_HPP_NAMESPACE::Bool32 meshShader = {};
VULKAN_HPP_NAMESPACE::Bool32 multiviewMeshShader = {};
VULKAN_HPP_NAMESPACE::Bool32 primitiveFragmentShadingRateMeshShader = {};
VULKAN_HPP_NAMESPACE::Bool32 meshShaderQueries = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderFeaturesEXT>
{
using Type = PhysicalDeviceMeshShaderFeaturesEXT;
};
struct PhysicalDeviceMeshShaderFeaturesNV
{
using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV;
@ -56439,6 +56775,244 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceMeshShaderFeaturesNV;
};
struct PhysicalDeviceMeshShaderPropertiesEXT
{
using NativeType = VkPhysicalDeviceMeshShaderPropertiesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( uint32_t maxTaskWorkGroupTotalCount_ = {},
std::array<uint32_t, 3> const & maxTaskWorkGroupCount_ = {},
uint32_t maxTaskWorkGroupInvocations_ = {},
std::array<uint32_t, 3> const & maxTaskWorkGroupSize_ = {},
uint32_t maxTaskPayloadSize_ = {},
uint32_t maxTaskSharedMemorySize_ = {},
uint32_t maxTaskPayloadAndSharedMemorySize_ = {},
uint32_t maxMeshWorkGroupTotalCount_ = {},
std::array<uint32_t, 3> const & maxMeshWorkGroupCount_ = {},
uint32_t maxMeshWorkGroupInvocations_ = {},
std::array<uint32_t, 3> const & maxMeshWorkGroupSize_ = {},
uint32_t maxMeshSharedMemorySize_ = {},
uint32_t maxMeshPayloadAndSharedMemorySize_ = {},
uint32_t maxMeshOutputMemorySize_ = {},
uint32_t maxMeshPayloadAndOutputMemorySize_ = {},
uint32_t maxMeshOutputComponents_ = {},
uint32_t maxMeshOutputVertices_ = {},
uint32_t maxMeshOutputPrimitives_ = {},
uint32_t maxMeshOutputLayers_ = {},
uint32_t maxMeshMultiviewViewCount_ = {},
uint32_t meshOutputPerVertexGranularity_ = {},
uint32_t meshOutputPerPrimitiveGranularity_ = {},
uint32_t maxPreferredTaskWorkGroupInvocations_ = {},
uint32_t maxPreferredMeshWorkGroupInvocations_ = {},
VULKAN_HPP_NAMESPACE::Bool32 prefersLocalInvocationVertexOutput_ = {},
VULKAN_HPP_NAMESPACE::Bool32 prefersLocalInvocationPrimitiveOutput_ = {},
VULKAN_HPP_NAMESPACE::Bool32 prefersCompactVertexOutput_ = {},
VULKAN_HPP_NAMESPACE::Bool32 prefersCompactPrimitiveOutput_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, maxTaskWorkGroupTotalCount( maxTaskWorkGroupTotalCount_ )
, maxTaskWorkGroupCount( maxTaskWorkGroupCount_ )
, maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
, maxTaskWorkGroupSize( maxTaskWorkGroupSize_ )
, maxTaskPayloadSize( maxTaskPayloadSize_ )
, maxTaskSharedMemorySize( maxTaskSharedMemorySize_ )
, maxTaskPayloadAndSharedMemorySize( maxTaskPayloadAndSharedMemorySize_ )
, maxMeshWorkGroupTotalCount( maxMeshWorkGroupTotalCount_ )
, maxMeshWorkGroupCount( maxMeshWorkGroupCount_ )
, maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
, maxMeshWorkGroupSize( maxMeshWorkGroupSize_ )
, maxMeshSharedMemorySize( maxMeshSharedMemorySize_ )
, maxMeshPayloadAndSharedMemorySize( maxMeshPayloadAndSharedMemorySize_ )
, maxMeshOutputMemorySize( maxMeshOutputMemorySize_ )
, maxMeshPayloadAndOutputMemorySize( maxMeshPayloadAndOutputMemorySize_ )
, maxMeshOutputComponents( maxMeshOutputComponents_ )
, maxMeshOutputVertices( maxMeshOutputVertices_ )
, maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
, maxMeshOutputLayers( maxMeshOutputLayers_ )
, maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
, meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
, meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
, maxPreferredTaskWorkGroupInvocations( maxPreferredTaskWorkGroupInvocations_ )
, maxPreferredMeshWorkGroupInvocations( maxPreferredMeshWorkGroupInvocations_ )
, prefersLocalInvocationVertexOutput( prefersLocalInvocationVertexOutput_ )
, prefersLocalInvocationPrimitiveOutput( prefersLocalInvocationPrimitiveOutput_ )
, prefersCompactVertexOutput( prefersCompactVertexOutput_ )
, prefersCompactPrimitiveOutput( prefersCompactPrimitiveOutput_ )
{
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMeshShaderPropertiesEXT( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceMeshShaderPropertiesEXT( *reinterpret_cast<PhysicalDeviceMeshShaderPropertiesEXT const *>( &rhs ) )
{
}
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
PhysicalDeviceMeshShaderPropertiesEXT & operator=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceMeshShaderPropertiesEXT & operator=( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceMeshShaderPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT *>( this );
}
operator VkPhysicalDeviceMeshShaderPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType,
pNext,
maxTaskWorkGroupTotalCount,
maxTaskWorkGroupCount,
maxTaskWorkGroupInvocations,
maxTaskWorkGroupSize,
maxTaskPayloadSize,
maxTaskSharedMemorySize,
maxTaskPayloadAndSharedMemorySize,
maxMeshWorkGroupTotalCount,
maxMeshWorkGroupCount,
maxMeshWorkGroupInvocations,
maxMeshWorkGroupSize,
maxMeshSharedMemorySize,
maxMeshPayloadAndSharedMemorySize,
maxMeshOutputMemorySize,
maxMeshPayloadAndOutputMemorySize,
maxMeshOutputComponents,
maxMeshOutputVertices,
maxMeshOutputPrimitives,
maxMeshOutputLayers,
maxMeshMultiviewViewCount,
meshOutputPerVertexGranularity,
meshOutputPerPrimitiveGranularity,
maxPreferredTaskWorkGroupInvocations,
maxPreferredMeshWorkGroupInvocations,
prefersLocalInvocationVertexOutput,
prefersLocalInvocationPrimitiveOutput,
prefersCompactVertexOutput,
prefersCompactPrimitiveOutput );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceMeshShaderPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceMeshShaderPropertiesEXT 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 ) && ( maxTaskWorkGroupTotalCount == rhs.maxTaskWorkGroupTotalCount ) &&
( maxTaskWorkGroupCount == rhs.maxTaskWorkGroupCount ) && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) &&
( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && ( maxTaskPayloadSize == rhs.maxTaskPayloadSize ) &&
( maxTaskSharedMemorySize == rhs.maxTaskSharedMemorySize ) && ( maxTaskPayloadAndSharedMemorySize == rhs.maxTaskPayloadAndSharedMemorySize ) &&
( maxMeshWorkGroupTotalCount == rhs.maxMeshWorkGroupTotalCount ) && ( maxMeshWorkGroupCount == rhs.maxMeshWorkGroupCount ) &&
( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) &&
( maxMeshSharedMemorySize == rhs.maxMeshSharedMemorySize ) && ( maxMeshPayloadAndSharedMemorySize == rhs.maxMeshPayloadAndSharedMemorySize ) &&
( maxMeshOutputMemorySize == rhs.maxMeshOutputMemorySize ) && ( maxMeshPayloadAndOutputMemorySize == rhs.maxMeshPayloadAndOutputMemorySize ) &&
( maxMeshOutputComponents == rhs.maxMeshOutputComponents ) && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) &&
( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && ( maxMeshOutputLayers == rhs.maxMeshOutputLayers ) &&
( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) &&
( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ) &&
( maxPreferredTaskWorkGroupInvocations == rhs.maxPreferredTaskWorkGroupInvocations ) &&
( maxPreferredMeshWorkGroupInvocations == rhs.maxPreferredMeshWorkGroupInvocations ) &&
( prefersLocalInvocationVertexOutput == rhs.prefersLocalInvocationVertexOutput ) &&
( prefersLocalInvocationPrimitiveOutput == rhs.prefersLocalInvocationPrimitiveOutput ) &&
( prefersCompactVertexOutput == rhs.prefersCompactVertexOutput ) && ( prefersCompactPrimitiveOutput == rhs.prefersCompactPrimitiveOutput );
# endif
}
bool operator!=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT;
void * pNext = {};
uint32_t maxTaskWorkGroupTotalCount = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxTaskWorkGroupCount = {};
uint32_t maxTaskWorkGroupInvocations = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxTaskWorkGroupSize = {};
uint32_t maxTaskPayloadSize = {};
uint32_t maxTaskSharedMemorySize = {};
uint32_t maxTaskPayloadAndSharedMemorySize = {};
uint32_t maxMeshWorkGroupTotalCount = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxMeshWorkGroupCount = {};
uint32_t maxMeshWorkGroupInvocations = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> maxMeshWorkGroupSize = {};
uint32_t maxMeshSharedMemorySize = {};
uint32_t maxMeshPayloadAndSharedMemorySize = {};
uint32_t maxMeshOutputMemorySize = {};
uint32_t maxMeshPayloadAndOutputMemorySize = {};
uint32_t maxMeshOutputComponents = {};
uint32_t maxMeshOutputVertices = {};
uint32_t maxMeshOutputPrimitives = {};
uint32_t maxMeshOutputLayers = {};
uint32_t maxMeshMultiviewViewCount = {};
uint32_t meshOutputPerVertexGranularity = {};
uint32_t meshOutputPerPrimitiveGranularity = {};
uint32_t maxPreferredTaskWorkGroupInvocations = {};
uint32_t maxPreferredMeshWorkGroupInvocations = {};
VULKAN_HPP_NAMESPACE::Bool32 prefersLocalInvocationVertexOutput = {};
VULKAN_HPP_NAMESPACE::Bool32 prefersLocalInvocationPrimitiveOutput = {};
VULKAN_HPP_NAMESPACE::Bool32 prefersCompactVertexOutput = {};
VULKAN_HPP_NAMESPACE::Bool32 prefersCompactPrimitiveOutput = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceMeshShaderPropertiesEXT>
{
using Type = PhysicalDeviceMeshShaderPropertiesEXT;
};
struct PhysicalDeviceMeshShaderPropertiesNV
{
using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV;
@ -91824,6 +92398,105 @@ namespace VULKAN_HPP_NAMESPACE
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoDecodeUsageInfoKHR
{
using NativeType = VkVideoDecodeUsageInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeUsageInfoKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR videoUsageHints_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, videoUsageHints( videoUsageHints_ )
{
}
VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoDecodeUsageInfoKHR( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoDecodeUsageInfoKHR( *reinterpret_cast<VideoDecodeUsageInfoKHR const *>( &rhs ) )
{
}
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
VideoDecodeUsageInfoKHR & operator=( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoDecodeUsageInfoKHR & operator=( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setVideoUsageHints( VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR videoUsageHints_ ) VULKAN_HPP_NOEXCEPT
{
videoUsageHints = videoUsageHints_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkVideoDecodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoDecodeUsageInfoKHR *>( this );
}
operator VkVideoDecodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoDecodeUsageInfoKHR *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, videoUsageHints );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoDecodeUsageInfoKHR const & ) const = default;
# else
bool operator==( VideoDecodeUsageInfoKHR 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 ) && ( videoUsageHints == rhs.videoUsageHints );
# endif
}
bool operator!=( VideoDecodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeUsageInfoKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::VideoDecodeUsageFlagsKHR videoUsageHints = {};
};
template <>
struct CppType<StructureType, StructureType::eVideoDecodeUsageInfoKHR>
{
using Type = VideoDecodeUsageInfoKHR;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeCapabilitiesKHR
{
@ -96195,6 +96868,130 @@ namespace VULKAN_HPP_NAMESPACE
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeUsageInfoKHR
{
using NativeType = VkVideoEncodeUsageInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeUsageInfoKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR
VideoEncodeUsageInfoKHR( VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR videoUsageHints_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR videoContentHints_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR tuningMode_ = VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR::eDefault,
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, videoUsageHints( videoUsageHints_ )
, videoContentHints( videoContentHints_ )
, tuningMode( tuningMode_ )
{
}
VULKAN_HPP_CONSTEXPR VideoEncodeUsageInfoKHR( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoEncodeUsageInfoKHR( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoEncodeUsageInfoKHR( *reinterpret_cast<VideoEncodeUsageInfoKHR const *>( &rhs ) )
{
}
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
VideoEncodeUsageInfoKHR & operator=( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoEncodeUsageInfoKHR & operator=( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setVideoUsageHints( VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR videoUsageHints_ ) VULKAN_HPP_NOEXCEPT
{
videoUsageHints = videoUsageHints_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR &
setVideoContentHints( VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR videoContentHints_ ) VULKAN_HPP_NOEXCEPT
{
videoContentHints = videoContentHints_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setTuningMode( VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR tuningMode_ ) VULKAN_HPP_NOEXCEPT
{
tuningMode = tuningMode_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkVideoEncodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeUsageInfoKHR *>( this );
}
operator VkVideoEncodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeUsageInfoKHR *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR const &,
VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR const &,
VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, videoUsageHints, videoContentHints, tuningMode );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeUsageInfoKHR const & ) const = default;
# else
bool operator==( VideoEncodeUsageInfoKHR 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 ) && ( videoUsageHints == rhs.videoUsageHints ) && ( videoContentHints == rhs.videoContentHints ) &&
( tuningMode == rhs.tuningMode );
# endif
}
bool operator!=( VideoEncodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeUsageInfoKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::VideoEncodeUsageFlagsKHR videoUsageHints = {};
VULKAN_HPP_NAMESPACE::VideoEncodeContentFlagsKHR videoContentHints = {};
VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR tuningMode = VULKAN_HPP_NAMESPACE::VideoEncodeTuningModeKHR::eDefault;
};
template <>
struct CppType<StructureType, StructureType::eVideoEncodeUsageInfoKHR>
{
using Type = VideoEncodeUsageInfoKHR;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEndCodingInfoKHR
{

149
vulkan/vulkan_to_string.hpp
View File

@ -369,16 +369,16 @@ namespace VULKAN_HPP_NAMESPACE
result += "AccelerationStructureBuildKHR | ";
if ( value & PipelineStageFlagBits::eRayTracingShaderKHR )
result += "RayTracingShaderKHR | ";
if ( value & PipelineStageFlagBits::eTaskShaderNV )
result += "TaskShaderNV | ";
if ( value & PipelineStageFlagBits::eMeshShaderNV )
result += "MeshShaderNV | ";
if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT )
result += "FragmentDensityProcessEXT | ";
if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR )
result += "FragmentShadingRateAttachmentKHR | ";
if ( value & PipelineStageFlagBits::eCommandPreprocessNV )
result += "CommandPreprocessNV | ";
if ( value & PipelineStageFlagBits::eTaskShaderEXT )
result += "TaskShaderEXT | ";
if ( value & PipelineStageFlagBits::eMeshShaderEXT )
result += "MeshShaderEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -505,6 +505,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "TessellationEvaluationShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations )
result += "ComputeShaderInvocations | ";
if ( value & QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT )
result += "TaskShaderInvocationsEXT | ";
if ( value & QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT )
result += "MeshShaderInvocationsEXT | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
@ -857,10 +861,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "IntersectionKHR | ";
if ( value & ShaderStageFlagBits::eCallableKHR )
result += "CallableKHR | ";
if ( value & ShaderStageFlagBits::eTaskNV )
result += "TaskNV | ";
if ( value & ShaderStageFlagBits::eMeshNV )
result += "MeshNV | ";
if ( value & ShaderStageFlagBits::eTaskEXT )
result += "TaskEXT | ";
if ( value & ShaderStageFlagBits::eMeshEXT )
result += "MeshEXT | ";
if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI )
result += "SubpassShadingHUAWEI | ";
@ -1543,10 +1547,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "RayTracingShaderKHR | ";
if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT )
result += "FragmentDensityProcessEXT | ";
if ( value & PipelineStageFlagBits2::eTaskShaderNV )
result += "TaskShaderNV | ";
if ( value & PipelineStageFlagBits2::eMeshShaderNV )
result += "MeshShaderNV | ";
if ( value & PipelineStageFlagBits2::eTaskShaderEXT )
result += "TaskShaderEXT | ";
if ( value & PipelineStageFlagBits2::eMeshShaderEXT )
result += "MeshShaderEXT | ";
if ( value & PipelineStageFlagBits2::eSubpassShadingHUAWEI )
result += "SubpassShadingHUAWEI | ";
if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI )
@ -2078,6 +2082,22 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoDecodeUsageFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoDecodeUsageFlagBitsKHR::eTranscoding )
result += "Transcoding | ";
if ( value & VideoDecodeUsageFlagBitsKHR::eOffline )
result += "Offline | ";
if ( value & VideoDecodeUsageFlagBitsKHR::eStreaming )
result += "Streaming | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoDecodeFlagsKHR )
{
return "{}";
@ -2726,6 +2746,40 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeUsageFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeUsageFlagBitsKHR::eTranscoding )
result += "Transcoding | ";
if ( value & VideoEncodeUsageFlagBitsKHR::eStreaming )
result += "Streaming | ";
if ( value & VideoEncodeUsageFlagBitsKHR::eRecording )
result += "Recording | ";
if ( value & VideoEncodeUsageFlagBitsKHR::eConferencing )
result += "Conferencing | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeContentFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
if ( value & VideoEncodeContentFlagBitsKHR::eCamera )
result += "Camera | ";
if ( value & VideoEncodeContentFlagBitsKHR::eDesktop )
result += "Desktop | ";
if ( value & VideoEncodeContentFlagBitsKHR::eRendered )
result += "Rendered | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlFlagsKHR )
{
return "{}";
@ -3288,6 +3342,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eQueueFamilyQueryResultStatusPropertiesKHR: return "QueueFamilyQueryResultStatusPropertiesKHR";
case StructureType::eVideoDecodeInfoKHR: return "VideoDecodeInfoKHR";
case StructureType::eVideoDecodeCapabilitiesKHR: return "VideoDecodeCapabilitiesKHR";
case StructureType::eVideoDecodeUsageInfoKHR: return "VideoDecodeUsageInfoKHR";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
@ -3630,6 +3685,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eVideoEncodeRateControlInfoKHR: return "VideoEncodeRateControlInfoKHR";
case StructureType::eVideoEncodeRateControlLayerInfoKHR: return "VideoEncodeRateControlLayerInfoKHR";
case StructureType::eVideoEncodeCapabilitiesKHR: return "VideoEncodeCapabilitiesKHR";
case StructureType::eVideoEncodeUsageInfoKHR: return "VideoEncodeUsageInfoKHR";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV: return "PhysicalDeviceDiagnosticsConfigFeaturesNV";
case StructureType::eDeviceDiagnosticsConfigCreateInfoNV: return "DeviceDiagnosticsConfigCreateInfoNV";
@ -3662,6 +3718,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV: return "AccelerationStructureGeometryMotionTrianglesDataNV";
case StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV: return "PhysicalDeviceRayTracingMotionBlurFeaturesNV";
case StructureType::eAccelerationStructureMotionInfoNV: return "AccelerationStructureMotionInfoNV";
case StructureType::ePhysicalDeviceMeshShaderFeaturesEXT: return "PhysicalDeviceMeshShaderFeaturesEXT";
case StructureType::ePhysicalDeviceMeshShaderPropertiesEXT: return "PhysicalDeviceMeshShaderPropertiesEXT";
case StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT: return "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
case StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT: return "PhysicalDeviceFragmentDensityMap2FeaturesEXT";
case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT: return "PhysicalDeviceFragmentDensityMap2PropertiesEXT";
@ -3734,6 +3792,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE: return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE";
case StructureType::eDescriptorSetBindingReferenceVALVE: return "DescriptorSetBindingReferenceVALVE";
case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE: return "DescriptorSetLayoutHostMappingInfoVALVE";
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT: return "PhysicalDeviceDepthClampZeroOneFeaturesEXT";
case StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT: return "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT";
case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM: return "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM";
case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM: return "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM";
@ -4354,11 +4413,11 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
case PipelineStageFlagBits::eAccelerationStructureBuildKHR: return "AccelerationStructureBuildKHR";
case PipelineStageFlagBits::eRayTracingShaderKHR: return "RayTracingShaderKHR";
case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV";
case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV";
case PipelineStageFlagBits::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR";
case PipelineStageFlagBits::eCommandPreprocessNV: return "CommandPreprocessNV";
case PipelineStageFlagBits::eTaskShaderEXT: return "TaskShaderEXT";
case PipelineStageFlagBits::eMeshShaderEXT: return "MeshShaderEXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -4446,6 +4505,8 @@ namespace VULKAN_HPP_NAMESPACE
case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches";
case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations";
case QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT: return "TaskShaderInvocationsEXT";
case QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT: return "MeshShaderInvocationsEXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -4484,6 +4545,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case QueryType::eVideoEncodeBitstreamBufferRangeKHR: return "VideoEncodeBitstreamBufferRangeKHR";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case QueryType::eMeshPrimitivesGeneratedEXT: return "MeshPrimitivesGeneratedEXT";
case QueryType::ePrimitivesGeneratedEXT: return "PrimitivesGeneratedEXT";
case QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR: return "AccelerationStructureSerializationBottomLevelPointersKHR";
case QueryType::eAccelerationStructureSizeKHR: return "AccelerationStructureSizeKHR";
@ -4939,8 +5001,8 @@ namespace VULKAN_HPP_NAMESPACE
case ShaderStageFlagBits::eMissKHR: return "MissKHR";
case ShaderStageFlagBits::eIntersectionKHR: return "IntersectionKHR";
case ShaderStageFlagBits::eCallableKHR: return "CallableKHR";
case ShaderStageFlagBits::eTaskNV: return "TaskNV";
case ShaderStageFlagBits::eMeshNV: return "MeshNV";
case ShaderStageFlagBits::eTaskEXT: return "TaskEXT";
case ShaderStageFlagBits::eMeshEXT: return "MeshEXT";
case ShaderStageFlagBits::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -5737,8 +5799,8 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineStageFlagBits2::eAccelerationStructureBuildKHR: return "AccelerationStructureBuildKHR";
case PipelineStageFlagBits2::eRayTracingShaderKHR: return "RayTracingShaderKHR";
case PipelineStageFlagBits2::eFragmentDensityProcessEXT: return "FragmentDensityProcessEXT";
case PipelineStageFlagBits2::eTaskShaderNV: return "TaskShaderNV";
case PipelineStageFlagBits2::eMeshShaderNV: return "MeshShaderNV";
case PipelineStageFlagBits2::eTaskShaderEXT: return "TaskShaderEXT";
case PipelineStageFlagBits2::eMeshShaderEXT: return "MeshShaderEXT";
case PipelineStageFlagBits2::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI";
case PipelineStageFlagBits2::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI";
case PipelineStageFlagBits2::eAccelerationStructureCopyKHR: return "AccelerationStructureCopyKHR";
@ -6220,6 +6282,18 @@ namespace VULKAN_HPP_NAMESPACE
}
}
VULKAN_HPP_INLINE std::string to_string( VideoDecodeUsageFlagBitsKHR value )
{
switch ( value )
{
case VideoDecodeUsageFlagBitsKHR::eDefault: return "Default";
case VideoDecodeUsageFlagBitsKHR::eTranscoding: return "Transcoding";
case VideoDecodeUsageFlagBitsKHR::eOffline: return "Offline";
case VideoDecodeUsageFlagBitsKHR::eStreaming: return "Streaming";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoDecodeFlagBitsKHR )
{
return "(void)";
@ -7261,6 +7335,7 @@ namespace VULKAN_HPP_NAMESPACE
case IndirectCommandsTokenTypeNV::eDrawIndexed: return "DrawIndexed";
case IndirectCommandsTokenTypeNV::eDraw: return "Draw";
case IndirectCommandsTokenTypeNV::eDrawTasks: return "DrawTasks";
case IndirectCommandsTokenTypeNV::eDrawMeshTasks: return "DrawMeshTasks";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -7319,6 +7394,44 @@ namespace VULKAN_HPP_NAMESPACE
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeUsageFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeUsageFlagBitsKHR::eDefault: return "Default";
case VideoEncodeUsageFlagBitsKHR::eTranscoding: return "Transcoding";
case VideoEncodeUsageFlagBitsKHR::eStreaming: return "Streaming";
case VideoEncodeUsageFlagBitsKHR::eRecording: return "Recording";
case VideoEncodeUsageFlagBitsKHR::eConferencing: return "Conferencing";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeContentFlagBitsKHR value )
{
switch ( value )
{
case VideoEncodeContentFlagBitsKHR::eDefault: return "Default";
case VideoEncodeContentFlagBitsKHR::eCamera: return "Camera";
case VideoEncodeContentFlagBitsKHR::eDesktop: return "Desktop";
case VideoEncodeContentFlagBitsKHR::eRendered: return "Rendered";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeTuningModeKHR value )
{
switch ( value )
{
case VideoEncodeTuningModeKHR::eDefault: return "Default";
case VideoEncodeTuningModeKHR::eHighQuality: return "HighQuality";
case VideoEncodeTuningModeKHR::eLowLatency: return "LowLatency";
case VideoEncodeTuningModeKHR::eUltraLowLatency: return "UltraLowLatency";
case VideoEncodeTuningModeKHR::eLossless: return "Lossless";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlModeFlagBitsKHR value )
{
switch ( value )