diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index 6ab87d7..f41a508 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -27,7 +27,7 @@ export module vulkan; export import std; -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 345, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 346, "Wrong VK_HEADER_VERSION!" ); #if defined( _MSC_VER ) # pragma warning( push ) @@ -917,6 +917,30 @@ export using ::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT; using ::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT; + //=== VK_KHR_device_address_commands === + using ::PFN_vkCmdBeginConditionalRendering2EXT; + using ::PFN_vkCmdBeginTransformFeedback2EXT; + using ::PFN_vkCmdBindIndexBuffer3KHR; + using ::PFN_vkCmdBindTransformFeedbackBuffers2EXT; + using ::PFN_vkCmdBindVertexBuffers3KHR; + using ::PFN_vkCmdCopyImageToMemoryKHR; + using ::PFN_vkCmdCopyMemoryKHR; + using ::PFN_vkCmdCopyMemoryToImageKHR; + using ::PFN_vkCmdCopyQueryPoolResultsToMemoryKHR; + using ::PFN_vkCmdDispatchIndirect2KHR; + using ::PFN_vkCmdDrawIndexedIndirect2KHR; + using ::PFN_vkCmdDrawIndexedIndirectCount2KHR; + using ::PFN_vkCmdDrawIndirect2KHR; + using ::PFN_vkCmdDrawIndirectByteCount2EXT; + using ::PFN_vkCmdDrawIndirectCount2KHR; + using ::PFN_vkCmdDrawMeshTasksIndirect2EXT; + using ::PFN_vkCmdDrawMeshTasksIndirectCount2EXT; + using ::PFN_vkCmdEndTransformFeedback2EXT; + using ::PFN_vkCmdFillMemoryKHR; + using ::PFN_vkCmdUpdateMemoryKHR; + using ::PFN_vkCmdWriteMarkerToMemoryAMD; + using ::PFN_vkCreateAccelerationStructure2KHR; + //=== VK_NV_fragment_shading_rate_enums === using ::PFN_vkCmdSetFragmentShadingRateEnumNV; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index de7f470..936cf08 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -37,7 +37,7 @@ # endif #endif -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 345, "Wrong VK_HEADER_VERSION!" ); +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 346, "Wrong VK_HEADER_VERSION!" ); VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { @@ -1102,6 +1102,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkBuildAccelerationStructuresKHR ) DECLARE_IS_DISPATCHED( vkBuildMicromapsEXT ) DECLARE_IS_DISPATCHED( vkClearShaderInstrumentationMetricsARM ) + DECLARE_IS_DISPATCHED( vkCmdBeginConditionalRendering2EXT ) DECLARE_IS_DISPATCHED( vkCmdBeginConditionalRenderingEXT ) DECLARE_IS_DISPATCHED( vkCmdBeginCustomResolveEXT ) DECLARE_IS_DISPATCHED( vkCmdBeginDebugUtilsLabelEXT ) @@ -1114,6 +1115,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdBeginRendering ) DECLARE_IS_DISPATCHED( vkCmdBeginRenderingKHR ) DECLARE_IS_DISPATCHED( vkCmdBeginShaderInstrumentationARM ) + DECLARE_IS_DISPATCHED( vkCmdBeginTransformFeedback2EXT ) DECLARE_IS_DISPATCHED( vkCmdBeginTransformFeedbackEXT ) DECLARE_IS_DISPATCHED( vkCmdBeginVideoCodingKHR ) DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBufferEmbeddedSamplers2EXT ) @@ -1125,6 +1127,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer ) DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2 ) DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2KHR ) + DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer3KHR ) DECLARE_IS_DISPATCHED( vkCmdBindInvocationMaskHUAWEI ) DECLARE_IS_DISPATCHED( vkCmdBindPipeline ) DECLARE_IS_DISPATCHED( vkCmdBindPipelineShaderGroupNV ) @@ -1133,10 +1136,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdBindShadersEXT ) DECLARE_IS_DISPATCHED( vkCmdBindShadingRateImageNV ) DECLARE_IS_DISPATCHED( vkCmdBindTileMemoryQCOM ) + DECLARE_IS_DISPATCHED( vkCmdBindTransformFeedbackBuffers2EXT ) DECLARE_IS_DISPATCHED( vkCmdBindTransformFeedbackBuffersEXT ) DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers ) DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2 ) DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2EXT ) + DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers3KHR ) DECLARE_IS_DISPATCHED( vkCmdBlitImage ) DECLARE_IS_DISPATCHED( vkCmdBlitImage2 ) DECLARE_IS_DISPATCHED( vkCmdBlitImage2KHR ) @@ -1166,15 +1171,19 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer ) DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2 ) DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyImageToMemoryKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToAccelerationStructureKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToMicromapEXT ) DECLARE_IS_DISPATCHED( vkCmdCopyMicromapEXT ) DECLARE_IS_DISPATCHED( vkCmdCopyMicromapToMemoryEXT ) DECLARE_IS_DISPATCHED( vkCmdCopyQueryPoolResults ) + DECLARE_IS_DISPATCHED( vkCmdCopyQueryPoolResultsToMemoryKHR ) DECLARE_IS_DISPATCHED( vkCmdCopyTensorARM ) DECLARE_IS_DISPATCHED( vkCmdCuLaunchKernelNVX ) DECLARE_IS_DISPATCHED( vkCmdCudaLaunchKernelNV ) @@ -1194,21 +1203,29 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectAMDX ) DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectCountAMDX ) DECLARE_IS_DISPATCHED( vkCmdDispatchIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDispatchIndirect2KHR ) DECLARE_IS_DISPATCHED( vkCmdDispatchTileQCOM ) DECLARE_IS_DISPATCHED( vkCmdDraw ) DECLARE_IS_DISPATCHED( vkCmdDrawClusterHUAWEI ) DECLARE_IS_DISPATCHED( vkCmdDrawClusterIndirectHUAWEI ) DECLARE_IS_DISPATCHED( vkCmdDrawIndexed ) DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirect2KHR ) DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCount ) DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountAMD ) DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountKHR ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCount2KHR ) DECLARE_IS_DISPATCHED( vkCmdDrawIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirect2KHR ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectByteCount2EXT ) DECLARE_IS_DISPATCHED( vkCmdDrawIndirectByteCountEXT ) DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCount ) DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountAMD ) DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountKHR ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCount2KHR ) DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirect2EXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCount2EXT ) DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountEXT ) DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountNV ) DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectEXT ) @@ -1230,12 +1247,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdEndRendering2KHR ) DECLARE_IS_DISPATCHED( vkCmdEndRendering2EXT ) DECLARE_IS_DISPATCHED( vkCmdEndShaderInstrumentationARM ) + DECLARE_IS_DISPATCHED( vkCmdEndTransformFeedback2EXT ) DECLARE_IS_DISPATCHED( vkCmdEndTransformFeedbackEXT ) DECLARE_IS_DISPATCHED( vkCmdEndVideoCodingKHR ) DECLARE_IS_DISPATCHED( vkCmdExecuteCommands ) DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsEXT ) DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsNV ) DECLARE_IS_DISPATCHED( vkCmdFillBuffer ) + DECLARE_IS_DISPATCHED( vkCmdFillMemoryKHR ) DECLARE_IS_DISPATCHED( vkCmdInitializeGraphScratchMemoryAMDX ) DECLARE_IS_DISPATCHED( vkCmdInsertDebugUtilsLabelEXT ) DECLARE_IS_DISPATCHED( vkCmdNextSubpass ) @@ -1379,6 +1398,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdTraceRaysKHR ) DECLARE_IS_DISPATCHED( vkCmdTraceRaysNV ) DECLARE_IS_DISPATCHED( vkCmdUpdateBuffer ) + DECLARE_IS_DISPATCHED( vkCmdUpdateMemoryKHR ) DECLARE_IS_DISPATCHED( vkCmdUpdatePipelineIndirectBufferNV ) DECLARE_IS_DISPATCHED( vkCmdWaitEvents ) DECLARE_IS_DISPATCHED( vkCmdWaitEvents2 ) @@ -1387,6 +1407,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCmdWriteAccelerationStructuresPropertiesNV ) DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarker2AMD ) DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarkerAMD ) + DECLARE_IS_DISPATCHED( vkCmdWriteMarkerToMemoryAMD ) DECLARE_IS_DISPATCHED( vkCmdWriteMicromapsPropertiesEXT ) DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp ) DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp2 ) @@ -1405,6 +1426,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE DECLARE_IS_DISPATCHED( vkCopyMemoryToMicromapEXT ) DECLARE_IS_DISPATCHED( vkCopyMicromapEXT ) DECLARE_IS_DISPATCHED( vkCopyMicromapToMemoryEXT ) + DECLARE_IS_DISPATCHED( vkCreateAccelerationStructure2KHR ) DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureKHR ) DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureNV ) DECLARE_IS_DISPATCHED( vkCreateAndroidSurfaceKHR ) @@ -6276,6 +6298,157 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); } + //=== VK_KHR_device_address_commands === + + VULKAN_HPP_INLINE void vkCmdBindIndexBuffer3KHR( VkCommandBuffer commandBuffer, VkBindIndexBuffer3InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindIndexBuffer3KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdBindVertexBuffers3KHR( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + VkBindVertexBuffer3InfoKHR const * pBindingInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindVertexBuffers3KHR( commandBuffer, firstBinding, bindingCount, pBindingInfos ); + } + + VULKAN_HPP_INLINE void vkCmdDrawIndirect2KHR( VkCommandBuffer commandBuffer, VkDrawIndirect2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirect2KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdDrawIndexedIndirect2KHR( VkCommandBuffer commandBuffer, VkDrawIndirect2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirect2KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdDispatchIndirect2KHR( VkCommandBuffer commandBuffer, VkDispatchIndirect2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchIndirect2KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdCopyMemoryKHR( VkCommandBuffer commandBuffer, VkCopyDeviceMemoryInfoKHR const * pCopyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryKHR( commandBuffer, pCopyMemoryInfo ); + } + + VULKAN_HPP_INLINE void vkCmdCopyMemoryToImageKHR( VkCommandBuffer commandBuffer, + VkCopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryToImageKHR( commandBuffer, pCopyMemoryInfo ); + } + + VULKAN_HPP_INLINE void vkCmdCopyImageToMemoryKHR( VkCommandBuffer commandBuffer, + VkCopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImageToMemoryKHR( commandBuffer, pCopyMemoryInfo ); + } + + VULKAN_HPP_INLINE void vkCmdUpdateMemoryKHR( VkCommandBuffer commandBuffer, + VkDeviceAddressRangeKHR const * pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkDeviceSize dataSize, + void const * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdUpdateMemoryKHR( commandBuffer, pDstRange, dstFlags, dataSize, pData ); + } + + VULKAN_HPP_INLINE void vkCmdFillMemoryKHR( VkCommandBuffer commandBuffer, + VkDeviceAddressRangeKHR const * pDstRange, + VkAddressCommandFlagsKHR dstFlags, + uint32_t data ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdFillMemoryKHR( commandBuffer, pDstRange, dstFlags, data ); + } + + VULKAN_HPP_INLINE void vkCmdCopyQueryPoolResultsToMemoryKHR( VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkStridedDeviceAddressRangeKHR const * pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkQueryResultFlags queryResultFlags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyQueryPoolResultsToMemoryKHR( commandBuffer, queryPool, firstQuery, queryCount, pDstRange, dstFlags, queryResultFlags ); + } + + VULKAN_HPP_INLINE void vkCmdDrawIndirectCount2KHR( VkCommandBuffer commandBuffer, VkDrawIndirectCount2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectCount2KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdDrawIndexedIndirectCount2KHR( VkCommandBuffer commandBuffer, + VkDrawIndirectCount2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirectCount2KHR( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void + vkCmdBeginConditionalRendering2EXT( VkCommandBuffer commandBuffer, + VkConditionalRenderingBeginInfo2EXT const * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginConditionalRendering2EXT( commandBuffer, pConditionalRenderingBegin ); + } + + VULKAN_HPP_INLINE void vkCmdBindTransformFeedbackBuffers2EXT( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + VkBindTransformFeedbackBuffer2InfoEXT const * pBindingInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindTransformFeedbackBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBindingInfos ); + } + + VULKAN_HPP_INLINE void vkCmdBeginTransformFeedback2EXT( VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + VkBindTransformFeedbackBuffer2InfoEXT const * pCounterInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginTransformFeedback2EXT( commandBuffer, firstCounterRange, counterRangeCount, pCounterInfos ); + } + + VULKAN_HPP_INLINE void vkCmdEndTransformFeedback2EXT( VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + VkBindTransformFeedbackBuffer2InfoEXT const * pCounterInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndTransformFeedback2EXT( commandBuffer, firstCounterRange, counterRangeCount, pCounterInfos ); + } + + VULKAN_HPP_INLINE void vkCmdDrawIndirectByteCount2EXT( VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBindTransformFeedbackBuffer2InfoEXT const * pCounterInfo, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectByteCount2EXT( commandBuffer, instanceCount, firstInstance, pCounterInfo, counterOffset, vertexStride ); + } + + VULKAN_HPP_INLINE void vkCmdDrawMeshTasksIndirect2EXT( VkCommandBuffer commandBuffer, VkDrawIndirect2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirect2EXT( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdDrawMeshTasksIndirectCount2EXT( VkCommandBuffer commandBuffer, + VkDrawIndirectCount2InfoKHR const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirectCount2EXT( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE void vkCmdWriteMarkerToMemoryAMD( VkCommandBuffer commandBuffer, VkMemoryMarkerInfoAMD const * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteMarkerToMemoryAMD( commandBuffer, pInfo ); + } + + VULKAN_HPP_INLINE VkResult vkCreateAccelerationStructure2KHR( VkDevice device, + VkAccelerationStructureCreateInfo2KHR const * pCreateInfo, + VkAllocationCallbacks const * pAllocator, + VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateAccelerationStructure2KHR( device, pCreateInfo, pAllocator, pAccelerationStructure ); + } + //=== VK_NV_fragment_shading_rate_enums === VULKAN_HPP_INLINE void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, @@ -10115,6 +10288,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_DEPRECATED( "The VK_EXT_descriptor_buffer extension has been deprecated by VK_EXT_descriptor_heap." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME; + //=== VK_KHR_device_address_commands === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceAddressCommandsSpecVersion = VK_KHR_DEVICE_ADDRESS_COMMANDS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceAddressCommandsExtensionName = VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME; + //=== VK_EXT_graphics_pipeline_library === VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibrarySpecVersion = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibraryExtensionName = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME; @@ -16510,6 +16687,43 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_device_address_commands === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_graphics_pipeline_library === template <> struct StructExtends @@ -16781,6 +16995,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_workgroup_memory_explicit_layout === template <> struct StructExtends @@ -22690,6 +22913,30 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; + //=== VK_KHR_device_address_commands === + PFN_vkCmdBindIndexBuffer3KHR vkCmdBindIndexBuffer3KHR = 0; + PFN_vkCmdBindVertexBuffers3KHR vkCmdBindVertexBuffers3KHR = 0; + PFN_vkCmdDrawIndirect2KHR vkCmdDrawIndirect2KHR = 0; + PFN_vkCmdDrawIndexedIndirect2KHR vkCmdDrawIndexedIndirect2KHR = 0; + PFN_vkCmdDispatchIndirect2KHR vkCmdDispatchIndirect2KHR = 0; + PFN_vkCmdCopyMemoryKHR vkCmdCopyMemoryKHR = 0; + PFN_vkCmdCopyMemoryToImageKHR vkCmdCopyMemoryToImageKHR = 0; + PFN_vkCmdCopyImageToMemoryKHR vkCmdCopyImageToMemoryKHR = 0; + PFN_vkCmdUpdateMemoryKHR vkCmdUpdateMemoryKHR = 0; + PFN_vkCmdFillMemoryKHR vkCmdFillMemoryKHR = 0; + PFN_vkCmdCopyQueryPoolResultsToMemoryKHR vkCmdCopyQueryPoolResultsToMemoryKHR = 0; + PFN_vkCmdDrawIndirectCount2KHR vkCmdDrawIndirectCount2KHR = 0; + PFN_vkCmdDrawIndexedIndirectCount2KHR vkCmdDrawIndexedIndirectCount2KHR = 0; + PFN_vkCmdBeginConditionalRendering2EXT vkCmdBeginConditionalRendering2EXT = 0; + PFN_vkCmdBindTransformFeedbackBuffers2EXT vkCmdBindTransformFeedbackBuffers2EXT = 0; + PFN_vkCmdBeginTransformFeedback2EXT vkCmdBeginTransformFeedback2EXT = 0; + PFN_vkCmdEndTransformFeedback2EXT vkCmdEndTransformFeedback2EXT = 0; + PFN_vkCmdDrawIndirectByteCount2EXT vkCmdDrawIndirectByteCount2EXT = 0; + PFN_vkCmdDrawMeshTasksIndirect2EXT vkCmdDrawMeshTasksIndirect2EXT = 0; + PFN_vkCmdDrawMeshTasksIndirectCount2EXT vkCmdDrawMeshTasksIndirectCount2EXT = 0; + PFN_vkCmdWriteMarkerToMemoryAMD vkCmdWriteMarkerToMemoryAMD = 0; + PFN_vkCreateAccelerationStructure2KHR vkCreateAccelerationStructure2KHR = 0; + //=== VK_NV_fragment_shading_rate_enums === PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; @@ -24299,6 +24546,33 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + //=== VK_KHR_device_address_commands === + vkCmdBindIndexBuffer3KHR = PFN_vkCmdBindIndexBuffer3KHR( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer3KHR" ) ); + vkCmdBindVertexBuffers3KHR = PFN_vkCmdBindVertexBuffers3KHR( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers3KHR" ) ); + vkCmdDrawIndirect2KHR = PFN_vkCmdDrawIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect2KHR" ) ); + vkCmdDrawIndexedIndirect2KHR = PFN_vkCmdDrawIndexedIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect2KHR" ) ); + vkCmdDispatchIndirect2KHR = PFN_vkCmdDispatchIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect2KHR" ) ); + vkCmdCopyMemoryKHR = PFN_vkCmdCopyMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryKHR" ) ); + vkCmdCopyMemoryToImageKHR = PFN_vkCmdCopyMemoryToImageKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageKHR" ) ); + vkCmdCopyImageToMemoryKHR = PFN_vkCmdCopyImageToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToMemoryKHR" ) ); + vkCmdUpdateMemoryKHR = PFN_vkCmdUpdateMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdUpdateMemoryKHR" ) ); + vkCmdFillMemoryKHR = PFN_vkCmdFillMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdFillMemoryKHR" ) ); + vkCmdCopyQueryPoolResultsToMemoryKHR = + PFN_vkCmdCopyQueryPoolResultsToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResultsToMemoryKHR" ) ); + vkCmdDrawIndirectCount2KHR = PFN_vkCmdDrawIndirectCount2KHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount2KHR" ) ); + vkCmdDrawIndexedIndirectCount2KHR = PFN_vkCmdDrawIndexedIndirectCount2KHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount2KHR" ) ); + vkCmdBeginConditionalRendering2EXT = PFN_vkCmdBeginConditionalRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRendering2EXT" ) ); + vkCmdBindTransformFeedbackBuffers2EXT = + PFN_vkCmdBindTransformFeedbackBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffers2EXT" ) ); + vkCmdBeginTransformFeedback2EXT = PFN_vkCmdBeginTransformFeedback2EXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedback2EXT" ) ); + vkCmdEndTransformFeedback2EXT = PFN_vkCmdEndTransformFeedback2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedback2EXT" ) ); + vkCmdDrawIndirectByteCount2EXT = PFN_vkCmdDrawIndirectByteCount2EXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCount2EXT" ) ); + vkCmdDrawMeshTasksIndirect2EXT = PFN_vkCmdDrawMeshTasksIndirect2EXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirect2EXT" ) ); + vkCmdDrawMeshTasksIndirectCount2EXT = + PFN_vkCmdDrawMeshTasksIndirectCount2EXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCount2EXT" ) ); + vkCmdWriteMarkerToMemoryAMD = PFN_vkCmdWriteMarkerToMemoryAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteMarkerToMemoryAMD" ) ); + vkCreateAccelerationStructure2KHR = PFN_vkCreateAccelerationStructure2KHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructure2KHR" ) ); + //=== VK_NV_fragment_shading_rate_enums === vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) ); @@ -25644,6 +25918,32 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + //=== VK_KHR_device_address_commands === + vkCmdBindIndexBuffer3KHR = PFN_vkCmdBindIndexBuffer3KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer3KHR" ) ); + vkCmdBindVertexBuffers3KHR = PFN_vkCmdBindVertexBuffers3KHR( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers3KHR" ) ); + vkCmdDrawIndirect2KHR = PFN_vkCmdDrawIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect2KHR" ) ); + vkCmdDrawIndexedIndirect2KHR = PFN_vkCmdDrawIndexedIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect2KHR" ) ); + vkCmdDispatchIndirect2KHR = PFN_vkCmdDispatchIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect2KHR" ) ); + vkCmdCopyMemoryKHR = PFN_vkCmdCopyMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryKHR" ) ); + vkCmdCopyMemoryToImageKHR = PFN_vkCmdCopyMemoryToImageKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageKHR" ) ); + vkCmdCopyImageToMemoryKHR = PFN_vkCmdCopyImageToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToMemoryKHR" ) ); + vkCmdUpdateMemoryKHR = PFN_vkCmdUpdateMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdUpdateMemoryKHR" ) ); + vkCmdFillMemoryKHR = PFN_vkCmdFillMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdFillMemoryKHR" ) ); + vkCmdCopyQueryPoolResultsToMemoryKHR = + PFN_vkCmdCopyQueryPoolResultsToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResultsToMemoryKHR" ) ); + vkCmdDrawIndirectCount2KHR = PFN_vkCmdDrawIndirectCount2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount2KHR" ) ); + vkCmdDrawIndexedIndirectCount2KHR = PFN_vkCmdDrawIndexedIndirectCount2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount2KHR" ) ); + vkCmdBeginConditionalRendering2EXT = PFN_vkCmdBeginConditionalRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRendering2EXT" ) ); + vkCmdBindTransformFeedbackBuffers2EXT = + PFN_vkCmdBindTransformFeedbackBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffers2EXT" ) ); + vkCmdBeginTransformFeedback2EXT = PFN_vkCmdBeginTransformFeedback2EXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedback2EXT" ) ); + vkCmdEndTransformFeedback2EXT = PFN_vkCmdEndTransformFeedback2EXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedback2EXT" ) ); + vkCmdDrawIndirectByteCount2EXT = PFN_vkCmdDrawIndirectByteCount2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCount2EXT" ) ); + vkCmdDrawMeshTasksIndirect2EXT = PFN_vkCmdDrawMeshTasksIndirect2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirect2EXT" ) ); + vkCmdDrawMeshTasksIndirectCount2EXT = PFN_vkCmdDrawMeshTasksIndirectCount2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCount2EXT" ) ); + vkCmdWriteMarkerToMemoryAMD = PFN_vkCmdWriteMarkerToMemoryAMD( vkGetDeviceProcAddr( device, "vkCmdWriteMarkerToMemoryAMD" ) ); + vkCreateAccelerationStructure2KHR = PFN_vkCreateAccelerationStructure2KHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructure2KHR" ) ); + //=== VK_NV_fragment_shading_rate_enums === vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index 5a47c14..304303b 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -66,7 +66,7 @@ extern "C" { //#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 345 +#define VK_HEADER_VERSION 346 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -924,6 +924,22 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR = 1000318000, + VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR = 1000318001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR = 1000318002, + VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR = 1000318003, + VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR = 1000318004, + VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR = 1000318005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR = 1000318006, + VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR = 1000318007, + VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR = 1000318008, + VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR = 1000318009, + VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR = 1000318010, + VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR = 1000318011, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT = 1000318012, + VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT = 1000318013, + VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD = 1000318014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR = 1000318015, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, @@ -12330,6 +12346,375 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( #endif +// VK_KHR_device_address_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_address_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) +#define VK_KHR_DEVICE_ADDRESS_COMMANDS_SPEC_VERSION 1 +#define VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME "VK_KHR_device_address_commands" + +typedef enum VkAccelerationStructureTypeKHR { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureTypeKHR; + +typedef enum VkAddressCommandFlagBitsKHR { + VK_ADDRESS_COMMAND_PROTECTED_BIT_KHR = 0x00000001, + VK_ADDRESS_COMMAND_FULLY_BOUND_BIT_KHR = 0x00000002, + VK_ADDRESS_COMMAND_STORAGE_BUFFER_USAGE_BIT_KHR = 0x00000004, + VK_ADDRESS_COMMAND_UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR = 0x00000008, + VK_ADDRESS_COMMAND_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR = 0x00000010, + VK_ADDRESS_COMMAND_UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR = 0x00000020, + VK_ADDRESS_COMMAND_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAddressCommandFlagBitsKHR; +typedef VkFlags VkAddressCommandFlagsKHR; + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; + +typedef enum VkAccelerationStructureCreateFlagBitsKHR { + VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCreateFlagBitsKHR; +typedef VkFlags VkAccelerationStructureCreateFlagsKHR; +typedef struct VkDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; +} VkDeviceAddressRangeKHR; + +typedef struct VkStridedDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; + VkDeviceSize stride; +} VkStridedDeviceAddressRangeKHR; + +typedef struct VkDeviceMemoryCopyKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR srcRange; + VkAddressCommandFlagsKHR srcFlags; + VkDeviceAddressRangeKHR dstRange; + VkAddressCommandFlagsKHR dstFlags; +} VkDeviceMemoryCopyKHR; + +typedef struct VkCopyDeviceMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t regionCount; + const VkDeviceMemoryCopyKHR* pRegions; +} VkCopyDeviceMemoryInfoKHR; + +typedef struct VkDeviceMemoryImageCopyKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + uint32_t addressRowLength; + uint32_t addressImageHeight; + VkImageSubresourceLayers imageSubresource; + VkImageLayout imageLayout; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkDeviceMemoryImageCopyKHR; + +typedef struct VkCopyDeviceMemoryImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + uint32_t regionCount; + const VkDeviceMemoryImageCopyKHR* pRegions; +} VkCopyDeviceMemoryImageInfoKHR; + +typedef struct VkMemoryRangeBarrierKHR { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkMemoryRangeBarrierKHR; + +typedef struct VkMemoryRangeBarriersInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryRangeBarrierCount; + const VkMemoryRangeBarrierKHR* pMemoryRangeBarriers; +} VkMemoryRangeBarriersInfoKHR; + +typedef struct VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 deviceAddressCommands; +} VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR; + +typedef struct VkBindIndexBuffer3InfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkIndexType indexType; +} VkBindIndexBuffer3InfoKHR; + +typedef struct VkBindVertexBuffer3InfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 setStride; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkBindVertexBuffer3InfoKHR; + +typedef struct VkDrawIndirect2InfoKHR { + VkStructureType sType; + const void* pNext; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + uint32_t drawCount; +} VkDrawIndirect2InfoKHR; + +typedef struct VkDrawIndirectCount2InfoKHR { + VkStructureType sType; + const void* pNext; + VkStridedDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkDeviceAddressRangeKHR countAddressRange; + VkAddressCommandFlagsKHR countAddressFlags; + uint32_t maxDrawCount; +} VkDrawIndirectCount2InfoKHR; + +typedef struct VkDispatchIndirect2InfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkDispatchIndirect2InfoKHR; + +typedef struct VkConditionalRenderingBeginInfo2EXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfo2EXT; + +typedef struct VkBindTransformFeedbackBuffer2InfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; +} VkBindTransformFeedbackBuffer2InfoEXT; + +typedef struct VkMemoryMarkerInfoAMD { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2KHR stage; + VkDeviceAddressRangeKHR dstRange; + VkAddressCommandFlagsKHR dstFlags; + uint32_t marker; +} VkMemoryMarkerInfoAMD; + +typedef struct VkAccelerationStructureCreateInfo2KHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkDeviceAddressRangeKHR addressRange; + VkAddressCommandFlagsKHR addressFlags; + VkAccelerationStructureTypeKHR type; +} VkAccelerationStructureCreateInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer3KHR)(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers3KHR)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect2KHR)(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateMemoryKHR)(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillMemoryKHR)(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResultsToMemoryKHR)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, const VkStridedDeviceAddressRangeKHR* pDstRange, VkAddressCommandFlagsKHR dstFlags, VkQueryResultFlags queryResultFlags); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount2KHR)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRendering2EXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedback2EXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedback2EXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterRange, uint32_t counterRangeCount, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCount2EXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, uint32_t counterOffset, uint32_t vertexStride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirect2EXT)(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCount2EXT)(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMarkerToMemoryAMD)(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructure2KHR)(VkDevice device, const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer3KHR( + VkCommandBuffer commandBuffer, + const VkBindIndexBuffer3InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers3KHR( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBindVertexBuffer3InfoKHR* pBindingInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect2KHR( + VkCommandBuffer commandBuffer, + const VkDispatchIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateMemoryKHR( + VkCommandBuffer commandBuffer, + const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkDeviceSize dataSize, + const void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdFillMemoryKHR( + VkCommandBuffer commandBuffer, + const VkDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + uint32_t data); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResultsToMemoryKHR( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + const VkStridedDeviceAddressRangeKHR* pDstRange, + VkAddressCommandFlagsKHR dstFlags, + VkQueryResultFlags queryResultFlags); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount2KHR( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRendering2EXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedback2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedback2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterRange, + uint32_t counterRangeCount, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCount2EXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo, + uint32_t counterOffset, + uint32_t vertexStride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirect2EXT( + VkCommandBuffer commandBuffer, + const VkDrawIndirect2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCount2EXT( + VkCommandBuffer commandBuffer, + const VkDrawIndirectCount2InfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMarkerToMemoryAMD( + VkCommandBuffer commandBuffer, + const VkMemoryMarkerInfoAMD* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructure2KHR( + VkDevice device, + const VkAccelerationStructureCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); +#endif +#endif + + // VK_KHR_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_fragment_shader_barycentric 1 #define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 @@ -13609,12 +13994,6 @@ typedef enum VkAddressCopyFlagBitsKHR { VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkAddressCopyFlagBitsKHR; typedef VkFlags VkAddressCopyFlagsKHR; -typedef struct VkStridedDeviceAddressRangeKHR { - VkDeviceAddress address; - VkDeviceSize size; - VkDeviceSize stride; -} VkStridedDeviceAddressRangeKHR; - typedef struct VkCopyMemoryIndirectCommandKHR { VkDeviceAddress srcAddress; VkDeviceAddress dstAddress; @@ -14856,12 +15235,6 @@ typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT; #define VK_EXT_conditional_rendering 1 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" - -typedef enum VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, - VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConditionalRenderingFlagBitsEXT; -typedef VkFlags VkConditionalRenderingFlagsEXT; typedef struct VkConditionalRenderingBeginInfoEXT { VkStructureType sType; const void* pNext; @@ -15604,10 +15977,7 @@ typedef struct VkHostAddressRangeConstEXT { size_t size; } VkHostAddressRangeConstEXT; -typedef struct VkDeviceAddressRangeEXT { - VkDeviceAddress address; - VkDeviceSize size; -} VkDeviceAddressRangeEXT; +typedef VkDeviceAddressRangeKHR VkDeviceAddressRangeEXT; typedef struct VkTexelBufferDescriptorInfoEXT { VkStructureType sType; @@ -16460,15 +16830,6 @@ typedef enum VkGeometryTypeKHR { } VkGeometryTypeKHR; typedef VkGeometryTypeKHR VkGeometryTypeNV; - -typedef enum VkAccelerationStructureTypeKHR { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, - VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureTypeKHR; typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; @@ -19103,7 +19464,6 @@ typedef struct VkQueryLowLatencySupportNV { // VK_EXT_descriptor_buffer is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_descriptor_buffer 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) #define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 #define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { @@ -24874,14 +25234,6 @@ typedef enum VkBuildAccelerationStructureModeKHR { VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF } VkBuildAccelerationStructureModeKHR; - -typedef enum VkAccelerationStructureCreateFlagBitsKHR { - VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, - VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, - VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCreateFlagBitsKHR; -typedef VkFlags VkAccelerationStructureCreateFlagsKHR; typedef struct VkAccelerationStructureBuildRangeInfoKHR { uint32_t primitiveCount; uint32_t primitiveOffset; diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index 8ea0262..1729ca5 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -1266,6 +1266,22 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eDescriptorBufferBindingInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT, eDescriptorBufferBindingPushDescriptorBufferHandleEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, eAccelerationStructureCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + eDeviceMemoryCopyKHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR, + eCopyDeviceMemoryInfoKHR = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR, + eDeviceMemoryImageCopyKHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR, + eCopyDeviceMemoryImageInfoKHR = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR, + eMemoryRangeBarriersInfoKHR = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR, + eMemoryRangeBarrierKHR = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR, + ePhysicalDeviceDeviceAddressCommandsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR, + eBindIndexBuffer3InfoKHR = VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR, + eBindVertexBuffer3InfoKHR = VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR, + eDrawIndirect2InfoKHR = VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR, + eDrawIndirectCount2InfoKHR = VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR, + eDispatchIndirect2InfoKHR = VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR, + eConditionalRenderingBeginInfo2EXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT, + eBindTransformFeedbackBuffer2InfoEXT = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT, + eMemoryMarkerInfoAMD = VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD, + eAccelerationStructureCreateInfo2KHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR, ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, eGraphicsPipelineLibraryCreateInfoEXT = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, @@ -3505,6 +3521,23 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE ; }; + // wrapper class for enum VkPipelineLayoutCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html + enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags + { + eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT + }; + + // wrapper using for bitmask VkPipelineLayoutCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlags.html + using PipelineLayoutCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineLayoutCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; + }; + // wrapper class for enum VkPipelineShaderStageCreateFlagBits, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlagBits.html enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags @@ -3528,23 +3561,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; }; - // wrapper class for enum VkPipelineLayoutCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html - enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags - { - eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT - }; - - // wrapper using for bitmask VkPipelineLayoutCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlags.html - using PipelineLayoutCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineLayoutCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; - }; - // wrapper class for enum VkBorderColor, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBorderColor.html enum class BorderColor { @@ -3997,31 +4013,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE eInstance = VK_VERTEX_INPUT_RATE_INSTANCE }; - // wrapper class for enum VkPolygonMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPolygonMode.html - enum class PolygonMode - { - eFill = VK_POLYGON_MODE_FILL, - eLine = VK_POLYGON_MODE_LINE, - ePoint = VK_POLYGON_MODE_POINT, - eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV - }; - - // wrapper class for enum VkPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrimitiveTopology.html - enum class PrimitiveTopology - { - ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, - eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, - eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, - eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, - eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, - eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, - eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, - ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - }; - // wrapper class for enum VkPipelineColorBlendStateCreateFlagBits, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlagBits.html enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags @@ -4067,6 +4058,31 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT; }; + // wrapper class for enum VkPolygonMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPolygonMode.html + enum class PolygonMode + { + eFill = VK_POLYGON_MODE_FILL, + eLine = VK_POLYGON_MODE_LINE, + ePoint = VK_POLYGON_MODE_POINT, + eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV + }; + + // wrapper class for enum VkPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrimitiveTopology.html + enum class PrimitiveTopology + { + ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, + eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, + eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, + eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, + eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, + eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, + eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, + eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, + ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + }; + enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags { }; @@ -8167,6 +8183,33 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; #endif /*VK_USE_PLATFORM_METAL_EXT*/ + //=== VK_KHR_device_address_commands === + + // wrapper class for enum VkAddressCommandFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCommandFlagBitsKHR.html + enum class AddressCommandFlagBitsKHR : VkAddressCommandFlagsKHR + { + eProtected = VK_ADDRESS_COMMAND_PROTECTED_BIT_KHR, + eFullyBound = VK_ADDRESS_COMMAND_FULLY_BOUND_BIT_KHR, + eStorageBufferUsage = VK_ADDRESS_COMMAND_STORAGE_BUFFER_USAGE_BIT_KHR, + eUnknownStorageBufferUsage = VK_ADDRESS_COMMAND_UNKNOWN_STORAGE_BUFFER_USAGE_BIT_KHR, + eTransformFeedbackBufferUsage = VK_ADDRESS_COMMAND_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR, + eUnknownTransformFeedbackBufferUsage = VK_ADDRESS_COMMAND_UNKNOWN_TRANSFORM_FEEDBACK_BUFFER_USAGE_BIT_KHR + }; + + // wrapper using for bitmask VkAddressCommandFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCommandFlagsKHR.html + using AddressCommandFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAddressCommandFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AddressCommandFlagsKHR allFlags = + AddressCommandFlagBitsKHR::eProtected | AddressCommandFlagBitsKHR::eFullyBound | AddressCommandFlagBitsKHR::eStorageBufferUsage | + AddressCommandFlagBitsKHR::eUnknownStorageBufferUsage | AddressCommandFlagBitsKHR::eTransformFeedbackBufferUsage | + AddressCommandFlagBitsKHR::eUnknownTransformFeedbackBufferUsage; + }; + //=== VK_EXT_graphics_pipeline_library === // wrapper class for enum VkGraphicsPipelineLibraryFlagBitsEXT, see diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 890ac84..97d094c 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -328,6 +328,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_METAL_EXT*/ "VK_KHR_synchronization2", "VK_EXT_descriptor_buffer", + "VK_KHR_device_address_commands", "VK_EXT_graphics_pipeline_library", "VK_AMD_shader_early_and_late_fragment_tests", "VK_KHR_fragment_shader_barycentric", @@ -1874,6 +1875,26 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE "VK_KHR_synchronization2", } } }, { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_device_address_commands", + { { "VK_VERSION_1_0", + { { + "VK_EXT_extended_dynamic_state", + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_extended_dynamic_state", + "VK_KHR_buffer_device_address", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_2", + { { + "VK_EXT_extended_dynamic_state", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, { "VK_EXT_graphics_pipeline_library", { { "VK_VERSION_1_0", { { @@ -3967,12 +3988,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_METAL_EXT ) || ( extension == "VK_EXT_metal_objects" ) #endif /*VK_USE_PLATFORM_METAL_EXT*/ - || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_EXT_graphics_pipeline_library" ) || - ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) || ( extension == "VK_KHR_fragment_shader_barycentric" ) || - ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || - ( extension == "VK_NV_fragment_shading_rate_enums" ) || ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) || - ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_fragment_density_map2" ) || - ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) || + || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_KHR_device_address_commands" ) || + ( extension == "VK_EXT_graphics_pipeline_library" ) || ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) || + ( extension == "VK_KHR_fragment_shader_barycentric" ) || ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) || + ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_NV_fragment_shading_rate_enums" ) || + ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || + ( extension == "VK_EXT_fragment_density_map2" ) || ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_workgroup_memory_explicit_layout" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_image_compression_control" ) || ( extension == "VK_EXT_attachment_feedback_loop_layout" ) || ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_device_fault" ) || diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index 89d1e85..200835a 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -15905,9 +15905,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; - nameInfo.objectType = handle.objectType; + nameInfo.objectType = handle.objectType; +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - nameInfo.pObjectName = name.c_str(); +# else + nameInfo.objectHandle = static_cast( handle ); +# endif + nameInfo.pObjectName = name.c_str(); return setDebugUtilsObjectNameEXT( nameInfo, d ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -15946,11 +15950,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; - tagInfo.objectType = handle.objectType; + tagInfo.objectType = handle.objectType; +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - tagInfo.tagName = name; - tagInfo.tagSize = sizeof( TagType ); - tagInfo.pTag = &tag; +# else + tagInfo.objectHandle = static_cast( handle ); +# endif + tagInfo.tagName = name; + tagInfo.tagSize = sizeof( TagType ); + tagInfo.pTag = &tag; return setDebugUtilsObjectTagEXT( tagInfo, d ); } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ @@ -24250,6 +24258,645 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindIndexBuffer3KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindIndexBuffer3KHR && "Function requires " ); +# endif + + d.vkCmdBindIndexBuffer3KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers3KHR( + uint32_t firstBinding, uint32_t bindingCount, BindVertexBuffer3InfoKHR const * pBindingInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindVertexBuffers3KHR( + static_cast( m_commandBuffer ), firstBinding, bindingCount, reinterpret_cast( pBindingInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers3KHR( + uint32_t firstBinding, ArrayProxy const & bindingInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers3KHR && "Function requires " ); +# endif + + d.vkCmdBindVertexBuffers3KHR( + m_commandBuffer, firstBinding, bindingInfos.size(), reinterpret_cast( bindingInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirect2KHR( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirect2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirect2KHR( DrawIndirect2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawIndirect2KHR && "Function requires " ); +# endif + + d.vkCmdDrawIndirect2KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirect2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawIndexedIndirect2KHR && "Function requires " ); +# endif + + d.vkCmdDrawIndexedIndirect2KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect2KHR( DispatchIndirect2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchIndirect2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect2KHR( DispatchIndirect2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDispatchIndirect2KHR && "Function requires " ); +# endif + + d.vkCmdDispatchIndirect2KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryKHR( CopyDeviceMemoryInfoKHR const * pCopyMemoryInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryKHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyMemoryInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryKHR( Optional copyMemoryInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryKHR && "Function requires " ); +# endif + + d.vkCmdCopyMemoryKHR( m_commandBuffer, reinterpret_cast( copyMemoryInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageKHR( CopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryToImageKHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyMemoryInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageKHR( Optional copyMemoryInfo, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageKHR && "Function requires " ); +# endif + + d.vkCmdCopyMemoryToImageKHR( m_commandBuffer, reinterpret_cast( copyMemoryInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToMemoryKHR( CopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImageToMemoryKHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyMemoryInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToMemoryKHR( Optional copyMemoryInfo, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImageToMemoryKHR && "Function requires " ); +# endif + + d.vkCmdCopyImageToMemoryKHR( m_commandBuffer, reinterpret_cast( copyMemoryInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::updateMemoryKHR( + DeviceAddressRangeKHR const * pDstRange, AddressCommandFlagsKHR dstFlags, DeviceSize dataSize, void const * pData, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdUpdateMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pDstRange ), + static_cast( dstFlags ), + static_cast( dataSize ), + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::updateMemoryKHR( + DeviceAddressRangeKHR const & dstRange, AddressCommandFlagsKHR dstFlags, ArrayProxy const & data, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdUpdateMemoryKHR && "Function requires " ); +# endif + + d.vkCmdUpdateMemoryKHR( m_commandBuffer, + reinterpret_cast( &dstRange ), + static_cast( dstFlags ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::fillMemoryKHR( + DeviceAddressRangeKHR const * pDstRange, AddressCommandFlagsKHR dstFlags, uint32_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdFillMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pDstRange ), + static_cast( dstFlags ), + data ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::fillMemoryKHR( + DeviceAddressRangeKHR const & dstRange, AddressCommandFlagsKHR dstFlags, uint32_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdFillMemoryKHR && "Function requires " ); +# endif + + d.vkCmdFillMemoryKHR( + m_commandBuffer, reinterpret_cast( &dstRange ), static_cast( dstFlags ), data ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResultsToMemoryKHR( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + QueryResultFlags queryResultFlags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyQueryPoolResultsToMemoryKHR( static_cast( m_commandBuffer ), + static_cast( queryPool ), + firstQuery, + queryCount, + reinterpret_cast( pDstRange ), + static_cast( dstFlags ), + static_cast( queryResultFlags ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResultsToMemoryKHR( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + QueryResultFlags queryResultFlags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyQueryPoolResultsToMemoryKHR && "Function requires " ); +# endif + + d.vkCmdCopyQueryPoolResultsToMemoryKHR( m_commandBuffer, + static_cast( queryPool ), + firstQuery, + queryCount, + reinterpret_cast( &dstRange ), + static_cast( dstFlags ), + static_cast( queryResultFlags ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectCount2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawIndirectCount2KHR && "Function requires " ); +# endif + + d.vkCmdDrawIndirectCount2KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirectCount2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawIndexedIndirectCount2KHR && "Function requires " ); +# endif + + d.vkCmdDrawIndexedIndirectCount2KHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const * pConditionalRenderingBegin, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginConditionalRendering2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( pConditionalRenderingBegin ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const & conditionalRenderingBegin, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRendering2EXT && "Function requires " ); +# endif + + d.vkCmdBeginConditionalRendering2EXT( m_commandBuffer, reinterpret_cast( &conditionalRenderingBegin ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffers2EXT( + uint32_t firstBinding, uint32_t bindingCount, BindTransformFeedbackBuffer2InfoEXT const * pBindingInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindTransformFeedbackBuffers2EXT( static_cast( m_commandBuffer ), + firstBinding, + bindingCount, + reinterpret_cast( pBindingInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffers2EXT( + uint32_t firstBinding, ArrayProxy const & bindingInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffers2EXT && + "Function requires " ); +# endif + + d.vkCmdBindTransformFeedbackBuffers2EXT( + m_commandBuffer, firstBinding, bindingInfos.size(), reinterpret_cast( bindingInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedback2EXT( + uint32_t firstCounterRange, uint32_t counterRangeCount, BindTransformFeedbackBuffer2InfoEXT const * pCounterInfos, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginTransformFeedback2EXT( static_cast( m_commandBuffer ), + firstCounterRange, + counterRangeCount, + reinterpret_cast( pCounterInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedback2EXT( + uint32_t firstCounterRange, ArrayProxy const & counterInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedback2EXT && "Function requires " ); +# endif + + d.vkCmdBeginTransformFeedback2EXT( + m_commandBuffer, firstCounterRange, counterInfos.size(), reinterpret_cast( counterInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedback2EXT( + uint32_t firstCounterRange, uint32_t counterRangeCount, BindTransformFeedbackBuffer2InfoEXT const * pCounterInfos, Dispatch const & d ) + const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndTransformFeedback2EXT( static_cast( m_commandBuffer ), + firstCounterRange, + counterRangeCount, + reinterpret_cast( pCounterInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedback2EXT( + uint32_t firstCounterRange, ArrayProxy const & counterInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedback2EXT && "Function requires " ); +# endif + + d.vkCmdEndTransformFeedback2EXT( + m_commandBuffer, firstCounterRange, counterInfos.size(), reinterpret_cast( counterInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const * pCounterInfo, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectByteCount2EXT( static_cast( m_commandBuffer ), + instanceCount, + firstInstance, + reinterpret_cast( pCounterInfo ), + counterOffset, + vertexStride ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const & counterInfo, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawIndirectByteCount2EXT && "Function requires " ); +# endif + + d.vkCmdDrawIndirectByteCount2EXT( m_commandBuffer, + instanceCount, + firstInstance, + reinterpret_cast( &counterInfo ), + counterOffset, + vertexStride ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirect2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawMeshTasksIndirect2EXT && "Function requires " ); +# endif + + d.vkCmdDrawMeshTasksIndirect2EXT( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirectCount2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawMeshTasksIndirectCount2EXT && "Function requires " ); +# endif + + d.vkCmdDrawMeshTasksIndirectCount2EXT( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteMarkerToMemoryAMD( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWriteMarkerToMemoryAMD && "Function requires " ); +# endif + + d.vkCmdWriteMarkerToMemoryAMD( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructure2KHR( AccelerationStructureCreateInfo2KHR const * pCreateInfo, + AllocationCallbacks const * pAllocator, + AccelerationStructureKHR * pAccelerationStructure, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateAccelerationStructure2KHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pAccelerationStructure ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createAccelerationStructure2KHR( + AccelerationStructureCreateInfo2KHR const & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructure2KHR && "Function requires " ); +# endif + + AccelerationStructureKHR accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructure2KHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructure2KHR" ); + + return detail::createResultValueType( result, std::move( accelerationStructure ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createAccelerationStructure2KHRUnique( + AccelerationStructureCreateInfo2KHR const & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructure2KHR && "Function requires " ); +# endif + + AccelerationStructureKHR accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructure2KHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructure2KHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( accelerationStructure, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_fragment_shading_rate_enums === // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index 94cb109..3e86f64 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -947,7 +947,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_descriptor_heap === struct HostAddressRangeEXT; struct HostAddressRangeConstEXT; - struct DeviceAddressRangeEXT; struct TexelBufferDescriptorInfoEXT; struct ImageDescriptorInfoEXT; struct ResourceDescriptorInfoEXT; @@ -1424,6 +1423,27 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct OpaqueCaptureDescriptorDataCreateInfoEXT; struct AccelerationStructureCaptureDescriptorDataInfoEXT; + //=== VK_KHR_device_address_commands === + struct DeviceAddressRangeKHR; + using DeviceAddressRangeEXT = DeviceAddressRangeKHR; + struct StridedDeviceAddressRangeKHR; + struct DeviceMemoryCopyKHR; + struct CopyDeviceMemoryInfoKHR; + struct DeviceMemoryImageCopyKHR; + struct CopyDeviceMemoryImageInfoKHR; + struct MemoryRangeBarriersInfoKHR; + struct MemoryRangeBarrierKHR; + struct PhysicalDeviceDeviceAddressCommandsFeaturesKHR; + struct BindIndexBuffer3InfoKHR; + struct BindVertexBuffer3InfoKHR; + struct DrawIndirect2InfoKHR; + struct DrawIndirectCount2InfoKHR; + struct DispatchIndirect2InfoKHR; + struct ConditionalRenderingBeginInfo2EXT; + struct BindTransformFeedbackBuffer2InfoEXT; + struct MemoryMarkerInfoAMD; + struct AccelerationStructureCreateInfo2KHR; + //=== VK_EXT_graphics_pipeline_library === struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; @@ -2054,7 +2074,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE struct TileMemorySizeInfoQCOM; //=== VK_KHR_copy_memory_indirect === - struct StridedDeviceAddressRangeKHR; struct CopyMemoryIndirectCommandKHR; using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; struct CopyMemoryIndirectInfoKHR; @@ -7571,6 +7590,305 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE uint32_t set, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + template ::type = true> + void bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + template ::type = true> + void bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + template ::type = true> + void bindVertexBuffers3KHR( uint32_t firstBinding, + uint32_t bindingCount, + BindVertexBuffer3InfoKHR const * pBindingInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + template ::type = true> + void bindVertexBuffers3KHR( uint32_t firstBinding, + ArrayProxy const & bindingInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + template ::type = true> + void drawIndirect2KHR( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + template ::type = true> + void drawIndirect2KHR( DrawIndirect2InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + template ::type = true> + void drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + template ::type = true> + void drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + template ::type = true> + void dispatchIndirect2KHR( DispatchIndirect2InfoKHR const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + template ::type = true> + void dispatchIndirect2KHR( DispatchIndirect2InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + template ::type = true> + void copyMemoryKHR( CopyDeviceMemoryInfoKHR const * pCopyMemoryInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + template ::type = true> + void copyMemoryKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + template ::type = true> + void copyMemoryToImageKHR( CopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + template ::type = true> + void copyMemoryToImageKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + template ::type = true> + void copyImageToMemoryKHR( CopyDeviceMemoryImageInfoKHR const * pCopyMemoryInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + template ::type = true> + void copyImageToMemoryKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template ::type = true> + void updateMemoryKHR( DeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + DeviceSize dataSize, + void const * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template ::type = true> + void updateMemoryKHR( DeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + ArrayProxy const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + template ::type = true> + void fillMemoryKHR( DeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + uint32_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + template ::type = true> + void fillMemoryKHR( DeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + uint32_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + template ::type = true> + void copyQueryPoolResultsToMemoryKHR( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + QueryResultFlags queryResultFlags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + template ::type = true> + void copyQueryPoolResultsToMemoryKHR( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + QueryResultFlags queryResultFlags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + template ::type = true> + void drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + template ::type = true> + void drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + template ::type = true> + void drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + template ::type = true> + void drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + template ::type = true> + void beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const * pConditionalRenderingBegin, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + template ::type = true> + void beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const & conditionalRenderingBegin, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + template ::type = true> + void bindTransformFeedbackBuffers2EXT( uint32_t firstBinding, + uint32_t bindingCount, + BindTransformFeedbackBuffer2InfoEXT const * pBindingInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + template ::type = true> + void bindTransformFeedbackBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & bindingInfos VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + template ::type = true> + void beginTransformFeedback2EXT( uint32_t firstCounterRange, + uint32_t counterRangeCount, + BindTransformFeedbackBuffer2InfoEXT const * pCounterInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + template ::type = true> + void beginTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + template ::type = true> + void endTransformFeedback2EXT( uint32_t firstCounterRange, + uint32_t counterRangeCount, + BindTransformFeedbackBuffer2InfoEXT const * pCounterInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + template ::type = true> + void endTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + template ::type = true> + void drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const * pCounterInfo, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + template ::type = true> + void drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const & counterInfo, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + template ::type = true> + void drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + template ::type = true> + void drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + template ::type = true> + void drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + template ::type = true> + void drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + template ::type = true> + void writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + template ::type = true> + void writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_fragment_shading_rate_enums === // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see @@ -17350,6 +17668,37 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createAccelerationStructure2KHR( AccelerationStructureCreateInfo2KHR const * pCreateInfo, + AllocationCallbacks const * pAllocator, + AccelerationStructureKHR * pAccelerationStructure, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructure2KHR( AccelerationStructureCreateInfo2KHR const & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createAccelerationStructure2KHRUnique( AccelerationStructureCreateInfo2KHR const & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_device_fault === // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index 11308d7..80d118c 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -685,6 +685,34 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressRangeKHR const & deviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeKHR.address ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeKHR.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfo2KHR const & accelerationStructureCreateInfo2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.createFlags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfo2KHR.type ); + return seed; + } + }; + template <> struct hash { @@ -1512,18 +1540,6 @@ VULKAN_HPP_EXPORT namespace std } }; - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT const & deviceAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.size ); - return seed; - } - }; - template <> struct hash { @@ -1621,6 +1637,21 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBuffer3InfoKHR const & bindIndexBuffer3InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBuffer3InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBuffer3InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBuffer3InfoKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBuffer3InfoKHR.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBuffer3InfoKHR.indexType ); + return seed; + } + }; + template <> struct hash { @@ -1828,6 +1859,48 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindTransformFeedbackBuffer2InfoEXT const & bindTransformFeedbackBuffer2InfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindTransformFeedbackBuffer2InfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindTransformFeedbackBuffer2InfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindTransformFeedbackBuffer2InfoEXT.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, bindTransformFeedbackBuffer2InfoEXT.addressFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBuffer3InfoKHR const & bindVertexBuffer3InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBuffer3InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBuffer3InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBuffer3InfoKHR.setStride ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBuffer3InfoKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBuffer3InfoKHR.addressFlags ); + return seed; + } + }; + template <> struct hash { @@ -2923,6 +2996,21 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfo2EXT const & conditionalRenderingBeginInfo2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfo2EXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfo2EXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfo2EXT.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfo2EXT.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfo2EXT.flags ); + return seed; + } + }; + template <> struct hash { @@ -3114,6 +3202,71 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryImageCopyKHR const & deviceMemoryImageCopyKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.addressRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.addressImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.imageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryImageCopyKHR.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDeviceMemoryImageInfoKHR const & copyDeviceMemoryImageInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryImageInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryImageInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryImageInfoKHR.image ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryImageInfoKHR.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryImageInfoKHR.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryCopyKHR const & deviceMemoryCopyKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.srcRange ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.srcFlags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.dstRange ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryCopyKHR.dstFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDeviceMemoryInfoKHR const & copyDeviceMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryInfoKHR.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyDeviceMemoryInfoKHR.pRegions ); + return seed; + } + }; + template <> struct hash { @@ -3233,19 +3386,6 @@ VULKAN_HPP_EXPORT namespace std } }; - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride ); - return seed; - } - }; - template <> struct hash { @@ -5291,6 +5431,20 @@ VULKAN_HPP_EXPORT namespace std }; # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirect2InfoKHR const & dispatchIndirect2InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirect2InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirect2InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirect2InfoKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirect2InfoKHR.addressFlags ); + return seed; + } + }; + template <> struct hash { @@ -5587,6 +5741,21 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirect2InfoKHR const & drawIndirect2InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawIndirect2InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirect2InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirect2InfoKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirect2InfoKHR.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirect2InfoKHR.drawCount ); + return seed; + } + }; + template <> struct hash { @@ -5601,6 +5770,23 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCount2InfoKHR const & drawIndirectCount2InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.addressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.countAddressRange ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.countAddressFlags ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCount2InfoKHR.maxDrawCount ); + return seed; + } + }; + template <> struct hash { @@ -8532,6 +8718,22 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMarkerInfoAMD const & memoryMarkerInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.stage ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.dstRange ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.dstFlags ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMarkerInfoAMD.marker ); + return seed; + } + }; + # if defined( VK_USE_PLATFORM_METAL_EXT ) template <> struct hash @@ -8574,6 +8776,40 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRangeBarrierKHR const & memoryRangeBarrierKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.addressRange ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarrierKHR.addressFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRangeBarriersInfoKHR const & memoryRangeBarriersInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarriersInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarriersInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarriersInfoKHR.memoryRangeBarrierCount ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRangeBarriersInfoKHR.pMemoryRangeBarriers ); + return seed; + } + }; + template <> struct hash { @@ -10512,6 +10748,20 @@ VULKAN_HPP_EXPORT namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceAddressCommandsFeaturesKHR const & physicalDeviceDeviceAddressCommandsFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceAddressCommandsFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceAddressCommandsFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceAddressCommandsFeaturesKHR.deviceAddressCommands ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 4e0d607..79166b2 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -1607,6 +1607,32 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + //=== VK_KHR_device_address_commands === + vkCmdBindIndexBuffer3KHR = PFN_vkCmdBindIndexBuffer3KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer3KHR" ) ); + vkCmdBindVertexBuffers3KHR = PFN_vkCmdBindVertexBuffers3KHR( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers3KHR" ) ); + vkCmdDrawIndirect2KHR = PFN_vkCmdDrawIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect2KHR" ) ); + vkCmdDrawIndexedIndirect2KHR = PFN_vkCmdDrawIndexedIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect2KHR" ) ); + vkCmdDispatchIndirect2KHR = PFN_vkCmdDispatchIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect2KHR" ) ); + vkCmdCopyMemoryKHR = PFN_vkCmdCopyMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryKHR" ) ); + vkCmdCopyMemoryToImageKHR = PFN_vkCmdCopyMemoryToImageKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageKHR" ) ); + vkCmdCopyImageToMemoryKHR = PFN_vkCmdCopyImageToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToMemoryKHR" ) ); + vkCmdUpdateMemoryKHR = PFN_vkCmdUpdateMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdUpdateMemoryKHR" ) ); + vkCmdFillMemoryKHR = PFN_vkCmdFillMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdFillMemoryKHR" ) ); + vkCmdCopyQueryPoolResultsToMemoryKHR = + PFN_vkCmdCopyQueryPoolResultsToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResultsToMemoryKHR" ) ); + vkCmdDrawIndirectCount2KHR = PFN_vkCmdDrawIndirectCount2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount2KHR" ) ); + vkCmdDrawIndexedIndirectCount2KHR = PFN_vkCmdDrawIndexedIndirectCount2KHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount2KHR" ) ); + vkCmdBeginConditionalRendering2EXT = PFN_vkCmdBeginConditionalRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRendering2EXT" ) ); + vkCmdBindTransformFeedbackBuffers2EXT = + PFN_vkCmdBindTransformFeedbackBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffers2EXT" ) ); + vkCmdBeginTransformFeedback2EXT = PFN_vkCmdBeginTransformFeedback2EXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedback2EXT" ) ); + vkCmdEndTransformFeedback2EXT = PFN_vkCmdEndTransformFeedback2EXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedback2EXT" ) ); + vkCmdDrawIndirectByteCount2EXT = PFN_vkCmdDrawIndirectByteCount2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCount2EXT" ) ); + vkCmdDrawMeshTasksIndirect2EXT = PFN_vkCmdDrawMeshTasksIndirect2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirect2EXT" ) ); + vkCmdDrawMeshTasksIndirectCount2EXT = PFN_vkCmdDrawMeshTasksIndirectCount2EXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCount2EXT" ) ); + vkCmdWriteMarkerToMemoryAMD = PFN_vkCmdWriteMarkerToMemoryAMD( vkGetDeviceProcAddr( device, "vkCmdWriteMarkerToMemoryAMD" ) ); + vkCreateAccelerationStructure2KHR = PFN_vkCreateAccelerationStructure2KHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructure2KHR" ) ); + //=== VK_NV_fragment_shading_rate_enums === vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); @@ -2717,6 +2743,30 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; + //=== VK_KHR_device_address_commands === + PFN_vkCmdBindIndexBuffer3KHR vkCmdBindIndexBuffer3KHR = 0; + PFN_vkCmdBindVertexBuffers3KHR vkCmdBindVertexBuffers3KHR = 0; + PFN_vkCmdDrawIndirect2KHR vkCmdDrawIndirect2KHR = 0; + PFN_vkCmdDrawIndexedIndirect2KHR vkCmdDrawIndexedIndirect2KHR = 0; + PFN_vkCmdDispatchIndirect2KHR vkCmdDispatchIndirect2KHR = 0; + PFN_vkCmdCopyMemoryKHR vkCmdCopyMemoryKHR = 0; + PFN_vkCmdCopyMemoryToImageKHR vkCmdCopyMemoryToImageKHR = 0; + PFN_vkCmdCopyImageToMemoryKHR vkCmdCopyImageToMemoryKHR = 0; + PFN_vkCmdUpdateMemoryKHR vkCmdUpdateMemoryKHR = 0; + PFN_vkCmdFillMemoryKHR vkCmdFillMemoryKHR = 0; + PFN_vkCmdCopyQueryPoolResultsToMemoryKHR vkCmdCopyQueryPoolResultsToMemoryKHR = 0; + PFN_vkCmdDrawIndirectCount2KHR vkCmdDrawIndirectCount2KHR = 0; + PFN_vkCmdDrawIndexedIndirectCount2KHR vkCmdDrawIndexedIndirectCount2KHR = 0; + PFN_vkCmdBeginConditionalRendering2EXT vkCmdBeginConditionalRendering2EXT = 0; + PFN_vkCmdBindTransformFeedbackBuffers2EXT vkCmdBindTransformFeedbackBuffers2EXT = 0; + PFN_vkCmdBeginTransformFeedback2EXT vkCmdBeginTransformFeedback2EXT = 0; + PFN_vkCmdEndTransformFeedback2EXT vkCmdEndTransformFeedback2EXT = 0; + PFN_vkCmdDrawIndirectByteCount2EXT vkCmdDrawIndirectByteCount2EXT = 0; + PFN_vkCmdDrawMeshTasksIndirect2EXT vkCmdDrawMeshTasksIndirect2EXT = 0; + PFN_vkCmdDrawMeshTasksIndirectCount2EXT vkCmdDrawMeshTasksIndirectCount2EXT = 0; + PFN_vkCmdWriteMarkerToMemoryAMD vkCmdWriteMarkerToMemoryAMD = 0; + PFN_vkCreateAccelerationStructure2KHR vkCreateAccelerationStructure2KHR = 0; + //=== VK_NV_fragment_shading_rate_enums === PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; @@ -5440,6 +5490,14 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD typename ResultValueType::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT( AccelerationStructureCaptureDescriptorDataInfoEXT const & info ) const; + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructure2KHR( AccelerationStructureCreateInfo2KHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + //=== VK_EXT_device_fault === // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html @@ -5919,6 +5977,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR; public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + AccelerationStructureKHR( Device const & device, + AccelerationStructureCreateInfo2KHR const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createAccelerationStructure2KHR( createInfo, allocator ); + } +# endif + # if !defined( VULKAN_HPP_NO_EXCEPTIONS ) AccelerationStructureKHR( Device const & device, AccelerationStructureCreateInfoKHR const & createInfo, @@ -7781,6 +7848,108 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineLayout layout, uint32_t set ) const VULKAN_HPP_NOEXCEPT; + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + void bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + void bindVertexBuffers3KHR( uint32_t firstBinding, ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + void drawIndirect2KHR( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + void drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + void dispatchIndirect2KHR( DispatchIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + void copyMemoryKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + void + copyMemoryToImageKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + void + copyImageToMemoryKHR( Optional copyMemoryInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + void updateMemoryKHR( DeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + DeviceSize dataSize, + void const * pData ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template + void updateMemoryKHR( DeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + void fillMemoryKHR( DeviceAddressRangeKHR const & dstRange, AddressCommandFlagsKHR dstFlags, uint32_t data ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + void copyQueryPoolResultsToMemoryKHR( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + QueryResultFlags queryResultFlags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + void drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + void drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + void beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + void bindTransformFeedbackBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & bindingInfos + VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + void beginTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos + VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + void endTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos + VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + void drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const & counterInfo, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + void drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + void drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + void writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const & info ) const VULKAN_HPP_NOEXCEPT; + //=== VK_NV_fragment_shading_rate_enums === // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see @@ -21719,9 +21888,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; - nameInfo.objectType = handle.objectType; + nameInfo.objectType = handle.objectType; +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - nameInfo.pObjectName = name.c_str(); +# else + nameInfo.objectHandle = static_cast( handle ); +# endif + nameInfo.pObjectName = name.c_str(); return setDebugUtilsObjectNameEXT( nameInfo ); } @@ -21746,11 +21919,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; - tagInfo.objectType = handle.objectType; + tagInfo.objectType = handle.objectType; +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - tagInfo.tagName = name; - tagInfo.tagSize = sizeof( TagType ); - tagInfo.pTag = &tag; +# else + tagInfo.objectHandle = static_cast( handle ); +# endif + tagInfo.tagName = name; + tagInfo.tagSize = sizeof( TagType ); + tagInfo.pTag = &tag; return setDebugUtilsObjectTagEXT( tagInfo ); } @@ -25533,6 +25710,291 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); } + //=== VK_KHR_device_address_commands === + + // wrapper function for command vkCmdBindIndexBuffer3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer3KHR.html + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer3KHR( BindIndexBuffer3InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer3KHR && "Function requires " ); + + getDispatcher()->vkCmdBindIndexBuffer3KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdBindVertexBuffers3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers3KHR.html + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers3KHR( uint32_t firstBinding, + ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers3KHR && "Function requires " ); + + getDispatcher()->vkCmdBindVertexBuffers3KHR( static_cast( m_commandBuffer ), + firstBinding, + bindingInfos.size(), + reinterpret_cast( bindingInfos.data() ) ); + } + + // wrapper function for command vkCmdDrawIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirect2KHR( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirect2KHR && "Function requires " ); + + getDispatcher()->vkCmdDrawIndirect2KHR( static_cast( m_commandBuffer ), reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdDrawIndexedIndirect2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect2KHR( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirect2KHR && "Function requires " ); + + getDispatcher()->vkCmdDrawIndexedIndirect2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdDispatchIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect2KHR( DispatchIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchIndirect2KHR && "Function requires " ); + + getDispatcher()->vkCmdDispatchIndirect2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdCopyMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryKHR( Optional copyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryKHR && "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( copyMemoryInfo.get() ) ); + } + + // wrapper function for command vkCmdCopyMemoryToImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageKHR( Optional copyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageKHR && "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryToImageKHR( static_cast( m_commandBuffer ), + reinterpret_cast( copyMemoryInfo.get() ) ); + } + + // wrapper function for command vkCmdCopyImageToMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToMemoryKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyImageToMemoryKHR( Optional copyMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToMemoryKHR && "Function requires " ); + + getDispatcher()->vkCmdCopyImageToMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( copyMemoryInfo.get() ) ); + } + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + VULKAN_HPP_INLINE void CommandBuffer::updateMemoryKHR( DeviceAddressRangeKHR const * pDstRange, + AddressCommandFlagsKHR dstFlags, + DeviceSize dataSize, + void const * pData ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateMemoryKHR && "Function requires " ); + getDispatcher()->vkCmdUpdateMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pDstRange ), + static_cast( dstFlags ), + static_cast( dataSize ), + pData ); + } + + // wrapper function for command vkCmdUpdateMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateMemoryKHR.html + template + VULKAN_HPP_INLINE void CommandBuffer::updateMemoryKHR( DeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateMemoryKHR && "Function requires " ); + + getDispatcher()->vkCmdUpdateMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &dstRange ), + static_cast( dstFlags ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ); + } + + // wrapper function for command vkCmdFillMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillMemoryKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::fillMemoryKHR( DeviceAddressRangeKHR const & dstRange, AddressCommandFlagsKHR dstFlags, uint32_t data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdFillMemoryKHR && "Function requires " ); + + getDispatcher()->vkCmdFillMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &dstRange ), + static_cast( dstFlags ), + data ); + } + + // wrapper function for command vkCmdCopyQueryPoolResultsToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResultsToMemoryKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResultsToMemoryKHR( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + StridedDeviceAddressRangeKHR const & dstRange, + AddressCommandFlagsKHR dstFlags, + QueryResultFlags queryResultFlags ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyQueryPoolResultsToMemoryKHR && + "Function requires " ); + + getDispatcher()->vkCmdCopyQueryPoolResultsToMemoryKHR( static_cast( m_commandBuffer ), + static_cast( queryPool ), + firstQuery, + queryCount, + reinterpret_cast( &dstRange ), + static_cast( dstFlags ), + static_cast( queryResultFlags ) ); + } + + // wrapper function for command vkCmdDrawIndirectCount2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCount2KHR && "Function requires " ); + + getDispatcher()->vkCmdDrawIndirectCount2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCount2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount2KHR( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirectCount2KHR && + "Function requires " ); + + getDispatcher()->vkCmdDrawIndexedIndirectCount2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdBeginConditionalRendering2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRendering2EXT.html + VULKAN_HPP_INLINE void + CommandBuffer::beginConditionalRendering2EXT( ConditionalRenderingBeginInfo2EXT const & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginConditionalRendering2EXT && + "Function requires " ); + + getDispatcher()->vkCmdBeginConditionalRendering2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( &conditionalRenderingBegin ) ); + } + + // wrapper function for command vkCmdBindTransformFeedbackBuffers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffers2EXT.html + VULKAN_HPP_INLINE void + CommandBuffer::bindTransformFeedbackBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTransformFeedbackBuffers2EXT && + "Function requires " ); + + getDispatcher()->vkCmdBindTransformFeedbackBuffers2EXT( static_cast( m_commandBuffer ), + firstBinding, + bindingInfos.size(), + reinterpret_cast( bindingInfos.data() ) ); + } + + // wrapper function for command vkCmdBeginTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedback2EXT.html + VULKAN_HPP_INLINE void + CommandBuffer::beginTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginTransformFeedback2EXT && + "Function requires " ); + + getDispatcher()->vkCmdBeginTransformFeedback2EXT( static_cast( m_commandBuffer ), + firstCounterRange, + counterInfos.size(), + reinterpret_cast( counterInfos.data() ) ); + } + + // wrapper function for command vkCmdEndTransformFeedback2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedback2EXT.html + VULKAN_HPP_INLINE void + CommandBuffer::endTransformFeedback2EXT( uint32_t firstCounterRange, + ArrayProxy const & counterInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedback2EXT && + "Function requires " ); + + getDispatcher()->vkCmdEndTransformFeedback2EXT( static_cast( m_commandBuffer ), + firstCounterRange, + counterInfos.size(), + reinterpret_cast( counterInfos.data() ) ); + } + + // wrapper function for command vkCmdDrawIndirectByteCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCount2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCount2EXT( uint32_t instanceCount, + uint32_t firstInstance, + BindTransformFeedbackBuffer2InfoEXT const & counterInfo, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectByteCount2EXT && + "Function requires " ); + + getDispatcher()->vkCmdDrawIndirectByteCount2EXT( static_cast( m_commandBuffer ), + instanceCount, + firstInstance, + reinterpret_cast( &counterInfo ), + counterOffset, + vertexStride ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirect2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirect2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirect2EXT( DrawIndirect2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirect2EXT && + "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirect2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectCount2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCount2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCount2EXT( DrawIndirectCount2InfoKHR const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCount2EXT && + "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirectCount2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdWriteMarkerToMemoryAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMarkerToMemoryAMD.html + VULKAN_HPP_INLINE void CommandBuffer::writeMarkerToMemoryAMD( MemoryMarkerInfoAMD const & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteMarkerToMemoryAMD && "Function requires " ); + + getDispatcher()->vkCmdWriteMarkerToMemoryAMD( static_cast( m_commandBuffer ), reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCreateAccelerationStructure2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructure2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createAccelerationStructure2KHR( AccelerationStructureCreateInfo2KHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAccelerationStructure2KHR && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; + Result result = + static_cast( getDispatcher()->vkCreateAccelerationStructure2KHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createAccelerationStructure2KHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, AccelerationStructureKHR( *this, *reinterpret_cast( &accelerationStructure ), allocator ) ); + } + //=== VK_NV_fragment_shading_rate_enums === // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index 52ac823..294e022 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -3620,12 +3620,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "HostAddressRangeConstEXT is not nothrow_move_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT ) == sizeof( VkDeviceAddressRangeEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceAddressRangeEXT is not nothrow_move_constructible!" ); - VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT ) == sizeof( VkTexelBufferDescriptorInfoEXT ), "struct and wrapper have different size!" ); VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); @@ -5822,6 +5816,117 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "AccelerationStructureCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); +//=== VK_KHR_device_address_commands === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressRangeKHR ) == sizeof( VkDeviceAddressRangeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceAddressRangeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR ) == sizeof( VkStridedDeviceAddressRangeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StridedDeviceAddressRangeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryCopyKHR ) == sizeof( VkDeviceMemoryCopyKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceMemoryCopyKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyDeviceMemoryInfoKHR ) == sizeof( VkCopyDeviceMemoryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyDeviceMemoryInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryImageCopyKHR ) == sizeof( VkDeviceMemoryImageCopyKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceMemoryImageCopyKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyDeviceMemoryImageInfoKHR ) == sizeof( VkCopyDeviceMemoryImageInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyDeviceMemoryImageInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRangeBarriersInfoKHR ) == sizeof( VkMemoryRangeBarriersInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryRangeBarriersInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRangeBarrierKHR ) == sizeof( VkMemoryRangeBarrierKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryRangeBarrierKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceAddressCommandsFeaturesKHR ) == + sizeof( VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceAddressCommandsFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindIndexBuffer3InfoKHR ) == sizeof( VkBindIndexBuffer3InfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindIndexBuffer3InfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVertexBuffer3InfoKHR ) == sizeof( VkBindVertexBuffer3InfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindVertexBuffer3InfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirect2InfoKHR ) == sizeof( VkDrawIndirect2InfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawIndirect2InfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirectCount2InfoKHR ) == sizeof( VkDrawIndirectCount2InfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawIndirectCount2InfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchIndirect2InfoKHR ) == sizeof( VkDispatchIndirect2InfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchIndirect2InfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfo2EXT ) == sizeof( VkConditionalRenderingBeginInfo2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ConditionalRenderingBeginInfo2EXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindTransformFeedbackBuffer2InfoEXT ) == sizeof( VkBindTransformFeedbackBuffer2InfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindTransformFeedbackBuffer2InfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMarkerInfoAMD ) == sizeof( VkMemoryMarkerInfoAMD ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryMarkerInfoAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfo2KHR ) == sizeof( VkAccelerationStructureCreateInfo2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureCreateInfo2KHR is not nothrow_move_constructible!" ); + //=== VK_EXT_graphics_pipeline_library === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ) == @@ -8566,12 +8671,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StridedDeviceAddressRangeKHR is not nothrow_move_constructible!" ); - VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR ) == sizeof( VkCopyMemoryIndirectCommandKHR ), "struct and wrapper have different size!" ); VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index d92ab72..533e32e 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -1686,6 +1686,295 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = AccelerationStructureCaptureDescriptorDataInfoEXT; }; + // wrapper struct for struct VkDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressRangeKHR.html + struct DeviceAddressRangeKHR + { + using NativeType = VkDeviceAddressRangeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceAddressRangeKHR( DeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceAddressRangeKHR( VkDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceAddressRangeKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceAddressRangeKHR & operator=( DeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceAddressRangeKHR & operator=( VkDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceAddressRangeKHR const & ) const = default; +#else + bool operator==( DeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ); +# endif + } + + bool operator!=( DeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress address = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceAddressRangeKHR; + }; +#endif + using DeviceAddressRangeEXT = DeviceAddressRangeKHR; + + // wrapper struct for struct VkAccelerationStructureCreateInfo2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfo2KHR.html + struct AccelerationStructureCreateInfo2KHR + { + using NativeType = VkAccelerationStructureCreateInfo2KHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfo2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfo2KHR( AccelerationStructureCreateFlagsKHR createFlags_ = {}, + DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + AccelerationStructureTypeKHR type_ = AccelerationStructureTypeKHR::eTopLevel, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , createFlags{ createFlags_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , type{ type_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfo2KHR( AccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureCreateInfo2KHR( VkAccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureCreateInfo2KHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureCreateInfo2KHR & operator=( AccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureCreateInfo2KHR & operator=( VkAccelerationStructureCreateInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) & VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) && VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfo2KHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureCreateInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfo2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfo2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfo2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createFlags, addressRange, addressFlags, type ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureCreateInfo2KHR const & ) const = default; +#else + bool operator==( AccelerationStructureCreateInfo2KHR 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 ) && ( createFlags == rhs.createFlags ) && ( addressRange == rhs.addressRange ) && + ( addressFlags == rhs.addressFlags ) && ( type == rhs.type ); +# endif + } + + bool operator!=( AccelerationStructureCreateInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureCreateInfo2KHR; + void const * pNext = {}; + AccelerationStructureCreateFlagsKHR createFlags = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + AccelerationStructureTypeKHR type = AccelerationStructureTypeKHR::eTopLevel; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfo2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfo2KHR; + }; + // wrapper struct for struct VkAccelerationStructureCreateInfoKHR, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoKHR.html struct AccelerationStructureCreateInfoKHR @@ -11836,118 +12125,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo; - // wrapper struct for struct VkDeviceAddressRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressRangeEXT.html - struct DeviceAddressRangeEXT - { - using NativeType = VkDeviceAddressRangeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddress address_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceAddressRangeEXT( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceAddressRangeEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceAddressRangeEXT & operator=( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceAddressRangeEXT & operator=( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceAddressRangeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceAddressRangeEXT const & ) const = default; -#else - bool operator==( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ); -# endif - } - - bool operator!=( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress address = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceAddressRangeEXT; - }; -#endif - // wrapper struct for struct VkBindHeapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindHeapInfoEXT.html struct BindHeapInfoEXT { @@ -11994,13 +12171,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setHeapRange( DeviceAddressRangeEXT heapRange_ ) & VULKAN_HPP_NOEXCEPT { heapRange = heapRange_; return *this; } - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setHeapRange( DeviceAddressRangeEXT heapRange_ ) && VULKAN_HPP_NOEXCEPT { heapRange = heapRange_; return std::move( *this ); @@ -12937,6 +13114,161 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; + // wrapper struct for struct VkBindIndexBuffer3InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBuffer3InfoKHR.html + struct BindIndexBuffer3InfoKHR + { + using NativeType = VkBindIndexBuffer3InfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindIndexBuffer3InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindIndexBuffer3InfoKHR( DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + IndexType indexType_ = IndexType::eUint16, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , indexType{ indexType_ } + { + } + + VULKAN_HPP_CONSTEXPR BindIndexBuffer3InfoKHR( BindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindIndexBuffer3InfoKHR( VkBindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : BindIndexBuffer3InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + BindIndexBuffer3InfoKHR & operator=( BindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindIndexBuffer3InfoKHR & operator=( VkBindIndexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBuffer3InfoKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindIndexBuffer3InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBuffer3InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBuffer3InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindIndexBuffer3InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags, indexType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindIndexBuffer3InfoKHR const & ) const = default; +#else + bool operator==( BindIndexBuffer3InfoKHR 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) && + ( indexType == rhs.indexType ); +# endif + } + + bool operator!=( BindIndexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindIndexBuffer3InfoKHR; + void const * pNext = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + IndexType indexType = IndexType::eUint16; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindIndexBuffer3InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = BindIndexBuffer3InfoKHR; + }; + // wrapper struct for struct VkBindIndexBufferIndirectCommandEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandEXT.html struct BindIndexBufferIndirectCommandEXT @@ -15142,6 +15474,426 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = BindTensorMemoryInfoARM; }; + // wrapper struct for struct VkBindTransformFeedbackBuffer2InfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindTransformFeedbackBuffer2InfoEXT.html + struct BindTransformFeedbackBuffer2InfoEXT + { + using NativeType = VkBindTransformFeedbackBuffer2InfoEXT; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindTransformFeedbackBuffer2InfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindTransformFeedbackBuffer2InfoEXT( DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR BindTransformFeedbackBuffer2InfoEXT( BindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindTransformFeedbackBuffer2InfoEXT( VkBindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BindTransformFeedbackBuffer2InfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + BindTransformFeedbackBuffer2InfoEXT & operator=( BindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindTransformFeedbackBuffer2InfoEXT & operator=( VkBindTransformFeedbackBuffer2InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTransformFeedbackBuffer2InfoEXT && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindTransformFeedbackBuffer2InfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindTransformFeedbackBuffer2InfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindTransformFeedbackBuffer2InfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindTransformFeedbackBuffer2InfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindTransformFeedbackBuffer2InfoEXT const & ) const = default; +#else + bool operator==( BindTransformFeedbackBuffer2InfoEXT 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ); +# endif + } + + bool operator!=( BindTransformFeedbackBuffer2InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindTransformFeedbackBuffer2InfoEXT; + void const * pNext = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindTransformFeedbackBuffer2InfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BindTransformFeedbackBuffer2InfoEXT; + }; + + // wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html + struct StridedDeviceAddressRangeKHR + { + using NativeType = VkStridedDeviceAddressRangeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : StridedDeviceAddressRangeKHR( *reinterpret_cast( &rhs ) ) + { + } + + StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size, stride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default; +#else + bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride ); +# endif + } + + bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress address = {}; + DeviceSize size = {}; + DeviceSize stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StridedDeviceAddressRangeKHR; + }; +#endif + + // wrapper struct for struct VkBindVertexBuffer3InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBuffer3InfoKHR.html + struct BindVertexBuffer3InfoKHR + { + using NativeType = VkBindVertexBuffer3InfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindVertexBuffer3InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindVertexBuffer3InfoKHR( Bool32 setStride_ = {}, + StridedDeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , setStride{ setStride_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR BindVertexBuffer3InfoKHR( BindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindVertexBuffer3InfoKHR( VkBindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : BindVertexBuffer3InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + BindVertexBuffer3InfoKHR & operator=( BindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindVertexBuffer3InfoKHR & operator=( VkBindVertexBuffer3InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setSetStride( Bool32 setStride_ ) & VULKAN_HPP_NOEXCEPT + { + setStride = setStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setSetStride( Bool32 setStride_ ) && VULKAN_HPP_NOEXCEPT + { + setStride = setStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBuffer3InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindVertexBuffer3InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBuffer3InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBuffer3InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindVertexBuffer3InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, setStride, addressRange, addressFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindVertexBuffer3InfoKHR const & ) const = default; +#else + bool operator==( BindVertexBuffer3InfoKHR 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 ) && ( setStride == rhs.setStride ) && ( addressRange == rhs.addressRange ) && + ( addressFlags == rhs.addressFlags ); +# endif + } + + bool operator!=( BindVertexBuffer3InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindVertexBuffer3InfoKHR; + void const * pNext = {}; + Bool32 setStride = {}; + StridedDeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindVertexBuffer3InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = BindVertexBuffer3InfoKHR; + }; + // wrapper struct for struct VkBindVertexBufferIndirectCommandEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandEXT.html struct BindVertexBufferIndirectCommandEXT @@ -27208,6 +27960,162 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = ComputePipelineIndirectBufferInfoNV; }; + // wrapper struct for struct VkConditionalRenderingBeginInfo2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfo2EXT.html + struct ConditionalRenderingBeginInfo2EXT + { + using NativeType = VkConditionalRenderingBeginInfo2EXT; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfo2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfo2EXT( DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + ConditionalRenderingFlagsEXT flags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfo2EXT( ConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ConditionalRenderingBeginInfo2EXT( VkConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ConditionalRenderingBeginInfo2EXT( *reinterpret_cast( &rhs ) ) + { + } + + ConditionalRenderingBeginInfo2EXT & operator=( ConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ConditionalRenderingBeginInfo2EXT & operator=( VkConditionalRenderingBeginInfo2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfo2EXT && setFlags( ConditionalRenderingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkConditionalRenderingBeginInfo2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfo2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfo2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfo2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ConditionalRenderingBeginInfo2EXT const & ) const = default; +#else + bool operator==( ConditionalRenderingBeginInfo2EXT 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) && + ( flags == rhs.flags ); +# endif + } + + bool operator!=( ConditionalRenderingBeginInfo2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eConditionalRenderingBeginInfo2EXT; + void const * pNext = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + ConditionalRenderingFlagsEXT flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ConditionalRenderingBeginInfo2EXT; + }; +#endif + + template <> + struct CppType + { + using Type = ConditionalRenderingBeginInfo2EXT; + }; + // wrapper struct for struct VkConditionalRenderingBeginInfoEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfoEXT.html struct ConditionalRenderingBeginInfoEXT @@ -29457,6 +30365,744 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = CopyDescriptorSet; }; + // wrapper struct for struct VkDeviceMemoryImageCopyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryImageCopyKHR.html + struct DeviceMemoryImageCopyKHR + { + using NativeType = VkDeviceMemoryImageCopyKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryImageCopyKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceMemoryImageCopyKHR( DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + uint32_t addressRowLength_ = {}, + uint32_t addressImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + ImageLayout imageLayout_ = ImageLayout::eUndefined, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , addressRowLength{ addressRowLength_ } + , addressImageHeight{ addressImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageLayout{ imageLayout_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryImageCopyKHR( DeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryImageCopyKHR( VkDeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceMemoryImageCopyKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryImageCopyKHR & operator=( DeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceMemoryImageCopyKHR & operator=( VkDeviceMemoryImageCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressRowLength( uint32_t addressRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + addressRowLength = addressRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressRowLength( uint32_t addressRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + addressRowLength = addressRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setAddressImageHeight( uint32_t addressImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + addressImageHeight = addressImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setAddressImageHeight( uint32_t addressImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + addressImageHeight = addressImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryImageCopyKHR && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceMemoryImageCopyKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryImageCopyKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryImageCopyKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceMemoryImageCopyKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, addressRange, addressFlags, addressRowLength, addressImageHeight, imageSubresource, imageLayout, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryImageCopyKHR const & ) const = default; +#else + bool operator==( DeviceMemoryImageCopyKHR 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) && + ( addressRowLength == rhs.addressRowLength ) && ( addressImageHeight == rhs.addressImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && + ( imageLayout == rhs.imageLayout ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( DeviceMemoryImageCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceMemoryImageCopyKHR; + void const * pNext = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + uint32_t addressRowLength = {}; + uint32_t addressImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + ImageLayout imageLayout = ImageLayout::eUndefined; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceMemoryImageCopyKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceMemoryImageCopyKHR; + }; + + // wrapper struct for struct VkCopyDeviceMemoryImageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDeviceMemoryImageInfoKHR.html + struct CopyDeviceMemoryImageInfoKHR + { + using NativeType = VkCopyDeviceMemoryImageInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDeviceMemoryImageInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyDeviceMemoryImageInfoKHR( Image image_ = {}, + uint32_t regionCount_ = {}, + DeviceMemoryImageCopyKHR const * pRegions_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyDeviceMemoryImageInfoKHR( CopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyDeviceMemoryImageInfoKHR( VkCopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyDeviceMemoryImageInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyDeviceMemoryImageInfoKHR( Image image_, ArrayProxyNoTemporaries const & regions_, void const * pNext_ = nullptr ) + : pNext( pNext_ ), image( image_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyDeviceMemoryImageInfoKHR & operator=( CopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyDeviceMemoryImageInfoKHR & operator=( VkCopyDeviceMemoryImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR & setPRegions( DeviceMemoryImageCopyKHR const * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryImageInfoKHR && setPRegions( DeviceMemoryImageCopyKHR const * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyDeviceMemoryImageInfoKHR & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyDeviceMemoryImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryImageInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryImageInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryImageInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyDeviceMemoryImageInfoKHR const & ) const = default; +#else + bool operator==( CopyDeviceMemoryImageInfoKHR 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 ) && ( image == rhs.image ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyDeviceMemoryImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyDeviceMemoryImageInfoKHR; + void const * pNext = {}; + Image image = {}; + uint32_t regionCount = {}; + DeviceMemoryImageCopyKHR const * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyDeviceMemoryImageInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyDeviceMemoryImageInfoKHR; + }; + + // wrapper struct for struct VkDeviceMemoryCopyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryCopyKHR.html + struct DeviceMemoryCopyKHR + { + using NativeType = VkDeviceMemoryCopyKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryCopyKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceMemoryCopyKHR( DeviceAddressRangeKHR srcRange_ = {}, + AddressCommandFlagsKHR srcFlags_ = {}, + DeviceAddressRangeKHR dstRange_ = {}, + AddressCommandFlagsKHR dstFlags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcRange{ srcRange_ } + , srcFlags{ srcFlags_ } + , dstRange{ dstRange_ } + , dstFlags{ dstFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryCopyKHR( DeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryCopyKHR( VkDeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceMemoryCopyKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryCopyKHR & operator=( DeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceMemoryCopyKHR & operator=( VkDeviceMemoryCopyKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setSrcRange( DeviceAddressRangeKHR const & srcRange_ ) & VULKAN_HPP_NOEXCEPT + { + srcRange = srcRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setSrcRange( DeviceAddressRangeKHR const & srcRange_ ) && VULKAN_HPP_NOEXCEPT + { + srcRange = srcRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setSrcFlags( AddressCommandFlagsKHR srcFlags_ ) & VULKAN_HPP_NOEXCEPT + { + srcFlags = srcFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setSrcFlags( AddressCommandFlagsKHR srcFlags_ ) && VULKAN_HPP_NOEXCEPT + { + srcFlags = srcFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setDstRange( DeviceAddressRangeKHR const & dstRange_ ) & VULKAN_HPP_NOEXCEPT + { + dstRange = dstRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setDstRange( DeviceAddressRangeKHR const & dstRange_ ) && VULKAN_HPP_NOEXCEPT + { + dstRange = dstRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR & setDstFlags( AddressCommandFlagsKHR dstFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dstFlags = dstFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryCopyKHR && setDstFlags( AddressCommandFlagsKHR dstFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dstFlags = dstFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceMemoryCopyKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryCopyKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryCopyKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceMemoryCopyKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcRange, srcFlags, dstRange, dstFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryCopyKHR const & ) const = default; +#else + bool operator==( DeviceMemoryCopyKHR 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 ) && ( srcRange == rhs.srcRange ) && ( srcFlags == rhs.srcFlags ) && ( dstRange == rhs.dstRange ) && + ( dstFlags == rhs.dstFlags ); +# endif + } + + bool operator!=( DeviceMemoryCopyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceMemoryCopyKHR; + void const * pNext = {}; + DeviceAddressRangeKHR srcRange = {}; + AddressCommandFlagsKHR srcFlags = {}; + DeviceAddressRangeKHR dstRange = {}; + AddressCommandFlagsKHR dstFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceMemoryCopyKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceMemoryCopyKHR; + }; + + // wrapper struct for struct VkCopyDeviceMemoryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDeviceMemoryInfoKHR.html + struct CopyDeviceMemoryInfoKHR + { + using NativeType = VkCopyDeviceMemoryInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDeviceMemoryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + CopyDeviceMemoryInfoKHR( uint32_t regionCount_ = {}, DeviceMemoryCopyKHR const * pRegions_ = {}, void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyDeviceMemoryInfoKHR( CopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyDeviceMemoryInfoKHR( VkCopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyDeviceMemoryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyDeviceMemoryInfoKHR( ArrayProxyNoTemporaries const & regions_, void const * pNext_ = nullptr ) + : pNext( pNext_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyDeviceMemoryInfoKHR & operator=( CopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyDeviceMemoryInfoKHR & operator=( VkCopyDeviceMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR & setPRegions( DeviceMemoryCopyKHR const * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDeviceMemoryInfoKHR && setPRegions( DeviceMemoryCopyKHR const * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyDeviceMemoryInfoKHR & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyDeviceMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyDeviceMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyDeviceMemoryInfoKHR const & ) const = default; +#else + bool operator==( CopyDeviceMemoryInfoKHR 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 ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyDeviceMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyDeviceMemoryInfoKHR; + void const * pNext = {}; + uint32_t regionCount = {}; + DeviceMemoryCopyKHR const * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyDeviceMemoryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyDeviceMemoryInfoKHR; + }; + // wrapper struct for struct VkImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy2.html struct ImageCopy2 { @@ -30901,132 +32547,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE #endif using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; - // wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html - struct StridedDeviceAddressRangeKHR - { - using NativeType = VkStridedDeviceAddressRangeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : StridedDeviceAddressRangeKHR( *reinterpret_cast( &rhs ) ) - { - } - - StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size, stride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default; -#else - bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride ); -# endif - } - - bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress address = {}; - DeviceSize size = {}; - DeviceSize stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StridedDeviceAddressRangeKHR; - }; -#endif - // wrapper struct for struct VkCopyMemoryIndirectInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectInfoKHR.html struct CopyMemoryIndirectInfoKHR { @@ -49620,44 +51140,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressType( DeviceFaultAddressTypeEXT addressType_ ) & VULKAN_HPP_NOEXCEPT - { - addressType = addressType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressType( DeviceFaultAddressTypeEXT addressType_ ) && VULKAN_HPP_NOEXCEPT - { - addressType = addressType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setReportedAddress( DeviceAddress reportedAddress_ ) & VULKAN_HPP_NOEXCEPT - { - reportedAddress = reportedAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setReportedAddress( DeviceAddress reportedAddress_ ) && VULKAN_HPP_NOEXCEPT - { - reportedAddress = reportedAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressPrecision( DeviceSize addressPrecision_ ) & VULKAN_HPP_NOEXCEPT - { - addressPrecision = addressPrecision_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressPrecision( DeviceSize addressPrecision_ ) && VULKAN_HPP_NOEXCEPT - { - addressPrecision = addressPrecision_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkDeviceFaultAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -49893,19 +51375,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE { } -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceFaultVendorInfoEXT( std::string const & description_, uint64_t vendorFaultCode_ = {}, uint64_t vendorFaultData_ = {} ) - : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ ) - { - VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); -# if defined( _WIN32 ) - strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); -# else - strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); -# endif - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - DeviceFaultVendorInfoEXT & operator=( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ @@ -49915,57 +51384,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return *this; } -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setDescription( std::array description_ ) & VULKAN_HPP_NOEXCEPT - { - description = description_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setDescription( std::array description_ ) && VULKAN_HPP_NOEXCEPT - { - description = description_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); -# if defined( _WIN32 ) - strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); -# else - strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); -# endif - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultCode( uint64_t vendorFaultCode_ ) & VULKAN_HPP_NOEXCEPT - { - vendorFaultCode = vendorFaultCode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultCode( uint64_t vendorFaultCode_ ) && VULKAN_HPP_NOEXCEPT - { - vendorFaultCode = vendorFaultCode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultData( uint64_t vendorFaultData_ ) & VULKAN_HPP_NOEXCEPT - { - vendorFaultData = vendorFaultData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultData( uint64_t vendorFaultData_ ) && VULKAN_HPP_NOEXCEPT - { - vendorFaultData = vendorFaultData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkDeviceFaultVendorInfoEXT const &() const VULKAN_HPP_NOEXCEPT { return *reinterpret_cast( this ); @@ -54726,6 +56144,144 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE # endif #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + // wrapper struct for struct VkDispatchIndirect2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchIndirect2InfoKHR.html + struct DispatchIndirect2InfoKHR + { + using NativeType = VkDispatchIndirect2InfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDispatchIndirect2InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DispatchIndirect2InfoKHR( DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR DispatchIndirect2InfoKHR( DispatchIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchIndirect2InfoKHR( VkDispatchIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchIndirect2InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DispatchIndirect2InfoKHR & operator=( DispatchIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchIndirect2InfoKHR & operator=( VkDispatchIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirect2InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchIndirect2InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchIndirect2InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchIndirect2InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchIndirect2InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DispatchIndirect2InfoKHR const & ) const = default; +#else + bool operator==( DispatchIndirect2InfoKHR 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ); +# endif + } + + bool operator!=( DispatchIndirect2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDispatchIndirect2InfoKHR; + void const * pNext = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DispatchIndirect2InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DispatchIndirect2InfoKHR; + }; + // wrapper struct for struct VkDispatchIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchIndirectCommand.html struct DispatchIndirectCommand { @@ -57251,6 +58807,161 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; #endif + // wrapper struct for struct VkDrawIndirect2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirect2InfoKHR.html + struct DrawIndirect2InfoKHR + { + using NativeType = VkDrawIndirect2InfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrawIndirect2InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrawIndirect2InfoKHR( StridedDeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + uint32_t drawCount_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , drawCount{ drawCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawIndirect2InfoKHR( DrawIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawIndirect2InfoKHR( VkDrawIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawIndirect2InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DrawIndirect2InfoKHR & operator=( DrawIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawIndirect2InfoKHR & operator=( VkDrawIndirect2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR & setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR && setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR & setDrawCount( uint32_t drawCount_ ) & VULKAN_HPP_NOEXCEPT + { + drawCount = drawCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirect2InfoKHR && setDrawCount( uint32_t drawCount_ ) && VULKAN_HPP_NOEXCEPT + { + drawCount = drawCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawIndirect2InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirect2InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirect2InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawIndirect2InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags, drawCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawIndirect2InfoKHR const & ) const = default; +#else + bool operator==( DrawIndirect2InfoKHR 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) && + ( drawCount == rhs.drawCount ); +# endif + } + + bool operator!=( DrawIndirect2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDrawIndirect2InfoKHR; + void const * pNext = {}; + StridedDeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + uint32_t drawCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawIndirect2InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DrawIndirect2InfoKHR; + }; + // wrapper struct for struct VkDrawIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCommand.html struct DrawIndirectCommand { @@ -57394,6 +59105,197 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE }; #endif + // wrapper struct for struct VkDrawIndirectCount2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCount2InfoKHR.html + struct DrawIndirectCount2InfoKHR + { + using NativeType = VkDrawIndirectCount2InfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrawIndirectCount2InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrawIndirectCount2InfoKHR( StridedDeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + DeviceAddressRangeKHR countAddressRange_ = {}, + AddressCommandFlagsKHR countAddressFlags_ = {}, + uint32_t maxDrawCount_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + , countAddressRange{ countAddressRange_ } + , countAddressFlags{ countAddressFlags_ } + , maxDrawCount{ maxDrawCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawIndirectCount2InfoKHR( DrawIndirectCount2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawIndirectCount2InfoKHR( VkDrawIndirectCount2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawIndirectCount2InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DrawIndirectCount2InfoKHR & operator=( DrawIndirectCount2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawIndirectCount2InfoKHR & operator=( VkDrawIndirectCount2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setAddressRange( StridedDeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setCountAddressRange( DeviceAddressRangeKHR const & countAddressRange_ ) & VULKAN_HPP_NOEXCEPT + { + countAddressRange = countAddressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setCountAddressRange( DeviceAddressRangeKHR const & countAddressRange_ ) && VULKAN_HPP_NOEXCEPT + { + countAddressRange = countAddressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setCountAddressFlags( AddressCommandFlagsKHR countAddressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + countAddressFlags = countAddressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setCountAddressFlags( AddressCommandFlagsKHR countAddressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + countAddressFlags = countAddressFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR & setMaxDrawCount( uint32_t maxDrawCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCount2InfoKHR && setMaxDrawCount( uint32_t maxDrawCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawIndirectCount2InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCount2InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCount2InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawIndirectCount2InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressRange, addressFlags, countAddressRange, countAddressFlags, maxDrawCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawIndirectCount2InfoKHR const & ) const = default; +#else + bool operator==( DrawIndirectCount2InfoKHR 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 ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ) && + ( countAddressRange == rhs.countAddressRange ) && ( countAddressFlags == rhs.countAddressFlags ) && ( maxDrawCount == rhs.maxDrawCount ); +# endif + } + + bool operator!=( DrawIndirectCount2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDrawIndirectCount2InfoKHR; + void const * pNext = {}; + StridedDeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + DeviceAddressRangeKHR countAddressRange = {}; + AddressCommandFlagsKHR countAddressFlags = {}; + uint32_t maxDrawCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawIndirectCount2InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DrawIndirectCount2InfoKHR; + }; + // wrapper struct for struct VkDrawIndirectCountIndirectCommandEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCountIndirectCommandEXT.html struct DrawIndirectCountIndirectCommandEXT @@ -86715,6 +88617,180 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = MemoryMapPlacedInfoEXT; }; + // wrapper struct for struct VkMemoryMarkerInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMarkerInfoAMD.html + struct MemoryMarkerInfoAMD + { + using NativeType = VkMemoryMarkerInfoAMD; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMarkerInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryMarkerInfoAMD( PipelineStageFlags2KHR stage_ = {}, + DeviceAddressRangeKHR dstRange_ = {}, + AddressCommandFlagsKHR dstFlags_ = {}, + uint32_t marker_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stage{ stage_ } + , dstRange{ dstRange_ } + , dstFlags{ dstFlags_ } + , marker{ marker_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryMarkerInfoAMD( MemoryMarkerInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryMarkerInfoAMD( VkMemoryMarkerInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryMarkerInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + MemoryMarkerInfoAMD & operator=( MemoryMarkerInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryMarkerInfoAMD & operator=( VkMemoryMarkerInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD & setStage( PipelineStageFlags2KHR stage_ ) & VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD && setStage( PipelineStageFlags2KHR stage_ ) && VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD & setDstRange( DeviceAddressRangeKHR const & dstRange_ ) & VULKAN_HPP_NOEXCEPT + { + dstRange = dstRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD && setDstRange( DeviceAddressRangeKHR const & dstRange_ ) && VULKAN_HPP_NOEXCEPT + { + dstRange = dstRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD & setDstFlags( AddressCommandFlagsKHR dstFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dstFlags = dstFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD && setDstFlags( AddressCommandFlagsKHR dstFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dstFlags = dstFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD & setMarker( uint32_t marker_ ) & VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMarkerInfoAMD && setMarker( uint32_t marker_ ) && VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryMarkerInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMarkerInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMarkerInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryMarkerInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, dstRange, dstFlags, marker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryMarkerInfoAMD const & ) const = default; +#else + bool operator==( MemoryMarkerInfoAMD 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 ) && ( stage == rhs.stage ) && ( dstRange == rhs.dstRange ) && ( dstFlags == rhs.dstFlags ) && + ( marker == rhs.marker ); +# endif + } + + bool operator!=( MemoryMarkerInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryMarkerInfoAMD; + void const * pNext = {}; + PipelineStageFlags2KHR stage = {}; + DeviceAddressRangeKHR dstRange = {}; + AddressCommandFlagsKHR dstFlags = {}; + uint32_t marker = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryMarkerInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryMarkerInfoAMD; + }; + #if defined( VK_USE_PLATFORM_METAL_EXT ) // wrapper struct for struct VkMemoryMetalHandlePropertiesEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMetalHandlePropertiesEXT.html @@ -87062,6 +89138,402 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = MemoryPriorityAllocateInfoEXT; }; + // wrapper struct for struct VkMemoryRangeBarrierKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRangeBarrierKHR.html + struct MemoryRangeBarrierKHR + { + using NativeType = VkMemoryRangeBarrierKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRangeBarrierKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryRangeBarrierKHR( PipelineStageFlags2 srcStageMask_ = {}, + AccessFlags2 srcAccessMask_ = {}, + PipelineStageFlags2 dstStageMask_ = {}, + AccessFlags2 dstAccessMask_ = {}, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + DeviceAddressRangeKHR addressRange_ = {}, + AddressCommandFlagsKHR addressFlags_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcStageMask{ srcStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstStageMask{ dstStageMask_ } + , dstAccessMask{ dstAccessMask_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , addressRange{ addressRange_ } + , addressFlags{ addressFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryRangeBarrierKHR( MemoryRangeBarrierKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryRangeBarrierKHR( VkMemoryRangeBarrierKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryRangeBarrierKHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryRangeBarrierKHR & operator=( MemoryRangeBarrierKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryRangeBarrierKHR & operator=( VkMemoryRangeBarrierKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setAddressRange( DeviceAddressRangeKHR const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR & setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) & VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarrierKHR && setAddressFlags( AddressCommandFlagsKHR addressFlags_ ) && VULKAN_HPP_NOEXCEPT + { + addressFlags = addressFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryRangeBarrierKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRangeBarrierKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRangeBarrierKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryRangeBarrierKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, addressRange, addressFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryRangeBarrierKHR const & ) const = default; +#else + bool operator==( MemoryRangeBarrierKHR 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 ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( addressRange == rhs.addressRange ) && ( addressFlags == rhs.addressFlags ); +# endif + } + + bool operator!=( MemoryRangeBarrierKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryRangeBarrierKHR; + void const * pNext = {}; + PipelineStageFlags2 srcStageMask = {}; + AccessFlags2 srcAccessMask = {}; + PipelineStageFlags2 dstStageMask = {}; + AccessFlags2 dstAccessMask = {}; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + DeviceAddressRangeKHR addressRange = {}; + AddressCommandFlagsKHR addressFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryRangeBarrierKHR; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryRangeBarrierKHR; + }; + + // wrapper struct for struct VkMemoryRangeBarriersInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRangeBarriersInfoKHR.html + struct MemoryRangeBarriersInfoKHR + { + using NativeType = VkMemoryRangeBarriersInfoKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRangeBarriersInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryRangeBarriersInfoKHR( uint32_t memoryRangeBarrierCount_ = {}, + MemoryRangeBarrierKHR const * pMemoryRangeBarriers_ = {}, + void const * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryRangeBarrierCount{ memoryRangeBarrierCount_ } + , pMemoryRangeBarriers{ pMemoryRangeBarriers_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryRangeBarriersInfoKHR( MemoryRangeBarriersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryRangeBarriersInfoKHR( VkMemoryRangeBarriersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryRangeBarriersInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MemoryRangeBarriersInfoKHR( ArrayProxyNoTemporaries const & memoryRangeBarriers_, void const * pNext_ = nullptr ) + : pNext( pNext_ ), memoryRangeBarrierCount( static_cast( memoryRangeBarriers_.size() ) ), pMemoryRangeBarriers( memoryRangeBarriers_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + MemoryRangeBarriersInfoKHR & operator=( MemoryRangeBarriersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryRangeBarriersInfoKHR & operator=( VkMemoryRangeBarriersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR & setPNext( void const * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR && setPNext( void const * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR & setMemoryRangeBarrierCount( uint32_t memoryRangeBarrierCount_ ) & VULKAN_HPP_NOEXCEPT + { + memoryRangeBarrierCount = memoryRangeBarrierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR && setMemoryRangeBarrierCount( uint32_t memoryRangeBarrierCount_ ) && VULKAN_HPP_NOEXCEPT + { + memoryRangeBarrierCount = memoryRangeBarrierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR & setPMemoryRangeBarriers( MemoryRangeBarrierKHR const * pMemoryRangeBarriers_ ) & VULKAN_HPP_NOEXCEPT + { + pMemoryRangeBarriers = pMemoryRangeBarriers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryRangeBarriersInfoKHR && setPMemoryRangeBarriers( MemoryRangeBarrierKHR const * pMemoryRangeBarriers_ ) && VULKAN_HPP_NOEXCEPT + { + pMemoryRangeBarriers = pMemoryRangeBarriers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MemoryRangeBarriersInfoKHR & setMemoryRangeBarriers( ArrayProxyNoTemporaries const & memoryRangeBarriers_ ) VULKAN_HPP_NOEXCEPT + { + memoryRangeBarrierCount = static_cast( memoryRangeBarriers_.size() ); + pMemoryRangeBarriers = memoryRangeBarriers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryRangeBarriersInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRangeBarriersInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRangeBarriersInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryRangeBarriersInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRangeBarrierCount, pMemoryRangeBarriers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryRangeBarriersInfoKHR const & ) const = default; +#else + bool operator==( MemoryRangeBarriersInfoKHR 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 ) && ( memoryRangeBarrierCount == rhs.memoryRangeBarrierCount ) && + ( pMemoryRangeBarriers == rhs.pMemoryRangeBarriers ); +# endif + } + + bool operator!=( MemoryRangeBarriersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryRangeBarriersInfoKHR; + void const * pNext = {}; + uint32_t memoryRangeBarrierCount = {}; + MemoryRangeBarrierKHR const * pMemoryRangeBarriers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryRangeBarriersInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryRangeBarriersInfoKHR; + }; + // wrapper struct for struct VkMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRequirements.html struct MemoryRequirements { @@ -104505,6 +106977,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; }; + // wrapper struct for struct VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR.html + struct PhysicalDeviceDeviceAddressCommandsFeaturesKHR + { + using NativeType = VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR; + + static bool const allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceAddressCommandsFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceAddressCommandsFeaturesKHR( Bool32 deviceAddressCommands_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceAddressCommands{ deviceAddressCommands_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDeviceAddressCommandsFeaturesKHR( PhysicalDeviceDeviceAddressCommandsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceAddressCommandsFeaturesKHR( VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceAddressCommandsFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceAddressCommandsFeaturesKHR & operator=( PhysicalDeviceDeviceAddressCommandsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceAddressCommandsFeaturesKHR & operator=( VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceAddressCommandsFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceAddressCommandsFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceAddressCommandsFeaturesKHR & setDeviceAddressCommands( Bool32 deviceAddressCommands_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddressCommands = deviceAddressCommands_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceAddressCommandsFeaturesKHR && setDeviceAddressCommands( Bool32 deviceAddressCommands_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddressCommands = deviceAddressCommands_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddressCommands ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceAddressCommandsFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceAddressCommandsFeaturesKHR 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 ) && ( deviceAddressCommands == rhs.deviceAddressCommands ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceAddressCommandsFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceAddressCommandsFeaturesKHR; + void * pNext = {}; + Bool32 deviceAddressCommands = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceAddressCommandsFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceAddressCommandsFeaturesKHR; + }; + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.html struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV @@ -173453,13 +176049,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE return std::move( *this ); } - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setAddressRange( DeviceAddressRangeEXT addressRange_ ) & VULKAN_HPP_NOEXCEPT { addressRange = addressRange_; return *this; } - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setAddressRange( DeviceAddressRangeEXT addressRange_ ) && VULKAN_HPP_NOEXCEPT { addressRange = addressRange_; return std::move( *this ); diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index fead740..4c6f0ca 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -3578,6 +3578,31 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_METAL_EXT*/ + //=== VK_KHR_device_address_commands === + + VULKAN_HPP_INLINE std::string to_string( AddressCommandFlagsKHR value ) + { + std::string result = "{"; + if ( value & AddressCommandFlagBitsKHR::eProtected ) + result += " Protected |"; + if ( value & AddressCommandFlagBitsKHR::eFullyBound ) + result += " FullyBound |"; + if ( value & AddressCommandFlagBitsKHR::eStorageBufferUsage ) + result += " StorageBufferUsage |"; + if ( value & AddressCommandFlagBitsKHR::eUnknownStorageBufferUsage ) + result += " UnknownStorageBufferUsage |"; + if ( value & AddressCommandFlagBitsKHR::eTransformFeedbackBufferUsage ) + result += " TransformFeedbackBufferUsage |"; + if ( value & AddressCommandFlagBitsKHR::eUnknownTransformFeedbackBufferUsage ) + result += " UnknownTransformFeedbackBufferUsage |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + //=== VK_EXT_graphics_pipeline_library === VULKAN_HPP_INLINE std::string to_string( GraphicsPipelineLibraryFlagsEXT value ) @@ -5237,6 +5262,22 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE case StructureType::eDescriptorBufferBindingInfoEXT : return "DescriptorBufferBindingInfoEXT"; case StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT : return "DescriptorBufferBindingPushDescriptorBufferHandleEXT"; case StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT : return "AccelerationStructureCaptureDescriptorDataInfoEXT"; + case StructureType::eDeviceMemoryCopyKHR : return "DeviceMemoryCopyKHR"; + case StructureType::eCopyDeviceMemoryInfoKHR : return "CopyDeviceMemoryInfoKHR"; + case StructureType::eDeviceMemoryImageCopyKHR : return "DeviceMemoryImageCopyKHR"; + case StructureType::eCopyDeviceMemoryImageInfoKHR : return "CopyDeviceMemoryImageInfoKHR"; + case StructureType::eMemoryRangeBarriersInfoKHR : return "MemoryRangeBarriersInfoKHR"; + case StructureType::eMemoryRangeBarrierKHR : return "MemoryRangeBarrierKHR"; + case StructureType::ePhysicalDeviceDeviceAddressCommandsFeaturesKHR : return "PhysicalDeviceDeviceAddressCommandsFeaturesKHR"; + case StructureType::eBindIndexBuffer3InfoKHR : return "BindIndexBuffer3InfoKHR"; + case StructureType::eBindVertexBuffer3InfoKHR : return "BindVertexBuffer3InfoKHR"; + case StructureType::eDrawIndirect2InfoKHR : return "DrawIndirect2InfoKHR"; + case StructureType::eDrawIndirectCount2InfoKHR : return "DrawIndirectCount2InfoKHR"; + case StructureType::eDispatchIndirect2InfoKHR : return "DispatchIndirect2InfoKHR"; + case StructureType::eConditionalRenderingBeginInfo2EXT : return "ConditionalRenderingBeginInfo2EXT"; + case StructureType::eBindTransformFeedbackBuffer2InfoEXT : return "BindTransformFeedbackBuffer2InfoEXT"; + case StructureType::eMemoryMarkerInfoAMD : return "MemoryMarkerInfoAMD"; + case StructureType::eAccelerationStructureCreateInfo2KHR : return "AccelerationStructureCreateInfo2KHR"; case StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : return "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"; case StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : return "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"; case StructureType::eGraphicsPipelineLibraryCreateInfoEXT : return "GraphicsPipelineLibraryCreateInfoEXT"; @@ -6911,6 +6952,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineLayoutCreateFlagBits value ) + { + switch ( value ) + { + case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineShaderStageCreateFlagBits value ) { switch ( value ) @@ -6921,15 +6971,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineLayoutCreateFlagBits value ) - { - switch ( value ) - { - case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BorderColor value ) { switch ( value ) @@ -7336,6 +7377,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineColorBlendStateCreateFlagBits value ) + { + switch ( value ) + { + case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDepthStencilStateCreateFlagBits value ) + { + switch ( value ) + { + case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; + case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PolygonMode value ) { switch ( value ) @@ -7367,25 +7427,6 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } } - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineColorBlendStateCreateFlagBits value ) - { - switch ( value ) - { - case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDepthStencilStateCreateFlagBits value ) - { - switch ( value ) - { - case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; - case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlagBits ) { return "(void)"; @@ -9868,6 +9909,22 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE } #endif /*VK_USE_PLATFORM_METAL_EXT*/ + //=== VK_KHR_device_address_commands === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AddressCommandFlagBitsKHR value ) + { + switch ( value ) + { + case AddressCommandFlagBitsKHR::eProtected : return "Protected"; + case AddressCommandFlagBitsKHR::eFullyBound : return "FullyBound"; + case AddressCommandFlagBitsKHR::eStorageBufferUsage : return "StorageBufferUsage"; + case AddressCommandFlagBitsKHR::eUnknownStorageBufferUsage : return "UnknownStorageBufferUsage"; + case AddressCommandFlagBitsKHR::eTransformFeedbackBufferUsage : return "TransformFeedbackBufferUsage"; + case AddressCommandFlagBitsKHR::eUnknownTransformFeedbackBufferUsage: return "UnknownTransformFeedbackBufferUsage"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_EXT_graphics_pipeline_library === VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GraphicsPipelineLibraryFlagBitsEXT value )